静态代理
以结婚为例子,结婚的双方相当于真是角色,而婚庆公司相当于,代理结婚双方,帮助处理结婚的事情,结婚,是实现都实现结婚接口即可
package com.lean.demo02;
public class StaticProxy {
public static void main(String[] args) {
//new WeddingCompany(new You()).HappyMarry();
//new Thread(()-> System.out.println("I Love You")).start();
WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.HappyMarry();
}
}
interface Marry{
//人间四大喜事
//久旱逢甘露
//他乡遇故知
//洞房花烛夜
//金榜题名时
void HappyMarry();
}
//真实角色,你去结婚
class You implements Marry{
@Override
public void HappyMarry() {
System.out.println("very happy");
}
}
//代理角色,帮助结婚
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 before(){
System.out.println("Before Marry");
}
private void after() {
System.out.println("After Marry");
}
}
/*
静态代理模式总结:
真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色
好处:
代理对象可以做很多真是对象做不了的事情
真实对象可专注做自己的事情
*/
Lamda表达式
任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口,只有函数式接口,我们才可以通过lambda表达式来创建该接口的对象。
package com.lean.demo02;
//推导lambda表达式
public class TestLambda1 {
//3.静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda2");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lambda();
ILike like2 = new Like2();
like2.lambda();
//4.局部内部类
class Like3 implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda3");
}
}
ILike like3 = new Like3();
like3.lambda();
//5.匿名内部类,没有类的名称,必须借助接口或父类
like = new ILike() {
@Override
public void lambda() {
System.out.println("I like lambda4");
}
};
like.lambda();
//6.用lambda简化
like = ()->{
System.out.println("I like lambda5");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike{
void lambda();
}
//2.实现类
class Like implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda");
}
}
总结:
-
lambda表达式只能由一行代码的情况下才能简化成一行,如果由多行代码,那么就用代码块包裹
like = a->System.out.println("I like number"+a);
-
多个参数也可以去掉参数类型,要去掉就都去掉类型,必须加上括号;
like = (a,b)->{ System.out.println("I like number"+a); System.out.println("I like number"+b); };
线程状态
创建状态,就绪状态,阻塞状态,运行状态,死亡状态
方法 | 说明 |
---|---|
setPriority(int newPriority) | 更改线程的优先级 |
static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠(相当于插队) |
void join() | 等待线程终止 |
static void yield() | 暂停当前正在执行的线程对象,并执行其他的线程 |
void interrupt() | 中断线程,不建议使用 |
boolean isAlive() | 测试线程是否处于活动状态 |
停止线程
-
不推荐使用JDK提供的stop(),destory()方法
-
推荐让线程自己停下来,建议使用标志位进行终止变量,当flag=false,则终止线程的运行。
package com.lean.demo02;
import jdk.nashorn.internal.ir.Flags;
//建议线程正常停止——————>利用次数,不建议死循环
//建议使用标志位--->设置一个标志位
//不要使用stop(),destory()等过时的方法
public class TestStop implements Runnable{
//设置一个标志位
private Boolean flag = true;
@Override
public void run() {
int i=0;
while(flag){
System.out.println("run.....Thread"+i++);
}
}
//设置一个公开的方法,停止线程,转换标志位
public void stop(){
this.flag = false;
}
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main"+i);
if(i==900){
//调用stop方法,让线程停止
testStop.stop();
System.out.println("线程停止了");
}
}
}
}
线程休眠
- sleep(时间)指定当前线程阻塞的毫秒数 1s= 1000ms
- sleep存在异常InetruptedException;
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延迟,倒计时等
- 每一个对象都有一个锁,sleep不会释放锁
package com.lean.demo02;
import java.sql.SQLOutput;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestSleep2 {
public static void main(String[] args) {
// 计时器
// try {
// tenDown();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//打印当前时间
Date startTime = new Date(System.currentTimeMillis());//获取系统当前时间
while (true){
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime = new Date(System.currentTimeMillis());//更新时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void tenDown()throws InterruptedException{
int num = 10;
while(true){
Thread.sleep(1000);
System.out.println(num--);
if (num<=0){
break;
}
}
}
}