1.静态代理
public interface Marry {
void HappyMarry();
}
//真实对象
public class You implements Marry {
@Override
public void HappyMarry() {
System.out.println("***结婚了，超开心");
}
}
//代理对象
public class MarryCompany implements Marry {
//代理谁---->真实目标角色
private Marry target;
public MarryCompany(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("拍婚纱照，布置婚礼现场");
}
}
public class staticProxy {
public static void main(String[] args) {
//you的代理是MarryCompany，代理对象可以做真实对象以外的事情，真实对象专注于自己的事情就好
// You you = new You();
// MarryCompany marryCompany = new MarryCompany(you);
// marryCompany.HappyMarry();
new MarryCompany(new You()).HappyMarry();
}
}
总结：
真实对象和代理对象实现同一个接口
代理对象代理真实的角色
优点：
代理对象可以做很多真实对象做不了的事情
真实对象只需要专注自己的事情就行
2.lambda表达式
2.1函数式接口
任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
public interface Runn{
public abstract void run();
}
2.2创建无参接口对象的方法
- 单独写接口的实现类之后，再在主程序中新建对象调用方法
public class LambdaTest01 {
public static void main(String[] args) {
Ilike like = new Like();
like.lambda();
}
//1.定义一个函数式接口，也就是只有一个抽象方法的接口
interface Ilike{
void lambda();
}
//2.实现类
class Like implements Ilike{
@Override
public void lambda() {
System.out.println("I Like lambda");
}
}
- 静态内部类
public class TestLambda {
public static void main(String[] args) {
//2.使用静态内部类
Ilike ilike2=new like2();
ilike2.lambda();
}
//静态内部类
static class like2 implements Ilike{
@Override
public void lambda() {
System.out.println("i like lambda2");
}
}
}
//1.定义一个函数式接口
interface Ilike{
void lambda();
}
- 局部内部类
public class TestLambda {
public static void main(String[] args) {
//3.局部内部类
class Like3 implements Ilike{
@Override
public void lambda() {
System.out.println("i like lambda3");
}
}
Ilike ilike3=new Like3();
ilike3.lambda();
}
}
//1.定义一个函数式接口
interface Ilike{
void lambda();
}
- 匿名内部类
public class TestLambda {
public static void main(String[] args) {
//2.匿名内部类,没有类的名称，必须借助父类或者接口
Ilike ilike4=new Ilike() {
@Override
public void lambda() {
System.out.println("i like lambda4");
}
};
ilike4.lambda();
}
}
//1.定义一个函数式接口
interface Ilike{
void lambda();
}
5.lambda简化
/*
* 推导lambda表达式
* */
public class TestLambda {
public static void main(String[] args) {
//2.用lambda简化
Ilike ilike5=()->{
System.out.println("i like lambda5");
};
ilike5.lambda();
}
}
//1.定义一个函数式接口
interface Ilike{
void lambda();
}
2.3创建有参接口对象的方法
1.
public class LambdaTest02 {
public static void main(String[] args) {
Ilove ilove = new love();
ilove.lambda(2);
}
}
interface Ilove{
void lambda(int a);
}
class love implements Ilove{
@Override
public void lambda(int a) {
System.out.println("I love " + a);
}
}
public class LambdaTest02 {
static class love implements Ilove{
@Override
public void lambda(int a) {
System.out.println("I love " + a);
}
}
public static void main(String[] args) {
Ilove ilove = new love();
ilove.lambda(3);
}
}
interface Ilove{
void lambda(int a);
}
public class LambdaTest02 {
public static void main(String[] args) {
class love implements Ilove{
@Override
public void lambda(int a) {
System.out.println("I love " + a);
}
}
Ilove ilove = new love();
ilove.lambda(4);
}
}
interface Ilove{
void lambda(int a);
}
public class LambdaTest02 {
public static void main(String[] args) {
new Ilove(){
@Override
public void lambda(int a) {
System.out.println("I love " + a);
}
}.lambda(5);
}
}
interface Ilove{
void lambda(int a);
}
5.lambda方式
public class LambdaTest02 {
public static void main(String[] args) {
Ilove ilove = (int a) -> {
System.out.println("I love " + a);
};
//还可以继续简化，1.简化参数类型
ilove = (a) -> {
System.out.println("I love " + a);
};
//2.简化括号
ilove = a -> {
System.out.println("I love " + a);
};
//3.简化花括号(必须只能有一行代码，如果多行则无法简化花括号！)
ilove = a -> System.out.println("I love " + a);
ilove.lambda(6);
}
}
interface Ilove{
void lambda(int a);
}
总结：
- .lambda表达式只有一行代码的情况下才能简化为一行，如果有多行，就需要花括号包裹
- 使用lambda的前提是函数式接口
- 多个参数也可以去掉参数类型，但是要去掉就都去掉，不能有些带类型有些不带，并且要括号包裹多个参数，用逗号隔开