设计模式

单利模式

• 懒汉式
  特点：不使用的时候也创建，浪费资源

public class SingleLanhan {
    private static  final SingleLanhan singleLanhan=new SingleLanhan();
    private SingleLanhan() {
    }
    public static SingleLanhan getInstance(){
        return singleLanhan;
    }

}

• 饿汉式
  特点：使用才加载，节省资源，虽然加锁，但是在，new Instance（）中 1，堆中分配内存；2，实例化类参数；3 地址指向内存；jvm 中2和3的的顺序是乱序的，所有有时候不能保证实例唯一

public class SingleErHan {
    private static SingleErHan singleErHan=null;
    private SingleErHan() {
    }
    public static SingleErHan getInstance(){
        if (singleErHan==null){
            synchronized (SingleErHan.class){
                if (singleErHan==null){
                    singleErHan=new SingleErHan();
                }
            }
        }
        return singleErHan;
    }

}

• 静态内部类
  特点：调用加载节省内存，保证实例唯一，但是初始化不能传入参数

public class SingleInnerClass {
    private SingleInnerClass() {
    }
    public static SingleInnerClass getInstance(){
        return InnerClass.INSTANCE;
    }
    private static class InnerClass{
        private static final SingleInnerClass INSTANCE=new SingleInnerClass();
    }
}

• 枚举

特点：调用加载节省内存，保证实例唯一

public enum  SingleMeJu {
    INSTANCE;

}

装饰者模式

• 利用抽象类解耦多个装饰者。

定义个被装饰抽象类

 abstract class Person {
    //被装饰抽象对象
    //穿衣方法
    public abstract void dress();
}

定义个装饰抽象类（逻辑所在）

 abstract class RobePerson extends Person{
    private Person person;

    public RobePerson(Person person) {
        this.person = person;
    }

    @Override
    public void dress() {
        person.dress();
    }
}

被装饰类

public class XiaoHuaPerson extends Person{
    @Override
    public void dress() {
      
    }
}

装饰类1

public class ShoShiDress extends RobePerson{
    public ShoShiDress(Person person) {
        super(person);
    }

    @Override
    public void dress() {
        super.dress();
        wordDress();
    }
    private void wordDress(){
        System.out.println("带了耳环");
    }

}

装饰类2

public class WorkDress extends RobePerson{
    public WorkDress(Person person) {
        super(person);
    }

    @Override
    public void dress() {
        super.dress();
        wordDress();
    }
    private void wordDress(){
        System.out.println("穿了工作服");
    }

}

装饰对象

    public static void main(String[] args) {
    	//被装饰者
        XiaoHuaPerson person = new XiaoHuaPerson();
        //装饰类2
        WorkDress workDress = new WorkDress(person);
        //装饰类1
        ShoShiDress shoShiDress = new ShoShiDress(workDress);
        shoShiDress.dress();
    }

观察者模式

观察者模式个人认为主要是被观察者存有观察者对象，循环调用观察者方法

• 观察者抽象类（这里我们用java自带的）

package java.util;
// 参数1 被观察者对象，参数2 需要更新的数据
public interface Observer {
    void update(Observable var1, Object var2);
}

• 被观察者抽象类（这里我们用java自带的）

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package java.util;

public class Observable {
	// changed 观察者是否更新数据的标志（默认是false,更新过为 true）
    private boolean changed = false;
    //观察者集合（线程安全）
    private Vector<Observer> obs = new Vector();

    public Observable() {
    }
	//添加 观察者方法
    public synchronized void addObserver(Observer var1) {
        if (var1 == null) {
            throw new NullPointerException();
        } else {
        	//判断是否已经添加
            if (!this.obs.contains(var1)) {
                this.obs.addElement(var1);
            }

        }
    }
	//移除观察者方法
    public synchronized void deleteObserver(Observer var1) {
        this.obs.removeElement(var1);
    }

    public void notifyObservers() {
        this.notifyObservers((Object)null);
    }
	//更新数据 通过循环，使得每个观察者能够更新数据
    public void notifyObservers(Object var1) {
        Object[] var2;
        synchronized(this) {
            if (!this.changed) {
                return;
            }

            var2 = this.obs.toArray();
            this.clearChanged();
        }

        for(int var3 = var2.length - 1; var3 >= 0; --var3) {
            ((Observer)var2[var3]).update(this, var1);
        }

    }

    public synchronized void deleteObservers() {
        this.obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        this.changed = true;
    }

    protected synchronized void clearChanged() {
        this.changed = false;
    }
	
    public synchronized boolean hasChanged() {
        return this.changed;
    }
	//返回观察者个数
    public synchronized int countObservers() {
        return this.obs.size();
    }
}

• 被观察者类

public class MyObservable extends Observable {
    public MyObservable() {
    }
    public void setChange(String s){
        setChanged();
        notifyObservers(s);
    }
}

• 观察者类1

public class MyFirstObserver implements Observer{
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("MyFirstObserver"+(String) arg);
    }
}

• 观察者类2

public class MyTwoObserver implements Observer{
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("MyTwoObserver"+(String) arg);
    }
}

使用

    public static void main(String[] args) {
        MyObservable myObservable=new MyObservable();

        MyFirstObserver myFirstObserver = new MyFirstObserver();
        MyTwoObserver myTwoObserver = new MyTwoObserver();
        myObservable.addObserver(myFirstObserver);
        myObservable.addObserver(myTwoObserver);
        myObservable.setChange("通知");
    }

策略模式

策略模式主要是对于一种行为结果，可以采用多种不同方案和策略，我们可以用抽象类规范这种行为方法，实现类实现不同的策略
场景：不同车有不同的计费方式，计算每次出行采用不同车的车费

• 车计价行为的抽象类或者叫车抽象类
  *接口定义是方法行为不是类的属性（对于接口方法要比类名有用）

public interface Car {
    int countPrice(int km);
}

• 车计价行为实现类

public class CarCtl implements Car{
    Car car;
    public  CarCtl(Car car){
        this.car=car;
    }
    @Override
    public int countPrice(int km) {
        System.out.println(car.countPrice(km)+"");
        return car.countPrice(km);
    }
}

• 车实现类

public class Bus implements Car {
    @Override
    public int countPrice(int km) {

        return km<3?1:2;
    }
}

public class TaxiCar implements Car{
    @Override
    public int countPrice(int km) {

        return km*3;
    }
}

调用

public class Main {
    public static void main(String[] args) {
    new CarCtl(new TaxiCar()).countPrice(10);
    }
}

责任链模式

场景：不知道一件事务谁来处理，可能需要层层判断审核，可以采用责任链模式。可以替代if else。实现方法类似装饰者模式，区别在于，装饰者模式在实现类中增加自己方法，而责任链模式在实现类中进行判断，选择是自己方法还是父类方法（上一级方法）

• 抽象类

public abstract class   Worker {
	//用户行为
     void worke(Worker myworker){};
     //判断等级谁来处理
    abstract int getLevel();
}

• 实现类

public class Boss extends Worker{
    public Worker worker;
    public void nextWorker(Worker worker) {
        this.worker=worker;
    }
    @Override
    public void worke(Worker myworker) {
        if (myworker.getLevel()==getLevel()){
            System.out.println("Boss处理");
        }else {
            if (worker==null){
                System.out.println("不能处理");
                return;
            }
            worker.worke(myworker);
        }
    }

    @Override
    int getLevel() {
        return 1;
    }
}

public class Groupder extends Worker {
    public Worker worker;
    public void nextWorker(Worker worker) {
        this.worker=worker;
    }
    @Override
    void worke(Worker myworker) {

        if (myworker.getLevel()==getLevel()){
            System.out.println("Groupder处理");
        }else {
            if (worker==null){
                System.out.println("不能处理");
                return;
            }
            worker.worke(myworker);
        }
    }

    @Override
    int getLevel() {
        return 2;
    }
}

public class YuanGong extends Worker{
    private int level;
    @Override
    int getLevel() {
        return level;
    }
    public void setLevel(int i){
        level=i;
    }
}

使用

    public static void main(String[] args) {
        int level=2;
        YuanGong yuanGong = new YuanGong();
        yuanGong.setLevel(level);

        Boss boss = new Boss();

        Groupder groupder = new Groupder();
        groupder.nextWorker(boss);

        groupder.worke(yuanGong);

    }

状态模式

电视机抽象类

public interface Dianshi {
    void upShow();
    void nextShow();
    void upVoice();
    void downVoice();
}

状态抽象类

public interface  TvStatus {
     void on();
     void off();
}

实现类

public class OnDianshi implements Dianshi {
    @Override
    public void upShow() {
        System.out.println("上个节目");
    }

    @Override
    public void nextShow() {
        System.out.println("下个节目");
    }

    @Override
    public void upVoice() {
        System.out.println("调高音量");
    }

    @Override
    public void downVoice() {
        System.out.println("降低音量");
    }
}

public class OffDianshi implements Dianshi{
    @Override
    public void upShow() {

    }

    @Override
    public void nextShow() {

    }

    @Override
    public void upVoice() {

    }

    @Override
    public void downVoice() {

    }
}

public  class DianCtl implements Dianshi,TvStatus{
    Dianshi dianshi=new OffDianshi();
    @Override
    public void on() {
        System.out.println("开机了");
        dianshi=new OnDianshi();
    }

    @Override
    public void off() {
        System.out.println("关机了");
        dianshi=new OffDianshi();
    }
    @Override
    public void upShow() {
        dianshi.upShow();
    }

    @Override
    public void nextShow() {
        dianshi.nextShow();
    }

    @Override
    public void upVoice() {
        dianshi.upVoice();
    }

    @Override
    public void downVoice() {
        dianshi.downVoice();
    }



}