標(biāo)簽（空格分隔）： android

設(shè)計(jì)模式六大原則

• 單一職責(zé)原則：就一個(gè)類來(lái)說(shuō)，應(yīng)該僅有一個(gè)引起他變化的原因。
• 開(kāi)源封閉原則：類、模板、函數(shù)等應(yīng)該可以拓展，但不可修改。
• 里氏替換原則：所有引用基類的地方必須透明地使用其子類的對(duì)象。
• 依賴倒置的原則：高層模塊不應(yīng)該依賴低層模塊，兩者都應(yīng)該依賴于抽象，抽象不應(yīng)該依賴于細(xì)節(jié)，細(xì)節(jié)應(yīng)該依賴于抽象。
• 迪米特原則：一個(gè)軟件實(shí)體應(yīng)當(dāng)盡可能少地與其他實(shí)體發(fā)生相互作用。
• 接口隔離原則：一個(gè)類對(duì)另一個(gè)類的依賴應(yīng)建立在一個(gè)最小的接口。

單例模式

（1）餓漢模式

public class Sington{
    private static Sington sington = new Sington();
    private Sington(){
        
    }
    public static Sington getInstance(){
        return  sington;
    }
}

(2)懶漢模式

//懶漢模式（線程不安全）
public class Sington{
   private static Sington sington;
   private Sington(){

   }
   public static Sington getInstance(){
       if(sington == null){
           sington = new Sington();
       }
       return sington;
   }
}

//懶漢模式（線程安全）
public class Sington{
    private static Sington sington;
    private Sington(){
        
    }
    public static synchronized Sington getInstance(){
        if(sington == null){
            sington = new Sington();
        }
        return sington;
    }
}

(3)雙重檢查模式（DCL）

//雙重檢查模式
public class DCL {
    private static volatile DCL dcl;
    private DCL(){};
    public static DCL getInstance(){
        if(dcl == null){
            synchronized (DCL.class){
                if(dcl == null){
                    dcl = new DCL();
                }
            }
        }
        return dcl;
    }
}

(4)靜態(tài)內(nèi)部類單例模式和枚舉單例模式

/靜態(tài)內(nèi)部類單例模式
public class StaicSington {
    private StaicSington(){
        
    }
    public static StaicSington getInstance(){
        return SingletonHolder.singleton;
    }
    private static class SingletonHolder{
        private static final StaicSington singleton = new StaicSington();
    }
}
//枚舉單例，線程安全
 enum Singleton{
    INSTANCE;
    public void doSomeThing(){
        
    }
}

簡(jiǎn)單工廠模式

定義：屬于建造型模式，又一個(gè)工廠對(duì)象創(chuàng)建出哪一種產(chǎn)品類實(shí)例。

//調(diào)用
public class Simple {
    public static void main(String[] args){
        ComputerFactory.createComputer("hp").start();
    }
}

//抽象產(chǎn)品類
abstract class Computer{
    public abstract void start();
}

//具體產(chǎn)品類

class LenovoComputer extends Computer{
    @Override
    public void start() {
        System.out.println("Lenovo電腦");
    }
}

class HPComputer extends Computer{
    @Override
    public void start() {
        System.out.println("hp電腦");
    }
}

//工廠類
class ComputerFactory{
    public static Computer createComputer(String type){
        Computer computer = null;
        switch (type){
            case "lenovo":
                computer = new LenovoComputer();
                break;
            case "hp":
                computer = new HPComputer();
                break;
            default:
                break;
        }
        return computer;
    }
}

優(yōu)點(diǎn)：避免直接實(shí)例化類，降低耦合性。
缺點(diǎn)：實(shí)例化對(duì)象在編譯階段就已經(jīng)確定，添加新類型，需要修改工廠，這不符合開(kāi)放封閉原則。

工廠方法模式

定義：定義一個(gè)用于創(chuàng)建對(duì)象接口，讓子類決定實(shí)例化哪一個(gè)類，工廠方法讓一個(gè)類的實(shí)例化延遲到他的子類。

//調(diào)用
public class Simple {
    public static void main(String[] args){
        ComputerFactory computerFactory =new GDComputerFactory();
        LenovoComputer lenovoComputer = computerFactory.createCompter(LenovoComputer.class);
        lenovoComputer.start();
        HPComputer hpComputer = computerFactory.createCompter(HPComputer.class);
        hpComputer.start();
    }
}

//抽象產(chǎn)品類
abstract class Computer{
    public abstract void start();
}

//具體產(chǎn)品類

class LenovoComputer extends Computer{
    @Override
    public void start() {
        System.out.println("Lenovo電腦");
    }
}

class HPComputer extends Computer{
    @Override
    public void start() {
        System.out.println("hp電腦");
    }
}

abstract class ComputerFactory{
    public abstract <T extends Computer> T createCompter(Class<T> tClass);
}

//運(yùn)用反射的知識(shí)
class GDComputerFactory extends ComputerFactory{
    @Override
    public <T extends Computer> T createCompter(Class<T> tClass) {
        Computer computer = null;
        String className = tClass.getName();
        try{
            computer = (Computer) Class.forName(className).newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return (T)computer;
    }
}

建造者模式

定義：將一個(gè)復(fù)雜對(duì)象的構(gòu)建和它的表示分離，使得同樣的構(gòu)建過(guò)程可以建造不同的表示。

public class BuilderUse {

    public static void main(String[] args){
        Builder mbuilder = new MoonComputerBuilder();
        Director director = new Director(mbuilder);
        director.CreateCompter("i7","haha","三星DDr4");
    }
}

class ComputerOne{
    private String cpu;
    private String mainboard;
    private String ram;

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setMainboard(String mainboard) {
        this.mainboard = mainboard;
    }

    public void setRam(String ram) {
        this.ram = ram;
    }
}

//抽象的建造者
abstract class Builder{
    public abstract void buildeCpu(String cpu);
    public abstract void bulidMainboard(String mainboard);
    public abstract void buildRam(String ram);
    public abstract ComputerOne create();
}

class MoonComputerBuilder extends Builder{
    private ComputerOne computer = new ComputerOne();
    @Override
    public void buildeCpu(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void bulidMainboard(String mainboard) {
        computer.setMainboard(mainboard);
    }

    @Override
    public void buildRam(String ram) {
        computer.setRam(ram);
    }

    @Override
    public ComputerOne create() {
        return computer;
    }
}

class Director{
    Builder builder = null;
    public Director(Builder builder){
        this.builder = builder;
    }

    public ComputerOne CreateCompter(String cpu,String mainboard,String ram){
        this.builder.buildeCpu(cpu);
        this.builder.buildRam(ram);
        this.builder.bulidMainboard(mainboard);
        return builder.create();
    }
}

優(yōu)點(diǎn)：客戶端不必知道產(chǎn)品內(nèi)部細(xì)節(jié)，構(gòu)建者類相互獨(dú)立，易于拓展。
缺點(diǎn):產(chǎn)生了多余的對(duì)象Build對(duì)象和Director對(duì)象。

代理模式

定義：為其他對(duì)象提供一種代理以控制對(duì)這個(gè)對(duì)象的訪問(wèn)。

//抽象主題類
public interface IUser {
    void save();
    void get();
}

//實(shí)際主題類
public class User implements IUser {
    public void save(){
        System.out.println("User類調(diào)用");
    }

    @Override
    public void get() {
        System.out.println("User類調(diào)用---get");
    }
}

//靜態(tài)代理
public class UserProxy implements IUser {
    private IUser target;
    public UserProxy(IUser target){
        this.target = target;
    }
    public void save(){
        System.out.println("開(kāi)始代理類");
        target.save();
        System.out.println("提交事務(wù)。。。");
    }

    @Override
    public void get() {

    }
}

//動(dòng)態(tài)代理
public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object target){
        this.target = target;
    }
    public Object getProxyInstance(){
        //使用反射的知識(shí)
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("開(kāi)始ProxyFactory");
                        Object value = method.invoke(target,args);
                        System.out.println("開(kāi)始二");
                        return value;
                    }
                });
    }
}

優(yōu)點(diǎn)：真實(shí)主題類只用關(guān)注實(shí)際的邏輯業(yè)務(wù)，而無(wú)需關(guān)注非本職工作。

裝飾模式

定義：動(dòng)態(tài)地給一個(gè)對(duì)象添加額外的職責(zé)，裝飾模式比生成子類更加靈活。

public class Decoration {
    public static void main(String[] args){
        YangGuo yangGuo = new YangGuo();
        HongQiGong hongQiGong = new HongQiGong(yangGuo);
        hongQiGong.attackMagic();
    }
}

//抽象組件
abstract class Swordsman{
    abstract void attackMagic();
}
//組件具體的實(shí)現(xiàn)類
class YangGuo extends Swordsman{
    @Override
    void attackMagic() {
        System.out.println("楊過(guò)使用全真劍法");
    }
}
//抽象裝飾者
abstract class Master extends Swordsman{
    private Swordsman swordsman;
    public Master(Swordsman swordsman){
        this.swordsman = swordsman;
    }

    @Override
    void attackMagic() {
        swordsman.attackMagic();
    }
}

//裝飾者具體實(shí)現(xiàn)類
class HongQiGong extends Master{
    @Override
    void attackMagic() {
        super.attackMagic();
        teachAttackMagic();
    }

    public HongQiGong(Swordsman swordsman) {
        super(swordsman);
    }

    public void teachAttackMagic(){
        System.out.println("洪七公打狗棒");
        System.out.println("楊過(guò)使用打狗棒");
    }
}

優(yōu)點(diǎn)：符合開(kāi)放封閉原則，擴(kuò)展靈活性。
缺點(diǎn)：易出錯(cuò)，裝飾層次不能修飾層數(shù)過(guò)多，否則影響效率。

外觀模式

定義：要求一個(gè)子系統(tǒng)的外部與內(nèi)部通信必須通過(guò)一個(gè)統(tǒng)一的對(duì)象進(jìn)行，此模式下提供一個(gè)高層接口，使得子系統(tǒng)便于使用。
簡(jiǎn)單實(shí)例：

//客戶端調(diào)用
public class OutSee {
    public static void main(String[] args){
        Man man = new Man();
        //這個(gè)人使用降魔掌和太極拳
        man.TaiJiQuan();
        man.XiangMoZhang();
    }
}

//子系統(tǒng)

class ZhaoShi{
    public void TaiJiQuan(){
        System.out.println("使用招式太極拳");
    }
    public void QiShangQuan(){
        System.out.println("使用七傷拳");
    }
    public void XiangMoZhang(){
        System.out.println("使用降魔掌");
    }
}

//子系統(tǒng)
class LeiGong{
    public void JiuYing(){
        System.out.println("使用九陰真經(jīng)");
    }
    public void JiuYang(){
        System.out.println("使用九陽(yáng)神功");
    }
}

//外觀類
class Man{
    private ZhaoShi zhaoShi;
    private LeiGong leiGong;
    public Man(){
        zhaoShi = new ZhaoShi();
        leiGong = new LeiGong();
    }
    //使用太極拳先使用九陽(yáng)神功
    public void TaiJiQuan(){
        leiGong.JiuYang();
        zhaoShi.TaiJiQuan();
    }
    //使用降魔掌必須先使用九陰神功
    public void XiangMoZhang(){
        leiGong.JiuYing();
        zhaoShi.XiangMoZhang();
    }


}

優(yōu)點(diǎn)：減少相互依賴，降低耦合性，加強(qiáng)了安全性。
缺點(diǎn)：不符合開(kāi)放原則。

享元模式

定義：使用共享對(duì)象有效地支持大量細(xì)粒度對(duì)象。

//客戶端調(diào)用
public class ShareYuan {

    public static void main(String[] args){
        Goods goods1 = GoodsFactory.getGoods("oneplus7");
        goods1.showGoodPrice("32g");
        Goods goods2 = GoodsFactory.getGoods("oneplus7");
        goods1.showGoodPrice("32g");
        Goods goods3 = GoodsFactory.getGoods("oneplus7");
        goods1.showGoodPrice("128g");
    }
}

//抽象的享元角色
interface IGoods{
    public void showGoodPrice(String version);
}

//具體的享元對(duì)象

class Goods implements IGoods{
    private String name;
    private String version;
    Goods(String name){
        this.name = name;

    }
    @Override
    public void showGoodPrice(String version) {
        if(version.equals("32g")){
            System.out.println("價(jià)格為2365");
        }else if(version.equals("128g")){
            System.out.println("價(jià)格為5999");
        }
    }
}

//享元工廠

class GoodsFactory{
    private static Map<String,Goods> pool = new HashMap<>();
    public static Goods getGoods(String name){
        if(pool.containsKey(name)){
            System.out.println("使用緩存，key為"+name);
            return pool.get(name);
        }else {
            Goods goods = new Goods(name);
            pool.put(name,goods);
            System.out.println("創(chuàng)建商品，key為"+name);
            return goods;
        }
    }
}

使用場(chǎng)景：

• 系統(tǒng)中有大量相似對(duì)象。
• 需要緩存池。

策略模式

定義：定義一系列的算法，把每一個(gè)算法封裝起來(lái)，而且使它們可以相互轉(zhuǎn)換。策略模式獨(dú)立于使用它的用戶。
簡(jiǎn)單實(shí)例：

public class Concrete {
    public static void main(String args[]){
        Context context;
        context = new Context(new WeakRivalStrategy());
        context.fighting();

        context = new Context(new CommonRiverStrategy());
        context.fighting();
    }
}

//定義策略接口
interface FightingStrategy{
    public void fighting();
}

//具體策略實(shí)現(xiàn)
class WeakRivalStrategy implements FightingStrategy{
    @Override
    public void fighting() {
        System.out.println("遇到較弱的對(duì)手");
    }
}

class CommonRiverStrategy implements  FightingStrategy{
    @Override
    public void fighting() {
        System.out.println("遇到普通對(duì)手");
    }
}

//上下文對(duì)象
class Context{
    private FightingStrategy fightingStrategy;
    public Context(FightingStrategy fightingStrategy){
        this.fightingStrategy = fightingStrategy;
    }
    public void fighting(){
        fightingStrategy.fighting();
    }
}

優(yōu)點(diǎn)：可以避免使用多重條件語(yǔ)句，易于擴(kuò)展。
缺點(diǎn)：每個(gè)策略類都是一個(gè)類，復(fù)用性小；和迪米特原則違背。

觀察者模式

定義：定義對(duì)象間一種一對(duì)多的依賴關(guān)系，每當(dāng)一個(gè)對(duì)象改變狀態(tài)時(shí)，則所有依賴于它的對(duì)象都會(huì)得到通知并被自動(dòng)更新。

public class ObserveDo {
    public static void main(String args[]){
        SubscriptionSubject subscriptionSubject = new SubscriptionSubject();
        WeixinUser user1 = new WeixinUser("jake");
        WeixinUser user2 = new WeixinUser("tom");
        WeixinUser user3 = new WeixinUser("herry");
        subscriptionSubject.attach(user1);
        subscriptionSubject.attach(user2);
        subscriptionSubject.attach(user3);
        subscriptionSubject.notify("hahahahahaa");
    }
}

//抽象觀察者
interface Observer{
    public void update(String message);
}

//具體的觀察者
class WeixinUser implements Observer{
    private String name;

    public WeixinUser(String name){
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name+"-"+message);
    }
}

//抽象被觀察者
interface Subject{
    public void attach(Observer observer);
    public void detach(Observer observer);
    public void notify(String message);
}

//具體被觀察者
class SubscriptionSubject implements Subject{
    private List<Observer> observeDos = new ArrayList<>();

    @Override
    public void attach(Observer observer) {
        observeDos.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        observeDos.remove(observer);
    }

    @Override
    public void notify(String message) {
        for(Observer observer : observeDos){
            observer.update(message);
        }
    }
}

優(yōu)點(diǎn)：觀察者和被觀察者之間抽象耦合，容易拓展。
缺點(diǎn)：開(kāi)發(fā)效率低下。