内部类

介绍：将一个类定义在另一个类或者方法里面，这样的类称之为内部类

分类
一、成员内部类
1.内部类在外部使用时，无法直接实例化，需要借助外部类信息才能实例化
2.内部类可以添加任意访问修饰符
3.内部类可以直接访问外部类的成员，如果出现重名属性，优先访问内部类定义的
4.可以使用外部类.this.成员的方式，访问外部类中同名的属性
5.外部类访问内部类，需要通过内部类实例，无法直接访问
6.内部类编译后.class文件命名：外部内$内部类.class

2.方法内部类
1.定义在方法内部，作用范围也在方法内
2.和方法内部成员一样，class前面不可以添加访问修饰符(public...等)
3.类中不能包含静态成员
4.类中可以包含final，abstract修饰符的成员(一般不建议)

3.静态内部类
1.静态内部类中，只能访问外部类中的静态成员，如果需要访问非静态成员，可以通过实例对象
2.静态内部类对象实例时，可以不依赖外部内部类
3.可以通过外部类.内部类.静态成员的方式，访问内部类中的静态成员
4.当静态内部类与外部内部类属性同名时，默认直接调用内部类中的成员，如需访问外部类中的静态成员，则可以通过外部内部类.属性的方式；如果访问外部非静态属性，则可以通过 new 外部类().属性的方式

4.匿名内部类
1.匿名内部类没有类型名称、对象实例名称
2.编译后的文件命名：外部类$数字.class
3.无法使用访问修饰符（public等）
4.无法编写构造方法，但是可以使用构造代码块
5.不能出现静态成员
6.可以实现接口也可以继承父类，但是无法兼得

public class Person {
    int age;
    
    public void eat() {
        return "吃东西";
    }
    
    public Heart getHeart() {
        return new Heart();
    }
    
    //成员内部类
    //1.内部类在外部使用时，无法直接实例化，需要借助外部类信息才能实例化
    //2.内部类可以添加任意访问修饰符
    //3.内部类可以直接访问外部类的成员，如果出现重名属性，优先访问内部类定义的
    //4.可以使用外部类.this.成员的方式，访问外部类中同名的属性
    //5.外部类访问内部类，需要通过内部类实例，无法直接访问
    //6.内部类编译后.class文件命名：外部内$内部类.class
    class Heart() {
        int age = 13;
    
        public String beat() {
            eat();
            //return age + "岁的心脏在跳动"; 可以直接访问外部的变量
            return Person.this.age + "岁的心脏在跳动";
       }
    }
    
    //静态内部类
    //1.静态内部类中，只能访问外部类中的静态成员，如果需要访问非静态成员，可以通过实例对象
    //2.静态内部类对象实例时，可以不依赖外部内部类
    //3.可以通过 外部类.内部类.静态成员 的方式，访问内部类中的静态成员
    //4.当静态内部类与外部内部类属性同名时，默认直接调用内部类中的成员，如需访问外部类中的静态成员，则可以通过 外部内部类.属性 的方式；如果访问外部非静态属性，则可以通过 new 外部类().属性 的方式
    static class Heart() {
        public static int age = 13;
        int temp = 22;
        public static void say() {
            return "hei";
        }
        public String beat() {
            new Parson().eat();
            return Person.age + "岁的心脏在跳动";
       }
    }
    
    //方法内部类
    //1.定义在方法内部，作用范围也在方法内
    //2.和方法内部成员一样，class前面不可以添加访问修饰符(public...等)
    //3.类中不能包含静态成员
    //4.类中可以包含final，abstract修饰符的成员(一般不建议)
    public Object getHeart() {
        class Heart() {
            public final int age = 13;
            int temp = 22;
            public final void say() {
                return "hei";
            }
            public String beat() {
                new Parson().eat();
                return Person.age + "岁的心脏在跳动";
           }
        }
        return new Heart.beat();
    }
}

public class PersonTest {
    Person xiaomei = new Person();
    xiaomei.age = 18;
    
    //获取成员内部类对象实例
    //1.new外部类.new内部类
    Person.Heart myHeart = new Person().new Heart();
    myHeart.beat();
    
    //2.外部类.new内部类
    myHeart = xiaomei.new Heart();
    myHeart.beat();
    
    //3.外部对象.获取方法
    myHeart = xiaomei.getHeart();
    myHeart.beat();
    
    //获取静态内部类对象实例
    Person.Heart myHeart = new Person.Heart();
    myHeart.beat();
    Person.Heart.say();
    
    //获取方法内部类对象实例
    xiaomei.getHeart();
    
    //匿名内部类
    //1.匿名内部类没有类型名称、对象实例名称
    //2.编译后的文件命名：外部类$数字.class
    //3.无法使用访问修饰符（public等）
    //4.无法编写构造方法，但是可以使用构造代码块
    //5.不能出现静态成员
    //6.可以实现接口也可以继承父类，但是无法兼得
    PersonTestOne to = new PersonTestOne();
    to.getRead(new Person() {
        {
            构造代码块
        }
        
        @Override
        public void read() {
            return "读书";
        }
    })
}

Java-内部类

内部类