2021/2/4学习内容：static 用法 静态代理

------------恢复内容开始------------

1.static用法

static方法可以通过类名调用，也可以在其他方法中直接调用

但是非静态方法只可以被非静态方法直接调用

public class person {
  public void run(){
　　　　　　
      
  }
  public static void go(){
      
  }
    public static void main(String[] args) {
        person p1 = new person();
        p1.go();
        person.go();
        go();
    }
}

2.static静态代码块，匿名代码块

public class person {
    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    person(){
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        person p1 = new person();
        System.out.println("=======");
        person p2 = new person();
    }
}

运行结果：

 

 

静态代码块最先运行且只运行一次，在每次创建对象时都会先运行匿名代码块和构造方法

3.导入静态static 可以直接用方法

import static java.lang.Math.random;
public class person {

    public static void main(String[] args) {
        System.out.println(random());
    }
}

4.静态代理

//静态代理模式总结：1.真实对象和代理对象实现同一个接口
//2.代理对象要代理真实角色
public class StaticProxy {
    public static void main(String[] args) {
        You y = new You();
        Weddingcompany weddingcompany = new Weddingcompany(y);
        weddingcompany.HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
}
//真实角色，你去结婚
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("我要结婚啦");
    }
}
//代理对象，婚庆公司帮助你结婚
class Weddingcompany implements Marry{
    private Marry target;
    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("婚礼前");
    }
}

 

5.lambda表达式

public class TestLambda {
    static class like1 implements ILike{//静态内部类
        @Override
        public void lambda() {
            System.out.println("i like wcc1");
        }
    }
    public static void main(String[] args) {
        class like2 implements ILike{//局部内部类（方法内定义）
            @Override
            public void lambda() {
                System.out.println("i like wcc2");
            }
        }
        ILike like = new like1();
        like.lambda();
        like = new like2();
        like.lambda();
        like = new ILike() {//匿名内部类（直接借助接口new）
            @Override
            public void lambda() {
                System.out.println("i like wcc3");
            }
        };
        like.lambda();
        like = () -> {
            System.out.println("i like wcc4");
        };
        like.lambda();
    }
}
interface ILike{//定义一个函数式接口（只有一个方法）
    void lambda();
}

当小括号里只有一个参数，lambda表达式的小括号可以去掉，当花括号里只有一行代码，花括号也可以简化。以及括号里的参数类型可以简化，要去掉都去掉。

 

 

 

 

 

------------恢复内容结束------------