静态代理
静态代理模式中真实对象和代理对象都要实现同一个接口，代理对象要代理真实角色
public class staticProxy {
public static void main(String[] args) {
WeddingCompany weddingcompany = new WeddingCompany(new you());
weddingcompany.HappyMarry();
}
}
interface Marry{
void HappyMarry();
}
//真实角色，我去结婚
class you implements Marry{
@Override
public void HappyMarry() {
System.out.println("要结婚了");
}
}
//代理角色，帮助我结婚
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("结婚之前，布置现场");
}
}
好处：代理对象可做很多真实对象做不了的事情
Lambda表达式
如果接口只包含唯一一个抽象，那么它就是一个函数式接口；对于函数式接口，可以通过lambda表达式来创建该接口的对象
public class testLambda1 {
//3.静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println("I Like 2");
}}
public static void main(String[] args) {
ILike like = new Like();//接口去new一个实现类
like.lambda();
Like2 like2 = new Like2();
like2.lambda();
//4.局部内部类
class Like3 implements ILike{
@Override
public void lambda() {
System.out.println("I Like 3");
}}
Like3 like3 = new Like3();
like3.lambda();
//匿名内部类，没有类的名称，必须借助接口或者父类
like =new ILike() {
@Override
public void lambda() {
System.out.println("I Like 4");
}
};
like.lambda();
//6.用lambda简化
like = ()->{
System.out.println("I Like 5");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike{
void lambda();
}
//2.实现类
class Like implements ILike{
@Override
public void lambda() {
System.out.println("I Like ");
}
}
只有一个接口和一个实现类，1到6是逐步简化过程。上面就是一个函数式接口，可用lambda简化
下面是带参数的
public class testLambda2 {
public static void main(String[] args) {
ILove love = new Love();
love.love(2);
}
}
interface ILove{
void love(int a);
}
class Love implements ILove{
@Override
public void love(int a) {
System.out.println("I love you-->"+a);
}
}
与
public class testLambda2 {
public static void main(String[] args) {
ILove love = null;
/*
ILove love = (int a)->{
System.out.println("I love you"+a);
};
//类型简化
love = (a)-> {
System.out.println("I love you"+a);
};
//简化括号
love = a->{
System.out.println("I love you"+a);
};
//去掉花括号
*/
love =a->System.out.println("I love you"+a);
love.love(521);
}
}
interface ILove{
void love(int a);
}
class Love implements ILove{
@Override
public void love(int a) {
System.out.println("I love you-->"+a);
}
}
是一样的(输出为521)
最后能去掉花括号的原因是代码只有一行
lambda表达式实现前提一定是函数式接口
多个参数也可以去掉参数类型，要去掉就都去掉，加上括号