静态代理模式

1、真实对象和代理对象都需要使用同一接口

2、代理对象要代理真实对象

代理对象可以做真实对象做不了的东西；

真实对象可以专注于自己的东西；

public class Testc {
    public static void main(String[] args) {
        company company = new company(new de());
        company.marr();
​
    }
​
}
​
interface marry{
    void marr();
}
​
class de implements marry{
    @Override
    public void marr() {
        System.out.println("好耶！！");
    }
}
 class company implements marry{
    private marry hi;
​
     public company(marry hi) {
         this.hi = hi;
     }
​
     @Override
     public void marr() {
         before();
         this.hi.marr();
         after();
​
​
     }
​
     private void after() {
         System.out.println("结婚之后");
     }
​
     private void before() {
         System.out.println("结婚之前");
     }
 }

Lamda表达式

意义：避免匿名内部定义过多；

实质属于函数式编程；

任何接口，只包含唯一一个抽象方法的就是函数式接口—可以用Lamda表达式

       fine m=null;
​
         m = (a) -> {
            System.out.println("Lamda!" + a);
        };
         m.good(6);
​
//去掉括号，参数只能有一个才能去掉括号
        m = a -> {
            System.out.println("Lamda!" + a);
        };
        m.good(6);
​
//去掉花括号 （只能有一行代码，否则代码块）
         m=a-> System.out.println("Lamda!!!!"+a);
         m.good(90);
​
​
​
interface fine{
    void good(int a);
}  //接口

更加的简单；

多个参数也可以去掉参数类型，但是要去掉都去掉，必须加上括号；

线程的停止

建议是让线程自己正常停止，不建议死循环；

建议使用标志位，自己设置一个标志位；

不要使用Stop,destory等方法；

public class Threadstop implements Runnable {
   private boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while (flag){
            System.out.println("线程..."+i++);
        }
    }
    //线程的标志位
    public void  stop(){
        flag=false;
    }
​
    public static void main(String[] args) {
        Threadstop t1 = new Threadstop();
        new Thread(t1).start();
        for (int i = 0; i < 500; i++) {
            System.out.println(i);
            if (i==250){
                t1.stop();
                System.out.println("线程停止！");
            }
        }
    }
}
​

线程和主函数一直都在运行，在250 的时候，启动了Stop标志位，线程停止，而主函数继续跑完。

线程休眠

sleep的1000=1秒；

异常为InterruptedException;

Sleep可以模拟网络延迟，倒计时等

每一个对象都有一个锁，sleep不会释放锁；

倒计时：

package Stop;
​
public class Testsleep {
    public static void tendown() throws InterruptedException {
        int num=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0){
                    break;
                }
            }
        }
​
    public static void main(String[] args) {
        try {
            tendown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    }

打印系统当前时间：

package Stop;
​
import java.text.SimpleDateFormat;
import java.util.Date;
​
​
public class Nowtime {
    public static void main(String[] args) {
        Date nowdata = new Date(System.currentTimeMillis());
        while (true) {
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(nowdata));
                nowdata = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}