-------------------------------------基础复习-------------------------------------------------------------------

* 单例设计模式：保证类在内存中只有一个对象。

* 如何保证类在内存中只有一个对象呢？

* (1)控制类的创建，不让其他类来创建本类的对象。private

* (2)在本类中定义一个本类的对象。Singleton s;

* (3)提供公共的访问方式。  public static Singleton getInstance(){return s}

* 单例写法两种：

* (1)饿汉式 开发用这种方式。

* 

//饿汉式

class Singleton {

//1,私有构造函数

private Singleton(){}

//2,创建本类对象

private static Singleton s = new Singleton();

//3,对外提供公共的访问方法

public static Singleton getInstance() {

return s;

}

public static void print() {

System.out.println("11111111111");

}

}

* (2)懒汉式 

* 

//懒汉式,单例的延迟加载模式

class Singleton {

//1,私有构造函数

private Singleton(){}

//2,声明一个本类的引用

private static Singleton s;

//3,对外提供公共的访问方法

public static Singleton getInstance() {

if(s == null)

//线程1,线程2

s = new Singleton();

return s;

}

public static void print() {

System.out.println("11111111111");

}

}

* (3)第三种格式

* 

class Singleton {

private Singleton() {}

public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改

}

DEMO:

public class Demo1_Singleton {

/**

* @param args

* * 单例设计模式：保证类在内存中只有一个对象。

*/

public static void main(String[] args) {

/*Singleton s1 = new Singleton();

Singleton s1 = Singleton.s; //成员变量被私有,不能通过类名.调用

Singleton.s = null;

Singleton s2 = Singleton.s;

System.out.println(s1 == s2);*/

Singleton s1 = Singleton.getInstance();

Singleton s2 = Singleton.getInstance();

System.out.println(s1 == s2);

}

}

/*

 * 饿汉式

 */

class Singleton {

//1,私有构造方法,其他类不能访问该构造方法了

private Singleton(){}

//2,创建本类对象

private static Singleton s = new Singleton();

//3,对外提供公共的访问方法

public static Singleton getInstance() { //获取实例

return s;

}

}

/*

* 饿汉式和懒汉式的区别

* 1,饿汉式是空间换时间,懒汉式是时间换空间

* 2,在多线程访问时,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象

*/

public static void main(String[] args) {

Singleton s1 = Singleton.getInstance();

Singleton s2 = Singleton.getInstance();

System.out.println(s1 == s2);

}

}

/*

 * 懒汉式,单例的延迟加载模式

 */

class Singleton {

//1,私有构造方法,其他类不能访问该构造方法了

private Singleton(){}

//2,声明一个引用

private static Singleton s ;

//3,对外提供公共的访问方法

public static Singleton getInstance() { //获取实例

if(s == null) {

//线程1等待,线程2等待

s = new Singleton();

}

return s;

}

多线程(Timer类）（计时器）

public class Demo3_Timer {

/**

* @param args

* @throws InterruptedException 

*/

public static void main(String[] args) throws InterruptedException {

Timer t = new Timer();

//在指定时间安排指定任务

//第一个参数,是安排的任务,第二个参数是执行的时间,第三个参数是过多长时间再重复执行

t.schedule(new MyTimerTask(), new Date(188, 6, 1, 14, 22, 50),3000);

while(true) {

Thread.sleep(1000);

System.out.println(new Date());

}

}

}

class MyTimerTask extends TimerTask {

@Override

public void run() {

System.out.println("起床背英语单词");

}

}

多线程(两个线程间的通信)

* 1.什么时候需要通信

* 多个线程并发执行时, 在默认情况下CPU是随机切换线程的

* 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印

* 2.怎么通信

* 如果希望线程等待, 就调用wait()

* 如果希望唤醒等待的线程, 就调用notify();

* 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

多线程(三个或三个以上间的线程通信)

* 多个线程通信的问题

* notify()方法是随机唤醒一个线程

* notifyAll()方法是唤醒所有线程

* JDK5之前无法唤醒指定的一个线程

* 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件

/*1,在同步代码块中,用哪个对象锁,就用哪个对象调用wait方法

 * 2,为什么wait方法和notify方法定义在Object这类中?

 *     因为锁对象可以是任意对象,Object是所有的类的基类,所以wait方法和notify方法需要定义在Object这个类中

 * 3,sleep方法和wait方法的区别?

 * a,sleep方法必须传入参数,参数就是时间,时间到了自动醒来

 *   wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待

 * b,sleep方法在同步函数或同步代码块中,不释放锁,睡着了也抱着锁睡

 *     wait方法在同步函数或者同步代码块中,释放锁

JDK1.5的新特性互斥锁)

* 1.同步

* 使用ReentrantLock类的lock()和unlock()方法进行同步

* 2.通信

* 使用ReentrantLock类的newCondition()方法可以获取Condition对象

* 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法

* 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

_设计模式(适配器设计模式)

* a.什么是适配器

* 在使用监听器的时候, 需要定义一个类事件监听器接口.

* 通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.

* 适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.

* b.适配器原理

* 适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.

* 适配器类需要定义成抽象的,因为创建该类对象,调用空方法是没有意义的

* 目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.

明天的计划 任务一总结 深度思考过完 补充DEMO没写完的功能