Java内部类

内部类

• 内部类访问特点：
  1、内部类可以直接访问外部类成员，包括私有
  2、外部类要访问内部类的成员，必须创建对象
  Test类：

public class Test {
    public static void main(String[] args) {
        Car c = new Car();
        c.carAge = 1;
        c.carName = "宾利";
        c.carColor = "粉色";
        c.show();
    }
}

Car类：

public class Car {
    String carName;
    int carAge;
    String carColor;
    public void show(Car this){
        System.out.println(this.carName);
        Engine e = new Engine();//实例化内部类对象
        System.out.println(e.engineName);
    }
    class Engine{
        String engineName;
        int engineAge;
        public void show(){
            System.out.println(engineAge);
            System.out.println(carName);
        }
    }
}

• 内部类分类：
  1、成员内部类
  2、静态内部类
  3、局部内部类
  4、匿名内部类

成员内部类

1、成员内部类注意事项：

• 写在成员位置的，属于外部类的成员
• 成员内部类可以被一些修饰符所修饰，比如：private，默认，protect，public，static等
• 在成员内部类里面JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。

2、获取成员内部类对象的两种方式：
方式1：外部类编写方法，对外提供内部类对象
方式2：直接创建
格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
范例：Outer.Inner oi = new Outer().new Inner();
Test类

public class Test1 {
    public static void main(String[] args) {
        //创建内部类的对象，并调用show方法
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

Outer类

public class Outer {
    private int a = 10;
    class Inner{
        private int a = 20;
        public void show(){
            int a = 30;
            //Outer.this获取了外部类对象的地址值
            System.out.println(Outer.this.a);//10
            System.out.println(this.a);//20
            System.out.println(a);//30
        }
    }
}

静态内部类和局部内部类

1、静态内部类注意事项：

• 静态内部类也是成员内部类的一种
• 静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象

2、创建静态内部类对象的格式：
外部类名.内部类名 对象名 = new 外部类名.内部类名();

3、调用静态方法的格式：
外部类名.内部类名.方法名();

4、局部内部类
1、将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量
2、外界是无法直接使用局部内部类，需要在方法内部创建对象并使用
3、该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

匿名内部类（重要）

• 匿名内部类本质上就是隐藏了名字的内部类,可以写在成员位置，也可以写在局部位置
  格式：

new 类名或者接口名(){
重写方法;
};

• 格式的细节：
  包含了继承或实现，方法重写，创建对象。整体就是一个类的子类对象或者接口的实现类对象

• 使用场景：
  当方法的参数是接口或者类时，以接口为例，可以传递这个接口的实现类对象，如果实现类只要使用一次，就可以用匿名内部类简化代码。

public interface Swim {
    public abstract void swim();
}

public abstract class Animal {
    public abstract void eat();
}

public class Test2 {
    public static void main(String[] args) {
        new Swim(){
            @Override
            public void swim() {
                System.out.println("重写了游泳的方法");
            }
        }.swim();//可以调用方法

        new Animal(){
            @Override
            public void eat() {
                System.out.println("重写了吃东西的方法");
            }
        };
    }
}