面向对象高级（三）内部类`

内部类

*是类中的五大成分之一（成员变量，方法，构造器，内部类，代码块），如果一个类定义在另一个类内部，这个类就是内部类。

场景：当一个类的内部，包含了一个完整的事务，且这个事务没有必要单独设计时，就可以把这个事物设计成内部类

|--------------------------------------------------|
| public class Car{ //内部类 public class Engine{ } } |

内部类有四种形式：成员内部类、静态内部类、局部内部类、匿名内部类

成员内部类：

就是类中的一个普通成员，类似于我们之前学过的普通的成员变量，成员方法

格式：

|---------------------------------------------|
| public class a{ //成员内部类 public class c{ } } |

注意：

JDK16之前，成员内部类中不能定义静态成员变量，JDK16之后可以定义静态成员了

创建对象的格式：

外部类名.内部类名.对象名=new 外部类（）.内部类（）；

复制代码

Outer.inner a=new Outer().new inner();

2、成员内部类的方法中，访问其他成员有啥特点？

*可以直接访问外部类的实例成员，静态变量

*可以拿到当前外部类对象，格式是外部类名.this

public class Outer {
    public String name;
    private int age=99;
    public class inner{
        private int age=88;

        //public static String name;Jdk16开始才支持定义静态成员的

        public void test(){
            System.out.println(name);
            System.out.println(age);
            int age=66;
            //66
            System.out.println(age);
            //88
            System.out.println(this.age);
            //99
            System.out.println(Outer.this.age);//（外部类名.this.变量名）可以拿到外部类的对象

        }
        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
    public void test2(){
        System.out.println(name);
    }
}

public class Test {
    public static void main(String[] args) {
        //了解成员内部类和其特点
        Outer.inner a=new Outer().new inner();
        a.test();
    }
}

二、静态内部类

有static 修饰的内部类，属于外部类自己持有，

|-------------------------------------------------------------|
| public class Outer{ //静态内部类 public static class inner { } } |

创建对象的格式

|-------------------------------------------------------------|
| 外部类.内部类对象名=new 外部类.内部类（） Outer1.inner in=new Outer.inner() |

静态内部类中访问外部类的特点：

可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员

局部内部类

*局部内部类是定义在方法中，代码块中，构造器等执行体中。

匿名内部类

匿名内部类是一种特殊的局部内部类；所谓匿名，是指程序员不需要为这个类声明名字。

|-------------------------------|
| new 类或接口（参数值）{ 类体（一般是方法重写）； } |

特点：

匿名内部类本身就是一个子类，并会立即创建出一个子类对象

作用：

用于更方便的创建一个子类对象

public class Test2 {
    public static void main(String[] args) {
        //认识匿名内部类，并掌握其作用
        /*
        Animal a = new Cat();
        a.cry();
         */
       Animal a=new Animal(){
           @Override
           public void cry() {
               System.out.println("猫喵喵喵的叫");
           }
       };
       a.cry();
        }
    }
    /**
    class Cat extends Animal{
        @Override
       public void cry() {
            System.out.println("猫喵喵喵的叫");
        }
    }
     */
    abstract class Animal{
      public  abstract void cry();
    }

匿名内部类在开发中的应用场景

*通常作为一个参数传递给方法

public class Test3 {
    public static void main(String[] args) {
        //目标：掌握匿名内部类的常见使用场景
        /*
       swimmimg s= new swimmimg(){
            @Override
            public void swim() {
                System.out.println("狗游的飞快~~");
            }
        };
       go(s);
         */
        go( new swimmimg(){
            @Override
            public void swim() {
                System.out.println("狗游的飞快~~");
            }
        });
    }
    //设计一个方法，可以接受swimming接口的一切实现类对象进来参加游泳比赛
    public static void go(swimmimg s){
        System.out.println("开始---------------------");
      s.swim();
    }

}
//猫和狗都要参加游泳比赛
interface swimmimg{
    void swim();
}