android设计模式简单版

标签（空格分隔）： android

---

设计模式六大原则

• 单一职责原则：就一个类来说，应该仅有一个引起他变化的原因。
• 开源封闭原则：类、模板、函数等应该可以拓展，但不可修改。
• 里氏替换原则：所有引用基类的地方必须透明地使用其子类的对象。
• 依赖倒置的原则：高层模块不应该依赖低层模块，两者都应该依赖于抽象，抽象不应该依赖于细节，细节应该依赖于抽象。
• 迪米特原则：一个软件实体应当尽可能少地与其他实体发生相互作用。
• 接口隔离原则：一个类对另一个类的依赖应建立在一个最小的接口。

单例模式

（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)静态内部类单例模式和枚举单例模式

/静态内部类单例模式
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(){
        
    }
}

简单工厂模式

定义：属于建造型模式，又一个工厂对象创建出哪一种产品类实例。

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

//抽象产品类
abstract class Computer{
    public abstract void start();
}

//具体产品类

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

优点：避免直接实例化类，降低耦合性。
缺点：实例化对象在编译阶段就已经确定，添加新类型，需要修改工厂，这不符合开放封闭原则。

工厂方法模式

定义：定义一个用于创建对象接口，让子类决定实例化哪一个类，工厂方法让一个类的实例化延迟到他的子类。

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

//抽象产品类
abstract class Computer{
    public abstract void start();
}

//具体产品类

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

建造者模式

定义：将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以建造不同的表示。

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

优点：客户端不必知道产品内部细节，构建者类相互独立，易于拓展。
缺点:产生了多余的对象Build对象和Director对象。

代理模式

定义：为其他对象提供一种代理以控制对这个对象的访问。

//抽象主题类
public interface IUser {
    void save();
    void get();
}

//实际主题类
public class User implements IUser {
    public void save(){
        System.out.println("User类调用");
    }

    @Override
    public void get() {
        System.out.println("User类调用---get");
    }
}

//静态代理
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() {

    }
}

//动态代理
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;
                    }
                });
    }
}

优点：真实主题类只用关注实际的逻辑业务，而无需关注非本职工作。

装饰模式

定义：动态地给一个对象添加额外的职责，装饰模式比生成子类更加灵活。

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();
}
//组件具体的实现类
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();
    }
}

//装饰者具体实现类
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("杨过使用打狗棒");
    }
}

优点：符合开放封闭原则，扩展灵活性。
缺点：易出错，装饰层次不能修饰层数过多，否则影响效率。

外观模式

定义：要求一个子系统的外部与内部通信必须通过一个统一的对象进行，此模式下提供一个高层接口，使得子系统便于使用。
简单实例：

//客户端调用
public class OutSee {
    public static void main(String[] args){
        Man man = new Man();
        //这个人使用降魔掌和太极拳
        man.TaiJiQuan();
        man.XiangMoZhang();
    }
}

//子系统

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

//子系统
class LeiGong{
    public void JiuYing(){
        System.out.println("使用九阴真经");
    }
    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();
    }


}

优点：减少相互依赖，降低耦合性，加强了安全性。
缺点：不符合开放原则。

享元模式

定义：使用共享对象有效地支持大量细粒度对象。

//客户端调用
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("创建商品，key为"+name);
            return goods;
        }
    }
}

使用场景：

• 系统中有大量相似对象。
• 需要缓存池。

策略模式

定义：定义一系列的算法，把每一个算法封装起来，而且使它们可以相互转换。策略模式独立于使用它的用户。
简单实例：

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

//具体策略实现
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();
    }
}

优点：可以避免使用多重条件语句，易于扩展。
缺点：每个策略类都是一个类，复用性小；和迪米特原则违背。

观察者模式

定义：定义对象间一种一对多的依赖关系，每当一个对象改变状态时，则所有依赖于它的对象都会得到通知并被自动更新。

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

优点：观察者和被观察者之间抽象耦合，容易拓展。
缺点：开发效率低下。