Java内部类

内部类

基本介绍

内部类一共有四种

匿名内部类

内部类案例

package com.xz.innerclass;

public class InnerClass01 {
    public static void main(String[] args) {

    }
}

class Outer {
    int n1 = 10;//属性

    public Outer(int n1) {//构造器
        this.n1 = n1;
    }

    public void hi() {//方法
        System.out.println("hi()....");
    }

    {//代码块
        System.out.println("代码块");
    }

    class Inner {//内部类

    }
}

class Other {//其他类

}

局部内部类的使用

package com.xz.innerclass;

/**
 * 演示局部内部类的使用
 */
public class LocalInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
    }
}

class Outer02 {
    private int n1 = 100;

    private void m2() {//私有方法
        System.out.println("m2()....");
    }

    public void m1() {//方法
        //1.局部内部类是定义在外部类的局部位置，通常在方法
        //3.不能添加访问修饰符，但是可以用final修饰
        //4.作用域：仅仅在定义它的方法或代码块中

        final class Inner02 {//局部内部类(本质仍然是一个类)
            private int n1 = 800;
            //可以直接访问外部类的所以成员，包括私有的
            public void f1() {
                //5.局部内部类可以直接访问外部类的成员，如下：
                //7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
                //  可以使用(外部类名.this.成员)去访问
                System.out.println("n1 =" + n1 + " 外部类的n1 = " + Outer02.this.n1);
                m2();
            }
        }
        //6.外部类在方法中，可以创建Inner02对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();

        {//代码块
            class Inner03 {

            }
        }

    }
}

匿名内部类（重点！！！）

package com.xz.innerclass;

//import com.xz.interface_.IA;

/**
 * 演示匿名内部类的使用
 */
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}

class Outer04 {//外部类
    private int n1 = 10;//属性

    public void method() {//方法
        //基于接口的匿名内部类
        //1.需求：  使用IA接口，并创建对象
        //2.传统方式：写一个类，实现该接口，并创建对象
        //3.当前需求：Tiger/Dog 类只使用一次，之后再不使用
        //4.可以用匿名内部类来简化开发
        //5.tiger 的编译类型： IA
        //6.tiger 的运行类型： 匿名内部类 XXXX ==> Outer04$1  (系统分配)
        /*
            底层实现： 会分配类名 Outer04$1
            class XXXX implements IA{
                @Override
                public void cry() {
                    System.out.println("老虎嗷嗷叫...");
                }
            }
         */
        //7. jdk底层在创建匿名内部类Outer04$1,立即马上就创建了Outer04$1实例， 并且把地址返回给tiger
        //8.匿名内部类使用一次，就不能再使用
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎嗷嗷叫...");
            }
        };
        System.out.println("tiger的运行类型是： " + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();
//        IA tiger = new Tiger();
//        tiger.cry();


        //演示基于类的匿名内部类
        //1. father编译类型Father
        //2. father运行类型Outer04$2
        //3.底层会创建匿名内部类
        //4.同时也直接返回了   匿名内部类 Outer04$2 的对象
        //5.注意("jack")参数(形参)列表会传给Father 的构造器
        /*
            class Outer04$2 extends Father{
            }
         */
        Father father = new Father("jack") {

            @Override
            public void test() {
                System.out.println("匿名内部类重写了test()方法...");
            }
        };
        System.out.println(father.getClass());
        father.test();


        //演示基于抽象类的匿名内部类
        Animal bear = new Animal() {
            @Override
            void sleep() {
                System.out.println("小熊睡觉...");
            }
        };
        System.out.println(bear.getClass());
        bear.sleep();
    }
}

interface IA {//接口

    public void cry();
}

//class Tiger implements IA {
//
//    @Override
//    public void cry() {
//        System.out.println("老虎嗷嗷叫...");
//    }
//}
//
//class Dog implements IA {
//
//    @Override
//    public void cry() {
//        System.out.println("小狗汪汪叫...");
//
//    }
//}

class Father {//类

    public Father(String name) {//构造器
        System.out.println("接收到name = " + name);
    }

    public void test() {//方法

    }
}

abstract class Animal {
    abstract void sleep();
}