- 7 内部类(了解)
- 7.1 成员内部类
- 7.2 静态内部类
- 7.3 局部内部类
- 7.4 匿名内部类
- 2.3. 静态内部类
- 2.4. Lambda表达式,
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();
}
- 7 内部类(了解)
- 7.1 成员内部类
- 7.2 静态内部类
- 7.3 局部内部类
- 7.4 匿名内部类
- 2.3. 静态内部类
- 2.4. Lambda表达式,
2.3. 静态内部类
静态代理模式总结:
- 1.真实对象和代理对象都要实现同一个接口;
- 2.代理对象要代理真实角色
这样做的好处:
- 1.代理对象可以做很多真实对象做不了的事情
- 2.真实对象可以专注做自己喜欢的事情
举例:(Tom 结婚的案例)
- 定义一个 Marry的接口
//Marry 接口
interface Marry{void HappyMarry();
}
- 被代理对象
// 真实角色-Tom,Tom去结婚
class Tom implements Marry {@Overridepublic void HappyMarry() {System.out.println("Tom 结婚了了,他很开心");}
}
- 代理对象-婚庆公司
// 代理角色-婚庆公司。帮助 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("婚礼前,准备婚礼现场");}
}
- 主方法
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表达式
- 普通方法
使用一个类去实现他的接口,重写它的方法
再 创建它的对象,调用它的方法
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("我的老家 就是那个屯");}
}
- 使用 静态内部类 来简化
把实现类放到方法外面
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();
}
- 使用 局部内部类 来代替
把实现类放到方法中,
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();
}
- 使用 匿名内部类 来代替
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();
}
- 使用 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();
}
- 最后再来一个示例
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);
}