标签：外部   常量   成员   内存耗尽   自身   通知   自动   parse   继承   

Java内部类

一.内部类

内部类分为：

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

内部类在编译时也可以生成独立的字节码（class）文件；
内部类可以直接访问外部类的私有成员，而不破坏封装；

成员内部类

在类的内部定义，与实例变量，实例方法同级别的类
创建内部类对象时，必须依赖外部类的对象

• Outer out=new Outer()
• Inner in=out.new Inner()

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

package oop;

public class Test {
    private String name="邓文雄";
    class Header {
        private String name="张三";
        public void print() {
            System.out.println(name);//打印内部类的属性
            System.out.println(Test.this.name);//打印外部类的重名属性
        }
    }
    public static void main(String[] args) {
        Header s2=new Test().new Header();//创建内部类对象
        s2.print();
    }
}

成员内部类不能定义静态成员（可以定义静态常量）

静态内部类

不依赖外部类对象，可以直接创建或通过类名访问，可声明静态成员，跟外部类同级；
只能直接访问外部类的静态成员（实例成员需要实例化外部类对象）

创建：

• Outer.Inner inner=new Outer.Inner()

局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法；
局部内部类访问外部类当前方法中的局部变量是，因无法保障变量的生命周期与自身相同，变量必须修饰为final

package oop;

public class Test {
    private String name="的吧";
    public void show(){
        //定义局部内部类
        class Inner{
            private int age =12;
            public void print(){
                System.out.println(name);
                System.out.println(age);
            }
        }
        //创建局部内部类对象
        Inner s=new Inner();
        s.print();
    }

    public static void main(String[] args) {
     Test s2=new Test();
     s2.show();
    }
}

匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）
• 必须继承一个父类或实现一个接口

Object类

所有类的父类

getclass()方法

返回引用中存储的实际对象类型;通常用于判断两个引用中实际存储对象类型是否一致；

hashCode()方法

返回该对象的哈希码值，地址

toString()方法

返回该对象的字符串表示；可以重写该方法

equals()方法

比较两个对象的地址相不相同

finalize()方法

• 当对象被判断为垃圾对象时，有JVM自动调用此方法，用以标记垃圾对象，进入回收队列；

• 垃圾对象：没有有效引用指向此对象时，为垃圾对象；
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
• 自动回收机制：JVM的内存耗尽时，一次性回收所以垃圾对象
• 手动回收机制：使用System.gc();通知JVM执行垃圾回收

二.类型转换与装箱拆箱

package oop;

public class Test {
    public static void main(String[] args) {
        //类型转换：装箱；基本类型转换为引用类型；
        int num1=19;
        //使用Integer创建对象
        Integer integer1=new Integer(num1);
        Integer integer2=Integer.valueOf(num1);
        //类型转换：拆箱；引用类型转换为基本类型
        Integer integer3=new Integer(100);
        int num2=integer3.intValue();
        //JDK1.5后的自动装箱和拆箱
        int num4=90;
        Integer integer4=num4;
        Integer integer5=new Integer(80);
        int num5=integer5;

    }
}

parse...()方法将字符串转换为基本类型

三.Integer数据缓冲区

package oop;

public class Test {
    public static void main(String[] args) {
         
          Integer integer1=new Integer(100);
          Integer integer2=new Integer(100);
          //false
          System.out.println(integer1==integer2);
          //当integer的值大于-128，小于127时，调用valueof进行自动装箱，使用缓冲区进行；否则使用new Integer()进行自动装箱
          Integer integer3=100;
          Integer integer4=100;
          //true
          System.out.println(integer3==integer4);
          Integer integer5=128;
          Integer integer6=128;
          //false
          System.out.println(integer5==integer6);

    }
}

内部类

标签：外部   常量   成员   内存耗尽   自身   通知   自动   parse   继承   

原文地址：https://www.cnblogs.com/python-road/p/13220832.html