内部类概述

定义在一个类里面的类就是内部类。
可以提供更好的封装性, 内部类有更多权限修饰符 , 封装性有更多的控制。
可以体现出组件的思想。

静态内部类

有static修饰，属于外部类本身，只会加载一次
静态内部类与它的外部类（和其他类）的实例成员进行交互，就像其他任何顶级类一样。实际上，静态嵌套类在行为上是顶级类，为了包装方便，该顶级类已嵌套在另一个顶级类中。
静态内部类访问格式
- 外部类名称.内部类名称
静态内部类创建对象的格式
- 外部类名称.内部类名称对象名称 = new 外部类名称.内部类名称
静态内部类的访问扩展：
- 静态内部类中是否可以直接访问外部类的静态成员?可以的，外部类的静态成员只有一份，可以被共享；
- 静态内部类中是否可以直接访问外部类的实例成员?不可以的,外部类的是成员必须用外部类对象访问。

public class InnerClass {
    public static void main(String[] args) {
        // 外部类名称.内部类名称 对象名称 = new 外部类名称.内部类构造器
        Outter.Inner in = new Outter.Inner();
        in.setName("张三");
        in.setAge(12);
        System.out.println(in.getName());
        System.out.println(in.getAge());
        in.show();
    }
}

class Outter{
    public static int age1 = 12;
    private double salary;

    // 静态内部类：有static修饰，属于外部类本身，只会加载一次
    public static class Inner{
        private String name;
        private int age;
        public static String schoolName = "黑马";

        public void show() {
            System.out.println(name+"-->"+age+"岁~");
            System.out.println(age1);
            //System.out.println(salary);
        }

        public Inner() {
        }

        public Inner(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }
}

实例内部类（成员内部类）

无static修饰的内部类，属于外部类的每个对象的，跟着对象一起加载。
实例内部类中不能定义静态成员，其他都可以定义
实例内部类的访问格式：
- 外部类名称.内部类名称
创建对象的格式：
- 外部类名称.内部类名称对象名称 = 外部类对象.new 内部类构造器;
扩展:
- 实例内部类中是否可以直接访问外部类的静态成员？可以的，外部类的静态成员可以被共享访问！
- 实例内部类中是否可以访问外部类的实例成员？可以的，实例内部类属于外部类对象，可以直接访问当前外部类对象的实例成员！

public class InnerClass {
    public static void main(String[] args) {
        // 实例内部类属于外部类对象。实例内部类的宿主是外部类对象！！
        Outter out = new Outter();
        Outter.Inner in = out.new Inner();
        Outter.Inner in1 = out.new Inner();
        in.show();
        in1.show();
    }
}
// 外部类
class Outter{
    public static int age = 1;
    private double salary;

    // 实例内部类：无static修饰，属于外部类的对象
    public class Inner{
        private String name ;

        public static final String schoolName = "黑马";
        // 不能在实例内部类中定义静态成员！！！
//      public static String schoolName = "黑马";
//      public static void test(){
//
//      }

        // 实例方法
        public void show(){
            System.out.println(name+"名称！");
            System.out.println(age);
            System.out.println(salary);
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
}

匿名内部类

匿名内部类是一个没有名字的内部类，其目的是为了简化代码，也是开发中常用的形式。
匿名内部类的格式:
匿名内部类的特点：
- 1. 匿名内部类是一个没有名字的内部类；
- 1. 匿名内部类一旦写出来，就会立即创建一个匿名内部类的对象返回；
- 1. 匿名内部类的对象类型相当于是当前new的那个类型的子类型。

public class Anonymity{
    public static void mian(String[] args){
        Animal a = new Animal(){
            @Override
            public void run(){
                System.out.println("猫跑的贼溜~~");
            }
        }；
        a.run();
        a.go();
    }
        Animal a1 = new Animal(){
          @Override
          public void run(){
              System.out.println("狗跑的贼快~~");    
          }
       }；
        a1.run();
        a1.go();
}
abstract class Animal{
    public abstract void run();
    public void go() {System.out.println("开始go~~~")};
}

匿名内部类的使用

/**
    目标： 匿名内部类的使用形式。(关注语法)
    需求：很多角色要一起参加游泳比赛（老师，学生，运动员）
 */
public class Anonymity02{
    public static void main(String[] args){
        //写法一
        Swim student = new Swim(){
            @Override
            public void swimming(){System.out.println("学生游泳")}；
        };
        go(student);

       //写法二
      go(new Swim(){
              @override
              public void swimming(){System.out.println("老师游泳")};
          }
      );
    }

    public static void go(Swim s){
        System.out.println("Start!");
        s.swimming();
        System.out.println("End!");
    }
}
interface Swim{
    void swimming();
}