Java10：内部类

7 内部类（了解）

内部类：就是在一个类的内部再定义一个类。

分类：
成员内部类
静态内部类
局部内部类
匿名内部类

7.1 成员内部类

package com.i.innerClass;
//inner Class 内部类
public class Outer {
    private int id= 10;

    /** 局部内部类:方法内部*/
    public void method(){
        class Inner2{
            public void in(){}
        }
    }

    /** 成员内部类：类内部*/
    public class Inner{
        //获取外部类私有属性
        public int getId() {
            System.out.println("内-部类");
            return id;
        }
    }
}
/** class内部类可以有多个，但是只能有一个是public修饰*/
class OuterClass{
    public static void main(String[] args) {

    }
}

package com;

import com.i.innerClass.Outer;
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //要使用内部类，要通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        //调用内部类方法
        int id = inner.getId();
        System.out.println(id);
    }
}

7.2 静态内部类

package com.i.innerClass;
//inner Class 内部类
public class Outer {
    private static int id= 10;
    /**成员内部类：类内部*/
    public static class Inner{
        //获取外部类私有属性
        public int getId() {
            System.out.println("内-部类");
            return id;
        }
    }
}

7.3 局部内部类

package com.i.innerClass;
//inner Class 内部类
public class Outer {
    /** 局部内部类:方法内部*/
    public void method(){
        class Inner2{
            public void in(){}
        }
    }
}

7.4 匿名内部类

package com.i.innerClass;

public class Outer1 {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();

        /** 匿名内部类，（接口实现类）*/
        UserService userService= new UserService() {
            @Override
            public void hello() {

            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("吃了一个苹果");
    }
}
// 接口
interface UserService{
    void hello();
}

2.3. 静态内部类

静态代理模式总结：

• 1.真实对象和代理对象都要实现同一个接口；
• 2.代理对象要代理真实角色

这样做的好处：

• 1.代理对象可以做很多真实对象做不了的事情
• 2.真实对象可以专注做自己喜欢的事情

举例：（Tom 结婚的案例）

1. 定义一个 Marry的接口

//Marry 接口
interface Marry{
    void HappyMarry();
}

2. 被代理对象

// 真实角色-Tom，Tom去结婚
class Tom implements Marry {
    @Override
    public void HappyMarry() {
        System.out.println("Tom 结婚了了，他很开心");
    }
}

3. 代理对象-婚庆公司

// 代理角色-婚庆公司。帮助 Tom结婚
class WeddingCompany implements Marry {
    //被代理对象，真实角色
    private Marry target;
    // 构造方法
    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//真实角色
        after();
    }

    private void after() {
        System.out.println("婚礼后，结尾款");
    }

    private void before() {
        System.out.println("婚礼前，准备婚礼现场");
    }
}

4. 主方法

public class StaticProxy {
    public static void main(String[] args) {
        Tom tom = new Tom();//Tom 要结婚
        /*WeddingCompany weddingCompany = new WeddingCompany(you);
        weddingCompany.HappyMarry();*/
        //用 lambda表达式对比
        new Thread(()-> System.out.println("I Love You")).start();
        new WeddingCompany(tom).HappyMarry();
    }
}

2.4. Lambda表达式，

Lambda表达式的实质是函数式编程
函数式接口的定义：

• 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。比如 Runable接口：

public interface Runnable {
	public abstract void run();
}

• 对于函数式接口，我们可以通过 lambda表达式来创建该接口的对象。

(params) -> expression [ 表达式 ]
	(params) -> statement [ 单个语句 ]
		(params) -> { statements }

为什么要使用 lambda表达式

• 1.避免匿名内部类定义过多
• 2.可以让代码看起来很简洁
• 3.去掉了一些没有意义的代码，只保留核心逻辑

推导 Lambda表达式

1. 普通方法

使用一个类去实现他的接口,重写它的方法
再 创建它的对象，调用它的方法

public class TestLambda9_1 {
    public static void main(String[] args) {
        MyAddress address = new MyHome();
        address.lambdaAddress();
    }
}
//1.定义一个函数式接口
interface MyAddress {
    void lambdaAddress();
}

//2.实现类
class MyHome implements MyAddress {
    @Override
    public void lambdaAddress() {
        System.out.println("我的老家 就是那个屯");
    }
}

2. 使用 静态内部类 来简化

把实现类放到方法外面

public class TestLambda9_1 {
    //3.使用静态内部类代替
    static class MyHome2 implements MyAddress {
        @Override
        public void lambdaAddress() {
            System.out.println("我的老家 就是那个屯 那个屯");
        }
    }
    public static void main(String[] args) {
        MyAddress address = new MyHome2();
        address.lambdaAddress();
    }
}
//1.定义一个函数式接口
interface MyAddress {
    void lambdaAddress();
}

3. 使用 局部内部类 来代替

把实现类放到方法中，

public class TestLambda9_1 {
    public static void main(String[] args) {
        //4.局部内部类
        class MyHome3 implements MyAddress {
            @Override
            public void lambdaAddress() {
                System.out.println("我的老家 就是那个屯 那个屯里 有土生土长的人");
            }
        }
        //局部内部类
        MyAddress address = new MyHome3();
        address.lambdaAddress();
    }
}
//1.定义一个函数式接口
interface MyAddress {
    void lambdaAddress();
}

4. 使用 匿名内部类 来代替

public class TestLambda9_1 {
    public static void main(String[] args) {
        //5.匿名内部类，没有类的名称，必须借助接口或父类
        address = new MyAddress() {
            @Override
            public void lambdaAddress() {
                System.out.println("匿名内部类");    
            }
        };
        address.lambdaAddress();
    }
}
//1.定义一个函数式接口
interface MyAddress {
    void lambdaAddress();
}

5. 使用 Lambda表达式 来简化，（JDK1.8）

因为这个接口只有一个方法，所以可以进一步简化
简化后可以只关注于 业务的实现

public class TestLambda9_1 {
    public static void main(String[] args) {
        //6.用 lambda表达式简化
        address = ()-> {
            System.out.println("用 lambda表达式简化");
        };
        address.lambdaAddress();
    }
}
//1.定义一个函数式接口
interface MyAddress {
    void lambdaAddress();
}

6. 最后再来一个示例

public class TestLambda9_2 {
    public static void main(String[] args) {
        ILove lo = null;
        /*4.局部内部类
        class Love implements ILove {
            @Override
            public void loveYou(int year) {
                System.out.println("Tom, I Love you "+ year +" year");
            }
        }
        ILove lo = new Love();
        lo.loveYou(1);*/

        /*5.匿名内部类
        lo = new ILove() {
            @Override
            public void loveYou(int year) {
                System.out.println("Tom, I Love you "+ year +" year");
            }
        };
        lo.loveYou(2);*/

        /*6.lambda表达式简化*/
        lo = (int year) -> {
            System.out.println("Tom, I Love you " + year + " year");
        };
        lo.loveYou(4);

        /*简化1：去掉参数类型。如果去掉参数类型，就全部去掉
        lo = (year) -> {
            System.out.println("Tom, I Love you " + year + " year");
        };
        lo.loveYou(8);*/

        /*简化2：去掉括号。只有一个参数时，才可以使用
        lo = year -> {
            System.out.println("Tom, I Love you " + year + " year");
        };
        lo.loveYou(16);*/

        /*简化2：去掉花括号。只有一行代码时，才可以使用
        lo = year -> System.out.println("Tom, I Love you " + year + " year");
        lo.loveYou(32);*/

        /* 总结：
        *   1.前提：接口为函数式接口。
        *   2.lambda表达式，只有一行代码时，才可以简化成一行; 如果有多行，那么就用代码块包裹;
        *   3.多个参数也可以去掉参数类型，如果去掉参数类型，就全部去掉,并且必须加上括号;
        * */
    }
}

interface ILove {
    void loveYou(int year);
}