测试 成员内部类、局部内部类、匿名内部类

TestInner1 ---内部类入门案例

TestInner2 ---成员内部类被private修饰后

TestInner3 ---成员内部类被Static修饰后的效果

TestInner4 ---局部内部类

TestInner5 ---匿名内部类

package com.wuya.innerclass;
//测试内部类 入门案例
public class TestInner1 {
    public static void main(String[] args) {
        //3.TODO 创建内部类对象,使用内部类的资源
        Outer.Inner oi = new Outer().new Inner();
        oi.miss();
        System.out.println(oi.tel);
        //3.1 外部类使用与之前一样,直接创建外部类对象
        new Outer().find();
    }
}
//1.创建外部类
class Outer{
    //1.1定义外部类属性
    String name;
    private int age;
    //1.2定义外部类成员方法
    public void find(){
        System.out.println("find()...@外部类");
        //5.TODO 外部类可以使用内部类的资源吗?--必须先创建内部类对象,才可访问
        Inner in = new Inner();
        System.out.println(in.addr+in.tel);
        in.miss();
    }

    //2.创建成员内部类(成员内部类的位置:在类里方法外;
    //                局部内部类:方法里)---内部类分两种
    class Inner{
        private String addr;
        long tel;
        public void miss(){
            System.out.println("miss()...@内部类");
            //4.TODO 内部类可以使用外部的资源吗?--可以使用,包括私有资源
            System.out.println(name+age);
//            find();否则方法间相互调用,成死循环了
        }
    }
}

package com.wuya.innerclass;
//测试 成员内部类被private修饰的现象
public class TestInner2 {
    public static void main(String[] args) {
//        new Outer2().new Inner2();//这行代码一些就报错
        //曲线救国,可以先创建外部类对象,调用drink()
        //创建外部类对象间接访问私有内部类中的资源
        new Outer2().drink();
    }
}
class Outer2{
    public void drink(){
        new Inner2().eat();
    }
    //测试得知:通过private修饰的内部类,私有化,无法被外界直接访问
    private class Inner2{
        public void eat(){
            System.out.println("eat()...@内部类");
        }
    }
}

package com.wuya.innerclass;
//测试 成员内部类被static修饰后的效果
public class TestInner3 {
    public static void main(String[] args) {
//        new Outer3().new Inner3();//报错
        //TODO 通过外部类的类名来创建内部类对象
        Outer3.Inner3 in3 = new Outer3.Inner3();
        in3.sing();
        new Outer3.Inner3().sing();
        //todo 访问内部类的静态资源---链式加载
        Outer3.Inner3.sing2();
    }
}
class Outer3{
    String addr;
    //成员内部类被static修饰---并不常用---浪费内存
    //测试得知:被static修饰后的成员内部类不能被外部类直接访问
    static class Inner3{
        char sex;
        public void sing(){
            System.out.println("sing()...");
        }
        static public void sing2(){
            System.out.println("sing2()...");
        }
    }
}

package com.wuya.innerclass;
//测试 局部内部类
public class TestInner4 {
    public static void main(String[] args) {
        /**如何使用局部内部类的资源呢?
         * 需要在局部内部类所在的方法内创建内部类的对象并进行调用,才能触发内部类的功能;
         * 注意:直接调用外部类对象的show()是无法触发内部类的功能的
         */
        new Outer4().show();
    }
}
class Outer4{
    public void show(){
        //局部内部类的位置:方法里
        class Inner4{
            String addr;
            public void play(){
                System.out.println("局部内部类的方法play()...");
            }
        }
        /** 如何使用局部内部类的资源? */
        //答:【在方法内】创建局部内部类的对象
        Inner4 in = new Inner4();
        in.addr = "上海";
        System.out.println(in.addr);
        in.play();
    }
}

package com.wuya.innerclass;
//测试 匿名内部类
//TODO 理解:匿名内部类没有名字,通常结合匿名对象一起使用

public class TestInner5 {
    public static void main(String[] args) {
        //2.new Inner1()是匿名对象;两个重写的方法及外层大括号属于 匿名内部类
        /** 就相当于创建了一个接口的实现类+重写接口中的所有抽象方法 */
        new Inner1() { //接口的实现类
            @Override
            public void sing() {
                System.out.println("sing()...");
            }

            @Override
            public void dance() {
                System.out.println("dance()...");
            }
        }.dance();//触发指定的重写后的方法
        /** 注意:匿名对象一次只能干一件事!!! 只能调用一个方法!!! 只能调用一次!!! */

        //4.匿名对象new Inner2()
        new Inner2() {
            @Override
            public void say() {
                System.out.println("say()...");
            }
        }.say();

        //6.创建普通类的匿名对象
        /** 没有强制要求普通类生成匿名内部类的重写方法 */
        new Inner3().learn();
    }
}
//1.创建接口 Inner1
interface Inner1{
    void sing();
    void dance();
}
//3.创建抽象类 Inner2
abstract class Inner2{
    abstract public void say();
    public void drink(){
        System.out.println("drink()...");
    }
}
//5.创建普通类 Inner3
class Inner3{
    public void sleep(){
        System.out.println("sleep()...");
    }
    public void learn(){
        System.out.println("learn()...");
    }
}