内部类

内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）。

public class People{
    // 内部类    
    public class Heart{    
    }
}

内部类的使用场景
场景：当一个事物的内部，还有一个部分需要一个完整的结构进行描述时。
基本作用
内部类通常可以方便访问外部类的成员，包括私有的成员。
内部类提供了更好的封装性，内部类本身就可以用private ，protectecd等修饰，封装性可以做更多控制。

静态内部类

有static修饰，属于外部类本身。
它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已。

public class Outer {
    private String hobby;
    public static class Inner{
        private String name;
        public Inner(){
        }
    }
 public Outer(){
        }
}

静态内部类创建对象的格式：
格式：外部类名.内部类名对象名 = new 外部类名.内部类构造器;
Outer.Inner in = new Outer.Inner();

1、静态内部类中是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
2、静态内部类中是否可以直接访问外部类的实例成员？
不可以的，外部类的实例成员必须用外部类对象访问。

如果一个类中包含了一个完整的成分，如汽车类中的发动机类。
特点、使用与普通类是一样的，类有的成分它都有，只是位置在别人里面而已。
访问总结：可以直接访问外部类的静态成员，不能直接访问外部类的实例成员。
注意：开发中实际上用的还是比较少。

成员内部类
无static修饰，属于外部类的对象。
JDK16之前，成员内部类中不能定义静态成员，JDK 16开始也可以定义静态成员了。

public class Outer {
// 成员内部类
public class Inner {
}
}

成员内部类创建对象的格式：
格式：外部类名.内部类名对象名 = new 外部类构造器.new 内部类构造器();

范例：Outer.Inner in = new Outer().new Inner();

1、成员内部类中是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
2、成员内部类的实例方法中是否可以直接访问外部类的实例成员？
可以的，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员

public class Test2 {
    public static void main(String[] args) {
        People.Heart heart = new People().new Heart();
        heart.show();
    }
}
class People{
    private int heartbeat = 150;
 
    /**
       成员内部类
     */
    public class Heart{
        private int heartbeat = 110;
 
        public void show(){
            int heartbeat = 78;
            System.out.println(heartbeat); // 78
            System.out.println(this.heartbeat); // 110
            System.out.println(People.this.heartbeat); // 150
        }
    }
}

匿名内部类

本质上是一个没有名字的局部内部类。
作用：方便创建子类对象，最终目的是为了简化代码编写。

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

Employee a = new Employee() {   
     public void work() {  
     }
     };
相当于
a. work();

没有内部类之前我们是这么编写代码

动物抽象类

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

老虎类

public class Tiger extends Animal{
    @Override
    public void run() {
        System.out.println("老虎跑的块~~~");
    }
}

测试类

public class Test {
 
    public static void main(String[] args) {
       Animal a = new Tiger();
        a.run();
    }
}

有了内部类之后我们这样编写

比如animal 有个抽象方法我们不能直接new animal

但我们可以这么写这就是匿名内部类

public class Test1 {
    public static void main(String[] args) {
        new Animal(){
            @Override
            public void run() {
                System.out.println("老虎跑的块~~~");
            }
        };
    }
}

匿名内部类应用

某个学校需要让老师，学生，运动员一起参加游泳比赛

package com.itheima.d8_innerclass_anonymous;
 
/**
    目标：掌握匿名内部类的使用形式（语法）
 */
public class Test2 {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生快乐的自由泳🏊‍");
            }
        };
        go(s);
        System.out.println("--------------");
 
        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师泳🏊的贼快~~~~~");
            }
        };
        go(s1);
 
        System.out.println("--------------");
 
        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("运动员🏊的贼快啊~~~~~");
            }
        });
    }
 
    /**
       学生 老师 运动员可以一起参加游泳比赛
     */
    public static void go(Swimming s){
        System.out.println("开始。。。");
        s.swim();
        System.out.println("结束。。。");
    }
}
 
 
interface Swimming{
    void swim();
}