Java内部类和常用类

内部类

概念:在一个类的内部在定义一个完整的类,与实例变量,实例方法同级别的类

特点:

• 编译后可生成独立的字节码文件
• 内部类可以直接访问外部类的私有成员,而不破坏封装
• 可为外部类提供必要功能组件

内部类分类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

成员内部类

外部类的一个实例部分,创建内部类时,必须依赖外部类对象

当外部类,内部类存在重名属性时,会优先访问内部类属性

内部类不能定义静态成员

创建内部类

外部类.内部类 实例化名称 = new 外部类().new 内部类();
实例化.方法();

属性重复时在内部类调用外部属性

外部类名.this.外部属性名					

内部类使用实例

package Inner_classes;
//import Inner_classes.Demo01.inner;
public class main {
    public static void main(String[] args) {
//        inner inner = new Demo01().new inner();   //创建内部类对象,需要导包
//        inner.show();
           Demo01.inner inner = new Demo01().new inner();   //创建内部类对象,不需要导包
           inner.show();
    }
}

package Inner_classes;
//外部类
public class Demo01 {
    private String name = "张杰";
    private int age = 21;
    class inner{       //内部类
        private String name = "张三";
        private String address = "安徽";
        private char sex = '男';
        public void show(){ //方法
            System.out.println(Demo01.this.name);	//属性重复时调用外部属性
            System.out.println(name);
            System.out.println(age);
            System.out.println(address);
            System.out.println(sex);
        }
    }
}

静态内部类

static关键字

不依赖外部类对象,可以直接创建或通过类名访问

只有内部类可以使用static修饰

静态内部内的调用方法

外部类.内部类 实例名 = new 外部类.内部类();
实例名.方法();

静态内部类内的静态属性

内部类.属性名

使用实例

package com.Demo02;
public class Application {
    public static void main(String[] args) {
        staticClass.Inner inner = new staticClass.Inner();
        inner.show();
    }
}

package com.Demo02;
//外部类
public class staticClass {
    private String name = "张杰";
    private String address = "安徽";
    static class Inner{ //静态内部类,级别和外部类相同
        private String add  = "北京";
        private static int count  = 123;
        public void show(){
            staticClass out = new staticClass();
            System.out.println(out.name);   //调用外部类属性
            System.out.println(out.address);    //调用外部类属性
            System.out.println(add);        //调用内部类属性
            System.out.println(Inner.count);    //调用外部类静态属性
        }
    }
}

局部内部类

定义在外部类的方法中,作用范围和对象仅限于当前方法

局部内部类不可以添加任何访问修饰符

局部内部类访问外部类当前方法中的局部变量时,因为无法保障变量的生命周期与自身相同,变量必须全部修饰为final

局部内部类需要创建局部内部类对象来调用局部内部类中方法

在方法中

内部类名 使用名 = new 内部类名();

使用实例

package com.Demo03;
//局部内部类
public class Application {
    public static void main(String[] args) {
        Local_nner_classes classes = new Local_nner_classes();
        classes.show();
    }
}

package com.Demo03;

public class Local_nner_classes {
    private String name = "张杰";
    private int age = 21;
        public void show(){
        String add = "安徽";  //局部变量
        class Inner{        //局部内部类,不可以添加任何访问修饰符
            private int count = 199;
            private String sex = "男";
            public void show2(){
                System.out.println(name);       //访问外部类属性
                System.out.println(age);        //访问外部类属性
                System.out.println(add);        //jdk1.8自动添加final,不可修改
                System.out.println(count);      //访问内部类属性
                System.out.println(sex);        //访问内部类属性
            }
        }
        Inner inner = new Inner();      //创建局部内部类对象来调用show2
        inner.show2();
    }
}

匿名内部类

无类名的局部内部类(特征都与局部类相同)

必须继承一个父类或者实现一个接口

定义类,实现类,创建对象的语法合并,只能创建一个该类的对象

优点:减少代码量;缺点:可读性差

匿名内部类的使用

    Usb usb = new Usb() {
        @Override
        public void service() {
            System.out.println("链接电脑成功");
        }
    };

使用实例

package com.Demo04;
//匿名内部类
public class Application {
    public  static void main(String[] args) {
//        Usb usb = new Mouse();
//        usb.service();
        class Fan implements Usb {
            @Override
            public void service() {
                System.out.println("链接电脑成功");
            }
        }
//        Usb usb = new Fan();    //使用局部内部类
//        usb.service();
        //使用匿名内部类优化,想当于创建了一个局部内部类
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("链接电脑成功");
            }
        };
        usb.service();
    }
}

常用类

Object类

超类.基类.所有类的直接或者间接父类,位于继承树的最顶层

任何类,如果没有书写extend显示继承某个类,都默认直接继承Object类,否则为间接继承

Object类中所定义的方法,是所有对象都具备的方法

Object类型可以存储任何对象;作为参数,可以接受任何对象,作为返回值,可返回任何对象

getClass()方法

public final Class<?> getClass(){}

返回引用中存储的实际对象类型

应用:通常用于判断两个引用中实际储存对象类型是否一致

使用

Class classstu1 = stu1.getClass();
Class classstu2 = stu2.getClass();
if (classstu1 == classstu2){
    System.out.println("stu1,2属于同一个类型");
}else {
    System.out.println("stu1,2不属于同一个类型");
}

hashCode()方法

public int hashCode(){}

返回对象的哈希码值

哈希码值根据对象的地址或字符串或数字使用hash算法计算出的int类型的数值

一般情况下相同对象返回相同哈希码值

对象.hashCode();

toString()方法

public String toString(){}

返回对象的字符串表示

可以根据程序要求重写toSrting方法,例如展示对象的各个属性值

对象.toString();

equals()方法

public boolean equals(Object ibj){}

默认实现为(this = = obj),比较两个对象地址是否相同

可以进行覆盖,比较两个对象内容是否相同

返回true和false

对equals进行覆盖步骤

比较两个引用是否指向同一个对象

判断obj是否为null

判断两个引用指向的实际类型对象是否一致

强制类型转换

依次比较各个属性值是否相同

next finalize