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() {@Overridepublic 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 {@Overridepublic void HappyMarry() {System.out.println("Tom 结婚了了，他很开心");}
}

3. 代理对象-婚庆公司

// 代理角色-婚庆公司。帮助 Tom结婚
class WeddingCompany implements Marry {//被代理对象，真实角色private Marry target;// 构造方法public WeddingCompany(Marry target) {this.target = target;}@Overridepublic 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 {@Overridepublic void lambdaAddress() {System.out.println("我的老家 就是那个屯");}
}

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

把实现类放到方法外面

public class TestLambda9_1 {//3.使用静态内部类代替static class MyHome2 implements MyAddress {@Overridepublic 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 {@Overridepublic 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() {@Overridepublic 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 {@Overridepublic void loveYou(int year) {System.out.println("Tom, I Love you "+ year +" year");}}ILove lo = new Love();lo.loveYou(1);*//*5.匿名内部类lo = new ILove() {@Overridepublic 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);
}