【Java】-NO.16.EBook.4.Java.1.004-【疯狂Java讲义第3版 李刚】- 内部类

package com.lee.test.java.ebook.crazy_java.u_6_oop_2.c_6_7_inner_test;

// 1. 内部类提供了更好的封装

// 2. 在内部类，访问内部类非静态变量用 this.var，访问外部类非静态变量用 Out.this.var

// 3. 在外部类，访问内部类非静态变量用 new Inner().var

// 4. 在外部类，静态的方法不能调用非静态类

// 5. 在非静态内部类，不能存在静态声明

// 6. 外部类访问静态内部类的静态成员，StaticInner.staticVar

// 6.1 外部类访问静态内部类的非静态成员，new StaticInner().var

// 7. 静态内部类无法访问外部类的非静态成员

// 8. 在外部类的外部构造外部类的内部类实例 Out.In in = new Out().new In();

// 8.1 等价于 Out.In in1; Out out = new Out();  in1 = out.new In();

// 9. 子类继承外部类的非静态内部类时，子类构造器必须显式的调用父类的构造器

// 9.1 子类可以直接继承外部类的静态内部类，故优先使用静态内部类会更加方便

// 10. 在外部类的外部构造静态内部类实例 Out.In in = new Out.In();

// 10.1 等价于 Out.staticIn staticIn1; staticIn1 = new Out.staticIn();

// 11. 局部内部类，即定义在方法中的类，Out$NInner.class规则生成class文件：Cow.class Cow$1Inner.class Cow$1InnerSub.class

// 12.1 匿名内部类lambada无参版，接口必须是有唯一抽象方法（类方法、默认方法随意），即函数式接口 @FunctionInterface 下同

// 12.2 匿名内部类lambada有参版，@FunctionInterface

// 12.3  匿名内部类lambada有参版 有返回值 缩略return，@FunctionInterface

// 12.4 匿名内部类lambada有参版，有返回值 显式return，@FunctionInterface

// 12.5 匿名

// 12.6 将实现函数式的接口强转

// 12.7 常见的函数式接口 java.util.function

//   xxxFunction, apply() 处理 数值 并返回新值

// xxxConsumer, accept() 处理 新值 不返回值

// xxxPredicate, test() 判断 返回boolean

// xxxSupplier, getAsXxx() 按某种逻辑算法 返回值

// 12.8.1 Lambada 未缩减 调用类方法

// 12.8.1.1 Lambada ::方法调用 省略参数，引用类方法 Converter converter1_1 = Integer::getInteger;

// 12.8.2 Lambada 未缩减 调用实例 Converter converter2 = str -> "".indexOf("");

// 12.8.2.1 Lambada ::方法调用 省略参数，引用实例方法 Converter converter2_1 = str -> "".indexOf("");

// 12.8.3 Lambada 未缩减 调用实例 MyTest converter3 = (a1, b, c) -> a1.substring(b, c);

// 12.8.3.1 Lambada ::方法调用 省略参数，第一个参数为调用者，之后的参数为形参传进来 MyTest converter3_1 = String::substring;

// 12.8.4 Lambada ::new 构造参数 Converter converter4 = Integer::new;

public class Cow {

    private int weight;

    private String color = "white";

    public Cow(int weight) {

        this.weight = weight;

    }

    // 内部类提供了更好的封装

    private class CowLeg {

        private int num;

        private String color = "black";

        // 5.1 在非静态内部类，不能存在静态声明

//        static{

//

//        }

        // 5.2  在非静态内部类，不能存在静态声明

//        private static void t1(){

//

//        }

        // 5.3  在非静态内部类，不能存在静态声明

//        private static int a;

        public CowLeg(int num) {

            this.num = num;

        }

        public void printLeg() {

            System.out.println("this cow weight:" + weight + ", has leg:" + num);

            // 2. 在内部类，访问内部类非静态变量用 this.var，访问外部类非静态变量用 Out.this.var

            System.out.println("leg color:" + this.color + ", cow color:" + Cow.this.color);

        }

    }

    // 静态内部类

    private static class Life {

        private static int num = 5;

        private int age;

        static {

            // 7 编译失败，静态内部类无法访问外部类的非静态成员

//            System.out.println(Cow.this.color);

        }

    }

    public void getLife() {

        // 6. 外部类访问静态内部类的静态成员，StaticInner.staticVar

        System.out.println(Life.num);

        // 6.1 外部类访问静态内部类的非静态成员，new StaticInner().var

        System.out.println(new Cow(1).color);

    }

    public void getLegInfo(int num) {

        new CowLeg(num).printLeg();

        // 3. 在外部类，访问内部类非静态变量用 new Inner().var

        System.out.println("inner color:" + new CowLeg(1).color);

    }

    public static void main(String[] args) {

        new Cow(10).getLegInfo(2);

        // 4. 编译失败，外部类的静态方法，无法调用非静态的内部类

        //new CowLeg(1);

        // 8. 在外部类的外部构造非静态内部类实例 Out.In in = new Out().new In();

        Out.In in = new Out().new In();

        // 8.1 等价于 Out.In in1; Out out = new Out();  in1 = out.new In();

        Out.In in1;

        Out out = new Out();

        in1 = out.new In();

        // 10 在外部类的外部构造静态内部类实例 Out.In in = new Out.In();

        Out.staticIn staticIn = new Out.staticIn();

        // 10.1 等价于

        Out.staticIn staticIn1;

        staticIn1 = new Out.staticIn();

        // 11. 局部内部类，即定义在方法中的类，Out$NInner.class规则生成class文件：Cow.class Cow$1Inner.class Cow$1InnerSub.class

        class Inner {

        }

        class InnerSub extends Inner {

        }

        // 12. 匿名内部类

        new Cow(1).showFace(new Face() {

            @Override

            public void show() {

                System.out.println("show Cow face");

            }

        });

        // 12.1 匿名内部类lambada无参版，接口必须是有唯一抽象方法（类方法、默认方法随意），即函数式接口 @FunctionInterface 下同

        new Cow(1).showFace(() -> System.out.println("show Cow face"));

        // 12.2 匿名内部类lambada有参版，@FunctionInterface

        new Cow(1).drop(num -> System.out.println("drop egg:" + num));

        // 12.3  匿名内部类lambada有参版 有返回值 缩略return，@FunctionInterface

        Wallet2 w = (int banknote, int coin) -> banknote + coin;

        // 12.4 匿名内部类lambada有参版，有返回值 显式return，@FunctionInterface

        Wallet wallet = (int[] bb, int[] cc) -> {

            int count = 0;

            for (int b : bb) {

                count += b;

            }

            for (int c : cc) {

                count += c;

            }

            return count;

        };

        int[] banknotes = {1, 2, 3};

        int[] coins = {1, 2, 3};

        int count1 = new Cow(1).count(wallet, banknotes, coins);

        // 12.5 匿名  Runnable r = () -> {};

        Runnable r = () -> {

        };

        // 12.6 将实现函数式的接口强转

        Object a = (Runnable) () -> {

        };

        // 12.7 常见的函数式接口 java.util.function

        //   xxxFunction, apply() 处理 数值 并返回新值

        // xxxConsumer, accept() 处理 新值 不返回值

        // xxxPredicate, test() 判断 返回boolean

        // xxxSupplier, getAsXxx() 按某种逻辑算法 返回值

        // 12.8.1 Lambada 未缩减 调用类方法

        Converter converter1 = str -> Integer.getInteger(str);

        // 12.8.1.1 Lambada ::方法调用 省略参数，引用类方法

        Converter converter1_1 = Integer::getInteger;

        // 12.8.2 Lambada 未缩减 调用实例

        Converter converter2 = str -> "".indexOf("");

        // 12.8.2.1 Lambada ::方法调用 省略参数，引用实例方法

        Converter converter2_1 = str -> "".indexOf("");

        // 12.8.3 Lambada 未缩减 调用实例

        MyTest converter3 = (a1, b, c) -> a1.substring(b, c);

        // 12.8.3.1 Lambada ::方法调用 省略参数，第一个参数为调用者，之后的参数为形参传进来

        MyTest converter3_1 = String::substring;

        // 12.8.4 Lambada ::new 构造参数

        Converter converter4 = Integer::new;

    }

    public void showFace(Face face) {

        face.show();

    }

    public void drop(Egg egg) {

        egg.show(2);

    }

    public int count(Wallet wallet, int[] banknotes, int[] coins) {

        return wallet.countMoney(banknotes, coins);

    }

}

class Out {

    class In {

        public In() {

            System.out.println("in");

        }

    }

    static class staticIn {

        public staticIn() {

            System.out.println("staticIn");

        }

    }

}

// 9. 子类继承外部类的非静态内部类时，子类构造器必须显式的调用父类的构造器

class Sub extends Out.In {

    public Sub(Out out) {

        out.super();

    }

}

// 9.1 子类可以直接继承外部类的静态内部类，故优先使用静态内部类会更加方便

class Sub2 extends Out.staticIn {

}

@FunctionalInterface

interface Face {

    void show();

}

@FunctionalInterface

interface Egg {

    void show(int num);

}

@FunctionalInterface

interface Wallet {

    int countMoney(int[] banknotes, int[] coins);

}

@FunctionalInterface

interface Wallet2 {

    int countMoney(int banknote, int coin);

}

@FunctionalInterface

interface Converter {

    Integer convert(String str);

}

@FunctionalInterface

interface MyTest {

    String test(String a, int b, int c);

}