【原】Java学习笔记025

package cn.temptation;

public class Sample01 {
    public static void main(String[] args) {
        // 内部类（嵌套类）：把类定义在其他类的内部，这个类被称为内部类（嵌套类）
        
        // 内部类的分类：（根据所在位置及形式的不同）
        // 1、成员内部类
        // 2、静态内部类
        // 3、局部内部类
        // 4、匿名内部类
        
        // 1、成员内部类：联想到成员变量和成员方法，内部类所在位置和类的成员同级

        // 观察一下生成的字节码文件，有三个：Sample01.class、OuterClass01.class、OuterClass01$InnerClass01.class
        // 成员内部类字节码名称为   外部类名称$成员内部类名称.class
        
        // 创建成员内部类对象的方式1：通过调用成员内部类的构造函数
        // 格式：外部类名.内部类名      成员内部类对象名     =  外部类对象. new  内部类构造函数();
        // 写法1
//        OuterClass01.InnerClass01 innerClass01 = (new OuterClass01()).new InnerClass01();
        // 写法2
//        OuterClass01.InnerClass01 innerClass01 = new OuterClass01().new InnerClass01();
//        System.out.println(innerClass01);            // cn.temptation.OuterClass01$InnerClass01@15db9742
        
        // 创建出外部类对象
        OuterClass01 outerClass01 = new OuterClass01();
        OuterClass01.InnerClass01 innerClass01 = outerClass01.new InnerClass01();
        System.out.println(innerClass01);            // cn.temptation.OuterClass01$InnerClass01@15db9742
    }
}

// 外部类
class OuterClass01 {
    // 成员内部类
    class InnerClass01 {
        
    }
}

package cn.temptation;

public class Sample02 {
    public static void main(String[] args) {
        // 创建成员内部类对象的方式2：通过调用成员内部类所在的外部类的成员方法，在外部类中创建出成员内部类的对象
        OuterClass02 outerClass02 = new OuterClass02();
        
        // 创建多个成员内部类对象的写法
//        OuterClass02.InnerClass02 inner1  = outerClass02.getInnerClass02();
//        System.out.println(inner1);            // cn.temptation.OuterClass02$InnerClass02@15db9742
//        OuterClass02.InnerClass02 inner2  = outerClass02.getInnerClass02();
//        System.out.println(inner2);            // cn.temptation.OuterClass02$InnerClass02@6d06d69c
        
        // 创建单个成员内部类对象的写法（使用单例模式的懒汉式）
        OuterClass02.InnerClass02 inner3 = outerClass02.getInstance();
        System.out.println(inner3);            // cn.temptation.OuterClass02$InnerClass02@15db9742
        OuterClass02.InnerClass02 inner4 = outerClass02.getInstance();
        System.out.println(inner4);            // cn.temptation.OuterClass02$InnerClass02@15db9742
        
        // 此时，只能通过getInstance()方法获取InnerClass02内部类的对象
        // 语法错误：The constructor OuterClass02.InnerClass02() is not visible
//        OuterClass02.InnerClass02 test = new OuterClass02().new InnerClass02();
    }
}

// 外部类
class OuterClass02 {
    // 成员变量
    private InnerClass02 innerClass02;
    
    // 成员方法
    // 多例创建方法
    public InnerClass02 getInnerClass02() {
        return new InnerClass02();
    }
    
    // 单例模式创建方法
    public InnerClass02 getInstance() {
        if (innerClass02 == null) {
            innerClass02 = new InnerClass02();
        }
        
        return innerClass02;
    }
    
    // 成员内部类
    class InnerClass02 {
        // 设置构造函数为私有
        private InnerClass02() {
            
        }
    }
}

package cn.temptation;

public class Sample03 {
    public static void main(String[] args) {
        // 可以在调用时设置对成员内部类的访问规则
        // 1、使用private修饰成员内部类，这样外部访问就无法访问成员内部类，只有通过外部类的成员方法
        // 2、访问规则写在成员方法中
        
        OuterClass03 outerClass03 = new OuterClass03();
        Object obj1 = outerClass03.getInnerClass03("admin");
        System.out.println(obj1);            // cn.temptation.OuterClass03$InnerClass03@15db9742
        
        Object obj2 = outerClass03.getInnerClass03("test");
        System.out.println(obj2);            // null
    }
}

// 外部类
class OuterClass03 {
    // 成员变量
    private InnerClass03 innerClass03;
        
    // 成员方法
    public Object getInnerClass03(String role) {
        if ("admin".equals(role)) {
            return getInstance();
        } else {
            return null;
        }
    }
    
    // 单例模式创建方法
    private InnerClass03 getInstance() {
        if (innerClass03 == null) {
            innerClass03 = new InnerClass03();
        }
        
        return innerClass03;
    }
    
    // 成员内部类
    private class InnerClass03 {
        
    }
}

package cn.temptation;

public class Sample04 {
    public static void main(String[] args) {
        // 成员内部类的特点：
        // 1、成员内部类中可以直接访问所在的外部类的成员
        // 2、成员内部类中可以直接访问所在的外部类的非静态的成员变量  和   静态的成员变量
    }
}

// 外部类
class OuterClass04 {
    // 非静态的成员变量
    public int i = 2;
    private int j = 3;
    // 静态的成员变量
    public static int x = 4;
    private static int y = 5;
    
    // 成员内部类
    class InnerClass04 {
        // 成员方法
        public void showByInner() {
            // 成员内部类对于所在的外部类的成员变量均可以访问（不论是用public修饰的，还是用private修饰的）
            System.out.println(i);
            System.out.println(j);
            // 成员内部类对于所在的外部类的静态成员变量均可以访问（不论是用public修饰的，还是用private修饰的）
            System.out.println(x);
            System.out.println(y);
        }
    }
}

package cn.temptation;

public class Sample05 {
    public static void main(String[] args) {
        OuterClass05.InnerClass05 innerClass05 = new OuterClass05().new InnerClass05();
        innerClass05.showByInner();
    }
}

// 外部类
class OuterClass05 {
    // 成员变量
    public int i = 2;
    public int k = 4;        // 外部类的成员变量 和 内部类的成员变量同名
    
    // 成员内部类
    class InnerClass05 {
        // 成员变量
        public int j = 3;
        public int k = 5;    // 外部类的成员变量 和 内部类的成员变量同名
        
        // 成员方法
        public void showByInner() {
            System.out.println(i);        // 2
            System.out.println(j);        // 3
            System.out.println(k);        // 5  --- 内部类的成员变量（就近原则）
            System.out.println(this.k);        // 5  --- 内部类的成员变量（this指的是当前这个成员内部类对象）
            
            System.out.println(OuterClass05.this.k);    // 4 --- 外部类的成员变量，通过eclipse的识别
            System.out.println(new OuterClass05());        // 外部类对象：cn.temptation.OuterClass05@15db9742
            System.out.println((new OuterClass05()).k);    // 4 --- 外部类的成员变量，通过创建外部类的对象
            System.out.println(OuterClass05.this);        // 外部类对象：cn.temptation.OuterClass05@6d06d69c
        }
    }
}

package cn.temptation;

public class Sample06 {
    public static void main(String[] args) {
        OuterClass06.InnerClass06 innerClass06 = new OuterClass06().new InnerClass06();
        innerClass06.showByInner();
    }
}

// 外部类
class OuterClass06 {
    // 成员方法
    public void method1() {
        System.out.println("外部类的公有非静态成员方法");
    }
    
    private void method2() {
        System.out.println("外部类的私有非静态成员方法");
    }
    
    public static void method3() {
        System.out.println("外部类的公有静态成员方法");
    }
    
    private static void method4() {
        System.out.println("外部类的私有静态成员方法");
    }
    
    // 成员内部类
    class InnerClass06 {
        // 成员方法
        public void showByInner() {
            // 成员内部类的成员方法可以访问外部类的所有成员方法（不论是否公有私有、不论是否静态非静态）
            method1();
            method2();
            method3();
            method4();
        }
    }
}

package cn.temptation;

public class Sample07 {
    public static void main(String[] args) {
        // 成员内部类有构造函数，并且创建时可以选择相应的构造函数重载方法
        
        OuterClass07.InnerClass07 inner1 = new OuterClass07().new InnerClass07();
        System.out.println(inner1);
        
        OuterClass07.InnerClass07 inner2 = new OuterClass07().new InnerClass07("param");
        System.out.println(inner2);
    }
}

// 外部类
class OuterClass07 {
    // 成员内部类
    class InnerClass07 {
        // 构造函数
        public InnerClass07() {
            System.out.println("这是内部类的无参构造函数");
        }
        
        public InnerClass07(String str) {
            System.out.println("这是内部类的有参构造函数，参数为：" + str);
        }
    }
}

package cn.temptation;

public class Sample08 {
    public static void main(String[] args) {
        // 2、静态内部类：联想到静态成员，使用static修饰
        
        // 观察一下生成的字节码文件，有三个：Sample08.class、OuterClass08.class、OuterClass08$InnerClass08.class
        // 静态内部类字节码名称为   外部类名称$静态内部类名称.class
        
        // 创建静态内部类对象
        // 格式：外部类名.内部类名      成员内部类对象名     = new  外部类名.内部类构造函数();
        
        // 语法错误：Illegal enclosing instance specification for type OuterClass08.InnerClass08
//        OuterClass08.InnerClass08 innerClass08 = new OuterClass08().new InnerClass08();
        
        OuterClass08.InnerClass08 innerClass08 = new OuterClass08.InnerClass08();
        System.out.println(innerClass08);            // cn.temptation.OuterClass08$InnerClass08@15db9742
    }
}

// 外部类
class OuterClass08 {
    // 静态内部类
    static class InnerClass08 {
        
    }
}

package cn.temptation;

public class Sample09 {
    public static void main(String[] args) {
        // 静态内部类的特点：
        // 静态内部类中不论静态的成员方法还是非静态的成员方法只能访问所在的外部类的静态成员变量
    }
}
// 外部类
class OuterClass09 {
    // 非静态成员变量
    public int i = 2;
    private int j = 3;
    // 静态成员变量
    public static int x = 4;
    private static int y = 5;
    
    // 静态内部类
    static class InnerClass09 {
        // 非静态的成员方法
        public void showByInner() {
            // 静态内部类对外部类的非静态成员变量无法访问
            // Cannot make a static reference to the non-static field i
//            System.out.println(i);
            // Cannot make a static reference to the non-static field j
//            System.out.println(j);
            
            // 静态内部类对外部类的静态成员变量可以访问
            System.out.println(x);
            System.out.println(y);
        }
        
        // 静态的成员方法
        public static void showByInnerStatic() {
            // 静态内部类对外部类的非静态成员变量无法访问
            // Cannot make a static reference to the non-static field i
//            System.out.println(i);
            // Cannot make a static reference to the non-static field j
//            System.out.println(j);
            
            // 静态内部类对外部类的静态成员变量可以访问
            System.out.println(x);
            System.out.println(y);
        }
    }
}

package cn.temptation;

public class Sample10 {
    public static void main(String[] args) {
        // 静态内部类的特点：
        // 静态内部类中不论静态的成员方法还是非静态的成员方法只能访问所在的外部类的静态成员方法
    }
}

// 外部类
class OuterClass10 {
    // 成员方法
    public void method1() {
        System.out.println("外部类的公有非静态成员方法");
    }
    
    private void method2() {
        System.out.println("外部类的私有非静态成员方法");
    }
    
    public static void method3() {
        System.out.println("外部类的公有静态成员方法");
    }
    
    private static void method4() {
        System.out.println("外部类的私有静态成员方法");
    }
    
    // 成员内部类
    static class InnerClass10 {
        // 非静态成员方法
        public void showByInner() {
            // 静态内部类对外部类的非静态成员方法无法访问
            // 语法错误：Cannot make a static reference to the non-static method method1() from the type OuterClass10
//            method1();
            // 语法错误：Cannot make a static reference to the non-static method method2() from the type OuterClass10
//            method2();
            
            // 静态内部类对外部类的静态成员方法可以访问
            method3();
            method4();
        }
        
        // 非静态成员方法
        public void showByInnerStatic() {
            // 静态内部类对外部类的非静态成员方法无法访问
            // 语法错误：Cannot make a static reference to the non-static method method1() from the type OuterClass10
            //            method1();
            // 语法错误：Cannot make a static reference to the non-static method method2() from the type OuterClass10
            //            method2();
            
            // 静态内部类对外部类的静态成员方法可以访问
            method3();
            method4();
        }
    }
}

package cn.temptation;

public class Sample11 {
    public static void main(String[] args) {
        // 静态内部类有构造函数，并且创建时可以选择相应的构造函数重载方法
        
        OuterClass11.InnerClass11 inner1 = new OuterClass11.InnerClass11();
        System.out.println(inner1);
        
        OuterClass11.InnerClass11 inner2 = new OuterClass11.InnerClass11("param");
        System.out.println(inner2);
    }
}

// 外部类
class OuterClass11 {
    // 成员内部类
    static class InnerClass11 {
        // 构造函数
        public InnerClass11() {
            System.out.println("这是内部类的无参构造函数");
        }
        
        public InnerClass11(String str) {
            System.out.println("这是内部类的有参构造函数，参数为：" + str);
        }
    }
}

package cn.temptation;

public class Sample12 {
    public static void main(String[] args) {
        // 3、局部内部类：联想到局部变量，位于外部类的成员方法中
        
        // 观察一下生成的字节码文件，有三个：Sample12.class、OuterClass12.class、OuterClass12$1InnerClass12.class
        // 局部内部类字节码名称为   外部类名称$ 编号 局部内部类名称.class
        
        // 语法错误：InnerClass12 cannot be resolved to a type
//        InnerClass12 innerClass12 = new InnerClass12();
        
        // 语法错误：OuterClass12.InnerClass12 cannot be resolved to a type
//        OuterClass12.InnerClass12 innerClass12 = new OuterClass12.new InnerClass12();
        
        // 对于局部内部类的访问，只能通过其所在的外部类的成员方法的调用
        OuterClass12 outerClass12 = new OuterClass12();
        outerClass12.showByOuter();            // 局部内部类的成员方法
    }
}

// 外部类
class OuterClass12 {
    // 成员方法
    public void showByOuter() {
        // 局部内部类
        class InnerClass12 {
            // 成员方法
            public void showByInner() {
                System.out.println("局部内部类的成员方法");
            }
        }
        
        // 在外部类的成员方法中实例化局部内部类对象
        InnerClass12 innerClass12 = new InnerClass12();
        innerClass12.showByInner();
    }
}

package cn.temptation;

public class Sample13 {
    public static void main(String[] args) {
        // 局部内部类的特点：
        // 1、局部内部类中可以直接访问所在的外部类的成员
        // 2、局部内部类中可以直接访问所在的外部类的非静态的成员变量  和   静态的成员变量
    }
}

// 外部类
class OuterClass13 {
    // 非静态的成员变量
    public int i = 2;
    private int j = 3;
    // 静态的成员变量
    public static int x = 4;
    private static int y = 5;
    
    // 成员方法
    public void showByOuter() {
        // 局部内部类
        class InnerClass13 {
            // 成员方法
            public void showByInner() {
                // 局部内部类对于所在的外部类的成员变量均可以访问（不论是用public修饰的，还是用private修饰的）
                System.out.println(i);
                System.out.println(j);
                // 局部内部类对于所在的外部类的静态成员变量均可以访问（不论是用public修饰的，还是用private修饰的）
                System.out.println(x);
                System.out.println(y);
            }
        }
        
        // 在外部类的成员方法中实例化局部内部类对象
        InnerClass13 innerClass13 = new InnerClass13();
        innerClass13.showByInner();
    }
}

package cn.temptation;

public class Sample14 {
    public static void main(String[] args) {
        // 局部内部类的特点：
        // 1、局部内部类中可以直接访问所在的外部类的非静态的成员方法  和   静态的成员方法
    }
}

// 外部类
class OuterClass14 {
    // 成员方法
    public void method1() {
        System.out.println("外部类的公有非静态成员方法");
    }
    
    private void method2() {
        System.out.println("外部类的私有非静态成员方法");
    }
    
    public static void method3() {
        System.out.println("外部类的公有静态成员方法");
    }
    
    private static void method4() {
        System.out.println("外部类的私有静态成员方法");
    }
    
    // 成员方法
    public void showByOuter() {
        // 局部内部类
        class InnerClass14 {
            // 成员方法
            public void showByInner() {
                // 局部内部类对于所在的外部类的成员方法均可以访问（不论是用public修饰的，还是用private修饰的）
                method1();
                method2();
                // 局部内部类对于所在的外部类的静态成员方法均可以访问（不论是用public修饰的，还是用private修饰的）
                method3();
                method4();
            }
        }
        
        // 在外部类的成员方法中实例化局部内部类对象
        InnerClass14 innerClass14 = new InnerClass14();
        innerClass14.showByInner();
    }
}

package cn.temptation;

public class Sample15 {
    public static void main(String[] args) {
        // 局部内部类有构造函数，并且创建时可以选择相应的构造函数重载方法
        
        OuterClass15 outerClass15 = new OuterClass15();
        outerClass15.showByOuter();
    }
}

// 外部类
class OuterClass15 {
    // 成员方法
    public void showByOuter() {
        // 局部内部类
        class InnerClass15 {
            // 构造函数
            public InnerClass15() {
                System.out.println("局部内部类的无参构造函数");
            }
            
            public InnerClass15(String str) {
                System.out.println("局部内部类的有参构造函数，参数为：" + str);
            }
        }
        
        // 在外部类的成员方法中实例化局部内部类对象
        InnerClass15 inner1 = new InnerClass15();
        System.out.println(inner1);
        
        InnerClass15 inner2 = new InnerClass15("param");
        System.out.println(inner2);
    }
}

package cn.temptation;

public class Sample16 {
    public static void main(String[] args) {
        // 观察一下生成的字节码文件，有四个：Sample16.class、OuterClass16.class、OuterClass16$1InnerClass16.class、OuterClass16$2InnerClass16.class
        // 局部内部类字节码名称为   外部类名称$ 编号 局部内部类名称.class
        
        OuterClass16 outerClass16 = new OuterClass16();
        outerClass16.metho1ByOuter();
        outerClass16.metho2ByOuter();
        
        // 注意：在外部类的不同成员方法中可以定义相同名称的局部内部类名称（即局部内部类可以重名），但是成员内部类 和 静态内部类 不可以重名（在同一个外部类中）
    }
}

// 外部类
class OuterClass16 {
    // 成员方法
    public void metho1ByOuter() {
        // 局部内部类
        class InnerClass16 {

        }
        
        // 在外部类的成员方法中实例化局部内部类对象
        InnerClass16 inner1 = new InnerClass16();
        System.out.println(inner1);
    }
    
    public void metho2ByOuter() {
        // 局部内部类
        class InnerClass16 {

        }
        
        // 在外部类的成员方法中实例化局部内部类对象
        InnerClass16 inner2 = new InnerClass16();
        System.out.println(inner2);
    }
}

package cn.temptation;

public class Sample17 {
    public static void main(String[] args) {
        // 局部内部类的成员方法访问局部内部类所在的外部类的成员方法中定义的局部变量，局部变量可以使用final修饰，也可以不使用final修饰
        // 但是不论是否使用final修饰，效果等同于使用final修饰
        
        OuterClass17 outerClass17 = new OuterClass17();
        outerClass17.showByOuter();
    }
}

// 外部类
class OuterClass17 {
    // 成员方法
    public void showByOuter() {
        // 局部变量
        int i = 2;
        final int j = 3;
        
        // 局部内部类
        class InnerClass17 {
            // 成员方法
            public void showByInner() {
                // 注意：下句从JDK 1.8开始不会产生错误，之前的JDK版本会产生语法错误
                System.out.println(i);        // 2
                System.out.println(j);        // 3
                
                // 语法错误：Local variable i defined in an enclosing scope must be final or effectively final
                // 局部内部类中的成员方法访问所在的成员方法的局部变量，该局部变量使用final定义或等同于final修饰的效果
//                i = 4;
//                System.out.println(i);
                
                // 语法错误： The final local variable j cannot be assigned, since it is defined in an enclosing type
//                j = 5;
//                System.out.println(j);
            }
        }
        
        // 在外部类的成员方法中实例化局部内部类对象
        InnerClass17 innerClass17 = new InnerClass17();
        innerClass17.showByInner();
    }
}

package cn.temptation;

public class Sample18 {
    public static void main(String[] args) {
        // 4、匿名内部类：联想到匿名对象和匿名数组，内部类没有名称，需要存在一个类或接口
        
        // 观察一下生成的字节码文件，有三个：Foo.class、Sample18.class、OuterClass18.class、OuterClass18$1.class
        // 匿名内部类字节码名称为   外部类名称$编号.class
        
        // 创建匿名内部类对象的方式：通过调用匿名内部类所在的外部类的成员方法
        OuterClass18 outerClass18 = new OuterClass18();
        // 定义接口类型的变量来接收匿名内部类对象的返回
        Foo foo = outerClass18.showByOuter();
        System.out.println(foo);            // cn.temptation.OuterClass18$1@15db9742
    }
}

// 定义接口
interface Foo {
    public abstract void show();
}

// 接口的实现类
//class FooImpl implements Foo {
//    @Override
//    public void show() {
//        System.out.println("接口的实现类的成员方法");
//    }
//}

// 外部类
class OuterClass18 {
    // 成员方法
    public Foo showByOuter() {
        // 实现了Foo接口的匿名内部类（类似局部内部类的位置）
        return new Foo() {
            @Override
            public void show() {
                System.out.println("实现了接口的匿名内部类");
            }
        };
    }
}

package cn.temptation;

public class Sample19 {
    public static void main(String[] args) {
        // 匿名内部类的特点：
        // 1、匿名内部类没有构造函数的（使用者无法创建构造函数，其实JVM生成了构造函数）
    }
}

// 定义接口
interface Test {
    public abstract void show();
}

// 外部类
class OuterClass19 {
    // 成员方法
    public Test showByOuter() {
        // 实现了Foo接口的匿名内部类
        return new Test() {
            // 构造函数
            // Return type for the method is missing
//            public Test() {
//                
//            }
            
            // 成员方法
            @Override
            public void show() {
                System.out.println("实现了接口的匿名内部类");
            }
        };
    }
}
// 查看OuterClass19$1.class字节码文件的反编译，可以看出jvm帮我们匿名内部类起了名字，并且生成了构造函数
//class OuterClass19$1 implements Test {
//    final OuterClass19 this$0;
//    
//    public void show()
//    {
//        System.out.println("实现了接口的匿名内部类");
//    }
//    
//    OuterClass19$1()
//    {
//        this$0 = OuterClass19.this;
//        super();
//    }
//}

package cn.temptation;

public class Sample20 {
    public static void main(String[] args) {
        // 匿名内部类的方法调用
        OuterClass20 outerClass20 = new OuterClass20();
        outerClass20.showByOuter();
    }
}

// 定义接口
interface Demo {
    public abstract void show();
}

class DemoImpl implements Demo {
    @Override
    public void show() {
        System.out.println("这是接口定义的方法");
    }
}

// 外部类
class OuterClass20 {
    // 成员方法
    public void showByOuter() {
        // 匿名内部类的方法回调
        (new Demo() {
            @Override
            public void show() {
                System.out.println("这是接口定义的方法");
            }
        }).show();
        
        // 上述方法回调的写法本质就是如下写法
        Demo obj = new DemoImpl();
        obj.show();
    }
}

package cn.temptation;

public class Sample21 {
    public static void main(String[] args) {
        OuterClass21 outerClass21 = new OuterClass21();
        outerClass21.showByOuter();
    }
}

// 接口
interface Ability {
    public abstract void method1();
    public abstract void method2();
}

// 外部类
class OuterClass21 {
    // 成员方法
    public void showByOuter() {
        // 接口定义的一个方法的调用
//        (new Ability() {
//            @Override
//            public void method1() {
//                System.out.println("接口定义的方法1");
//            }
//            
//            @Override
//            public void method2() {
//                System.out.println("接口定义的方法2");
//            }
//        }).method1();
        
        // 接口定义的两个方法的调用的写法1（分别调用）
//        (new Ability() {
//            @Override
//            public void method1() {
//                System.out.println("接口定义的方法1");
//            }
//            
//            @Override
//            public void method2() {
//                System.out.println("接口定义的方法2");
//            }
//        }).method1();
//        
//        (new Ability() {
//            @Override
//            public void method1() {
//                System.out.println("接口定义的方法1");
//            }
//            
//            @Override
//            public void method2() {
//                System.out.println("接口定义的方法2");
//            }
//        }).method2();
        
        // 接口定义的两个方法的调用的写法2（定义一个接口类型的变量来接收匿名内部类）
        Ability obj = new Ability() {
            @Override
            public void method1() {
                System.out.println("接口定义的方法1");
            }
            
            @Override
            public void method2() {
                System.out.println("接口定义的方法2");
            }
        };
        
        obj.method1();
        obj.method2();
    }
}

package cn.temptation;

public class Sample22 {
    public static void main(String[] args) {
        OuterClass22 outerClass22 = new OuterClass22();
        outerClass22.showByOuter();
    }
}

// 接口
interface Project {
    public abstract void show();
}

// 外部类
class OuterClass22 {
    // 成员变量
    public int i = 2;
    private int j = 3;
    public static int x = 4;
    public static int y = 5;
    
    // 成员方法
    public void showByOuter() {
        // 匿名内部类
        (new Project() {
            // 成员方法
            @Override
            public void show() {
                // 匿名内部类可以访问外部类的成员变量（不论是否公有私有、不论是否静态非静态）
                System.out.println(i);
                System.out.println(j);
                System.out.println(x);
                System.out.println(y);
            }
        }).show();
    }
}

package cn.temptation;

public class Sample23 {
    public static void main(String[] args) {
        // 需求：运用内部类，描述如下功能：张三有一颗健壮的心脏，他最近想靠搬砖发财
        
        // 思路：
        // 1、"张三有一颗健壮的心脏"：考虑使用成员内部类，并且只有一颗心脏（考虑使用单例获取）
        // 2、"他最近想靠搬砖发财"：考虑使用匿名内部类
        
        Person person = new Person("张三");
        Person.Heart heart = person.getInstance();
        heart.setState("健壮");
        System.out.println("姓名为：" + person.getName() + "，有一颗" + heart.getState() + "的心脏");
        
        person.think("搬砖");
    }
}

// 接口
interface IAbility {
    public abstract void getRich(String str);
}

// 外部类：人类
class Person {
    // 成员变量
    private String name;
    private Heart heart;
    
    // 构造函数
    public Person() {
        super();
    }

    public Person(String name) {
        super();
        this.name = name;
    }
    
    // 成员内部类：心脏类
    class Heart {
        // 成员变量
        private String state;
        
        // 构造函数
        private Heart() {
            super();
        }

        // 成员方法
        public String getState() {
            return state;
        }

        public void setState(String state) {
            this.state = state;
        }
    }
    
    // 成员方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    // 自定义成员方法
    public Heart getInstance() {
        if (heart == null) {
            heart = new Heart();
        }
        
        return heart;
    }
    
    public void think(String str) {
        // 匿名内部类
        (new IAbility() {
            @Override
            public void getRich(String str) {
                System.out.println("依靠" + str + "发财");
            }
        }).getRich(str);
    }
}