android設計模式簡單版

標簽(空格分隔): android


設計模式六大原則

  • 單一職責原則:就一個類來說昼扛,應該僅有一個引起他變化的原因瞭恰。
  • 開源封閉原則:類弛随、模板瓢喉、函數(shù)等應該可以拓展,但不可修改舀透。
  • 里氏替換原則:所有引用基類的地方必須透明地使用其子類的對象栓票。
  • 依賴倒置的原則:高層模塊不應該依賴低層模塊,兩者都應該依賴于抽象盐杂,抽象不應該依賴于細節(jié)逗载,細節(jié)應該依賴于抽象。
  • 迪米特原則:一個軟件實體應當盡可能少地與其他實體發(fā)生相互作用链烈。
  • 接口隔離原則:一個類對另一個類的依賴應建立在一個最小的接口厉斟。

單例模式

(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(){
        
    }
}

簡單工廠模式

定義:屬于建造型模式强衡,又一個工廠對象創(chuàng)建出哪一種產(chǎn)品類實例擦秽。

//調(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)點:避免直接實例化類,降低耦合性漩勤。
缺點:實例化對象在編譯階段就已經(jīng)確定感挥,添加新類型,需要修改工廠越败,這不符合開放封閉原則触幼。

工廠方法模式

定義:定義一個用于創(chuàng)建對象接口,讓子類決定實例化哪一個類究飞,工廠方法讓一個類的實例化延遲到他的子類置谦。

//調(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);
}

//運用反射的知識
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òu)建和它的表示分離,使得同樣的構(gòu)建過程可以建造不同的表示亿傅。

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)點:客戶端不必知道產(chǎn)品內(nèi)部細節(jié)媒峡,構(gòu)建者類相互獨立,易于拓展葵擎。
缺點:產(chǎn)生了多余的對象Build對象和Director對象谅阿。

代理模式

定義:為其他對象提供一種代理以控制對這個對象的訪問。

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

//實際主題類
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("開始代理類");
        target.save();
        System.out.println("提交事務酬滤。签餐。。");
    }

    @Override
    public void get() {

    }
}

//動態(tài)代理
public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object target){
        this.target = target;
    }
    public Object getProxyInstance(){
        //使用反射的知識
        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("開始ProxyFactory");
                        Object value = method.invoke(target,args);
                        System.out.println("開始二");
                        return value;
                    }
                });
    }
}


優(yōu)點:真實主題類只用關(guān)注實際的邏輯業(yè)務盯串,而無需關(guān)注非本職工作贱田。

裝飾模式

定義:動態(tài)地給一個對象添加額外的職責,裝飾模式比生成子類更加靈活嘴脾。

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

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

//裝飾者具體實現(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("楊過使用打狗棒");
    }
}

優(yōu)點:符合開放封閉原則,擴展靈活性。
缺點:易出錯译打,裝飾層次不能修飾層數(shù)過多耗拓,否則影響效率。

外觀模式

定義:要求一個子系統(tǒng)的外部與內(nèi)部通信必須通過一個統(tǒng)一的對象進行奏司,此模式下提供一個高層接口乔询,使得子系統(tǒng)便于使用。
簡單實例:

//客戶端調(diào)用
public class OutSee {
    public static void main(String[] args){
        Man man = new Man();
        //這個人使用降魔掌和太極拳
        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("使用九陽神功");
    }
}

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


}


優(yōu)點:減少相互依賴韵洋,降低耦合性竿刁,加強了安全性。
缺點:不符合開放原則搪缨。

享元模式

定義:使用共享對象有效地支持大量細粒度對象食拜。

//客戶端調(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);
}

//具體的享元對象

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("價格為2365");
        }else if(version.equals("128g")){
            System.out.println("價格為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;
        }
    }
}


使用場景:

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

策略模式

定義:定義一系列的算法痹届,把每一個算法封裝起來呻待,而且使它們可以相互轉(zhuǎn)換。策略模式獨立于使用它的用戶队腐。
簡單實例:

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();
}

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

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

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

優(yōu)點:可以避免使用多重條件語句蚕捉,易于擴展。
缺點:每個策略類都是一個類柴淘,復用性衅妊汀;和迪米特原則違背悠就。

觀察者模式

定義:定義對象間一種一對多的依賴關(guān)系千绪,每當一個對象改變狀態(tài)時,則所有依賴于它的對象都會得到通知并被自動更新梗脾。


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)點:觀察者和被觀察者之間抽象耦合荸型,容易拓展。
缺點:開發(fā)效率低下炸茧。

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
  • 序言:七十年代末瑞妇,一起剝皮案震驚了整個濱河市,隨后出現(xiàn)的幾起案子梭冠,更是在濱河造成了極大的恐慌辕狰,老刑警劉巖,帶你破解...
    沈念sama閱讀 222,378評論 6 516
  • 序言:濱河連續(xù)發(fā)生了三起死亡事件控漠,死亡現(xiàn)場離奇詭異蔓倍,居然都是意外死亡悬钳,警方通過查閱死者的電腦和手機,發(fā)現(xiàn)死者居然都...
    沈念sama閱讀 94,970評論 3 399
  • 文/潘曉璐 我一進店門偶翅,熙熙樓的掌柜王于貴愁眉苦臉地迎上來默勾,“玉大人,你說我怎么就攤上這事聚谁∧赴” “怎么了?”我有些...
    開封第一講書人閱讀 168,983評論 0 362
  • 文/不壞的土叔 我叫張陵形导,是天一觀的道長环疼。 經(jīng)常有香客問我,道長朵耕,這世上最難降的妖魔是什么炫隶? 我笑而不...
    開封第一講書人閱讀 59,938評論 1 299
  • 正文 為了忘掉前任,我火速辦了婚禮憔披,結(jié)果婚禮上等限,老公的妹妹穿的比我還像新娘。我一直安慰自己芬膝,他們只是感情好望门,可當我...
    茶點故事閱讀 68,955評論 6 398
  • 文/花漫 我一把揭開白布。 她就那樣靜靜地躺著锰霜,像睡著了一般筹误。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發(fā)上癣缅,一...
    開封第一講書人閱讀 52,549評論 1 312
  • 那天厨剪,我揣著相機與錄音,去河邊找鬼友存。 笑死祷膳,一個胖子當著我的面吹牛,可吹牛的內(nèi)容都是我干的屡立。 我是一名探鬼主播直晨,決...
    沈念sama閱讀 41,063評論 3 422
  • 文/蒼蘭香墨 我猛地睜開眼,長吁一口氣:“原來是場噩夢啊……” “哼膨俐!你這毒婦竟也來了勇皇?” 一聲冷哼從身側(cè)響起,我...
    開封第一講書人閱讀 39,991評論 0 277
  • 序言:老撾萬榮一對情侶失蹤焚刺,失蹤者是張志新(化名)和其女友劉穎敛摘,沒想到半個月后,有當?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體乳愉,經(jīng)...
    沈念sama閱讀 46,522評論 1 319
  • 正文 獨居荒郊野嶺守林人離奇死亡兄淫,尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內(nèi)容為張勛視角 年9月15日...
    茶點故事閱讀 38,604評論 3 342
  • 正文 我和宋清朗相戀三年屯远,在試婚紗的時候發(fā)現(xiàn)自己被綠了。 大學時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片拖叙。...
    茶點故事閱讀 40,742評論 1 353
  • 序言:一個原本活蹦亂跳的男人離奇死亡氓润,死狀恐怖,靈堂內(nèi)的尸體忽然破棺而出薯鳍,到底是詐尸還是另有隱情,我是刑警寧澤挨措,帶...
    沈念sama閱讀 36,413評論 5 351
  • 正文 年R本政府宣布挖滤,位于F島的核電站,受9級特大地震影響浅役,放射性物質(zhì)發(fā)生泄漏斩松。R本人自食惡果不足惜,卻給世界環(huán)境...
    茶點故事閱讀 42,094評論 3 335
  • 文/蒙蒙 一觉既、第九天 我趴在偏房一處隱蔽的房頂上張望惧盹。 院中可真熱鬧,春花似錦瞪讼、人聲如沸钧椰。這莊子的主人今日做“春日...
    開封第一講書人閱讀 32,572評論 0 25
  • 文/蒼蘭香墨 我抬頭看了看天上的太陽嫡霞。三九已至,卻和暖如春希柿,著一層夾襖步出監(jiān)牢的瞬間诊沪,已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 33,671評論 1 274
  • 我被黑心中介騙來泰國打工曾撤, 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留端姚,地道東北人。 一個月前我還...
    沈念sama閱讀 49,159評論 3 378
  • 正文 我出身青樓挤悉,卻偏偏與公主長得像渐裸,于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子尖啡,可洞房花燭夜當晚...
    茶點故事閱讀 45,747評論 2 361

推薦閱讀更多精彩內(nèi)容