java的内部类

定义：在类中或类的成员方法中创建的类叫做内部类

   - 内部类也是一个类，可以有成员变量，成员方法
   - 内部类可以是普通类、抽象类子类、接口的实现类

//外部类
public class OuterDemo1 implements Inf1 {
    @Override
    public void start() {
        //启动
        System.out.println("启动");
    }
    //内部类实现接口
    class Inner implements Inf2{
        @Override
        public void start() {
            //开始
            System.out.println("开始");
        }
    }
}
//接口1
interface Inf1{
    //启动
    public abstract void start();
    // public abstract默认省略
}
//接口2
interface Inf2{
    //开始
    void start();
}

内部类分为四种：

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

成员内部类

• 成员内部类创建在类中，方法外，可以使用4个访问修饰符
• 成员内部类不可以有静态成员
• 外部类可以使用成员内部类
• 成员内部类的实例方法中拥有外部类对象，使用“外部类名.this”获取，所以可以使用“外部类名.This”访问外部类成员（内部类的实例方法中this表示内部类对象，外部.类名。This表示外部类对象）；

示例一：

//外部类
public class OuterDemo2 {
    int a=10;
    static int b=20;//静态变量
    //成员方法
    //在外部类中访问成员内部类：new 内部类名------》表示内部对象
    //通过内部类对象访问
    public void fun(){
        System.out.println( new Inner().x);
    }
    //成员内部类
    class Inner{
        int x=100;
//        static  int y=200;//编译错误：成员内部类中不能存在静态成员
    }
}

示例二：

//外部类
public class OuterDemo3 {
    int a=10;
    static int b=20;//静态变量
    //成员内部类
    class Inner{
        int x=100;
//        static  int y=200;//编译错误：成员内部类中不能存在静态成员
     public void fun(){
         //在内部类中访问外部类成员，外部类名.this得到外部类对象
         System.out.println(OuterDemo3.this.a);
         //this 在内部类中表示当前的内部类对象
         System.out.println(this.x);
     }
    }
}

静态内部类

• 静态内部类创建在类中，方法外，使用static修饰
• 四种访问权限修饰符都可以修饰静态内部类，类可以被任何地方使用，其他类使用静态内部类时，要受静态内部类的权限修饰行影响，这种影响与类中成员变量和成员一样
• 导入静态内部类的包的格式为import …外部类.静态内部类
• 只导入静态内部类的外部类也可以使用静态内部类，只是使用时格式为“外部类.内部类.";
• 静态内部类中可以有静态成员变量与静态成员方法
• 静态内部类的实例方法中没有外部类对象，所以不能在静态内部类中使用"外部类.this"
  ,即静态内部类只能访问外部类的静态成员,不能访问外部类的实例成员

//外部类
public class OuterDemo4 {

    //静态内部类
    static class Inner {
        static int x = 20;
        public  static  void fun(){
            System.out.println("static 内部类");
        }
    }
    public void test(){
        //使用类名.变量名调用静态内部类中的静态变量
        System.out.println(Inner.x);
    }

}

局部内部类

• 方法中定义的内部类
• 局部内部类与局部变量有很多相似之处

   - 都不可使用权限修饰符修饰
   - 作用域范围相同,都是定义地方起到第一个"}"结束

• 局部内部类拥有外部类对象,即可以使用"外部类名.this"访问外部类成员
• 局部内部类中可访问外部方法的局部变量,但是该局部变量必须是

//外部类
public class OuterDemo5 {
   int a=10;
    public void fun(){
        /*
        *局部内部类：定义在方法内部或参数
        * 作用域只在该方法内有效，不能使用权限修饰符修饰
        * */
        int x=100;//局部变量
        // 局部内部类
        class Inner{
            public void test(){
                //访问外部类成员，通过“外部类.this.”访问
                System.out.println(OuterDemo5.this.a);
                //访问方法的局部变量
                System.out.println(x);
            }
        }
    }
}

匿名内部类

• 匿名内部类一定是跟在一个new关键字后面
• 匿名内部类可以在外部类成员变量赋值是创建
• 匿名内部类可以在方法体中直接创建并使用，并且可以与局部内部类一样。可以访问外部方法的final修饰的局部变量
• 匿名内部类可以在调用方法传参时创建
• 匿名内部类中拥有外部类对象，即可以使用"外部类名.this"访问外部类成员

//外部类
public class OuterDemo6 {
    //1、在成员变量赋值时创建
    //声明引用变量·并创建匿名内部类对象：new 类名（）{}  ----->匿名内部类
    Animal a1 = new Animal() {
        @Override
        public void eat() {
            System.out.println("小狗再吃");
        }
    };

    // 2、在方法内部定义并使用
    public void fun() {
        //匿名内部类---->匿名对象，用完一次机回收
        new Animal() {
            @Override
            public void eat() {
                System.out.println("小猫再吃");
            }
        };
    }

    //3、在方法参数位置创建
    public void m(Animal a) {
        a.eat();
    }

    public static void main(String[] args) {
        new OuterDemo6().m(new Animal() {
            //在方法参数位置创建

            @Override
            public void eat() {
                System.out.println("小鱼再吃");
            }
        });

    }

}

class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
}