设计模式—常用的设计模式介绍

Bertha 。 2022-03-15 05:16 334阅读 0赞

## 设计模式—常用的设计模式介绍 ##

### 1.单例模式(Singleton) ###

简单点说，就是一个应用程序中，某个类的实例对象只有一个，你没有办法去new，因为构造器是被private修饰的，一般通过getInstance()的方法来获取它们的实例。getInstance()的返回值是一个对象的引用，并不是一个新的实例

*  1>懒汉式写法(线程不安全)

/**
     * 懒汉式(线程不安全)
     */
    public class Singleton {
        private static Singleton singleton;
    
        private Singleton() {
        }
    
        public static Singleton getInstance() {
            if (singleton == null) {
                singleton = new Singleton();
            }
            return singleton;
        }
    
    }

*  2>懒汉式写法(线程安全)

/**
     * 懒汉式(线程安全)
     */
    public class Singleton2 {
        private static Singleton2 singleton;
    
        private Singleton2() {
        }
    
        /**
         * 使用了synchronized关键字
         * @return
         */
        public static synchronized Singleton2 getInstance() {
            if (singleton == null) {
                singleton = new Singleton2();
            }
            return singleton;
        }
    }

*  3>饿汉式写法

/**
     * 饿汉式
     */
    public class Singleton3 {
        private static Singleton3 singleton = new Singleton3();
    
        private Singleton3() {
        }
    
        public static Singleton3 getInstance() {
            return singleton;
        }
    }

*  4>静态内部类写法

/**
     * 静态内部类写法
     */
    public class Singleton4 {
    
        /**
         * 静态内部类
         */
        private static class SingletonHolder{
            private static final Singleton4 instance = new Singleton4();
        }
    
        private Singleton4() {
        }
    
        public static Singleton4 getInstance() {
            return SingletonHolder.instance;
        }
    }

*  5>双重校验锁

/**
     * 双重校验锁
     */
    public class Singleton5 {
        private volatile static Singleton5 singleton;
    
        private Singleton5() {
        }
    
        public static Singleton5 getInstance() {
            if (singleton == null) {
                synchronized (Singleton5.class) {
                    if (singleton == null) {
                        singleton = new Singleton5();
                    }
                }
            }
            return singleton;
        }
    }

### 2.工厂模式(Factory Method) ###

*  1>简单工厂模式：一个抽象的接口，多个抽象接口的实现类，一个工厂类，用来实例化抽象的接口

// 抽象产品类
    abstract class Car {
        public abstract void run();
    
        public abstract void stop();
    }
    
    // 具体实现类
    class Benz extends Car {
        public void run() {
            System.out.println("Benz开始启动了。。。。。");
        }
    
        public void stop() {
            System.out.println("Benz停车了。。。。。");
        }
    }
    
    class Ford extends Car {
        public void run() {
            System.out.println("Ford开始启动了。。。");
        }
    
        public void stop() {
            System.out.println("Ford停车了。。。。");
        }
    }
    
    // 工厂类
    class Factory {
        public static Car getCarInstance(String type) {
            Car c = null;
            if ("Benz".equals(type)) {
                c = new Benz();
            }
            if ("Ford".equals(type)) {
                c = new Ford();
            }
            return c;
        }
    }
    
    public class Test {
    
        public static void main(String[] args) {
            Car c = Factory.getCarInstance("Benz");
            if (c != null) {
                c.run();
                c.stop();
            } else {
                System.out.println("造不了这种汽车。。。");
            }
    
        }
    
    }

![在这里插入图片描述][20190228222730583.png]

*  2>工厂方法模式：有四个角色，抽象工厂模式，具体工厂模式，抽象产品模式，具体产品模式。不再是由一个工厂类去实例化具体的产品，而是由抽象工厂的子类去实例化产品

// 抽象产品角色
    public interface Moveable {
        void run();
    }
    
    // 具体产品角色
    public class Plane implements Moveable {
        @Override
        public void run() {
            System.out.println("plane....");
        }
    }
    
    public class Broom implements Moveable {
        @Override
        public void run() {
            System.out.println("broom.....");
        }
    }
    
    // 抽象工厂
    public abstract class VehicleFactory {
        abstract Moveable create();
    }
    
    // 具体工厂
    public class PlaneFactory extends VehicleFactory {
        public Moveable create() {
            return new Plane();
        }
    }
    
    public class BroomFactory extends VehicleFactory {
        public Moveable create() {
            return new Broom();
        }
    }
    
    // 测试类
    public class Test {
        public static void main(String[] args) {
            VehicleFactory factory = new BroomFactory();
            Moveable m = factory.create();
            m.run();
        }
    }

*  3>抽象工厂模式：与工厂方法模式不同的是，工厂方法模式中的工厂只生产单一的产品，而抽象工厂模式中的工厂生产多个产品

//抽象工厂类
    public abstract class AbstractFactory {
        public abstract Vehicle createVehicle();
        public abstract Weapon createWeapon();
        public abstract Food createFood();
    }
    //具体工厂类，其中Food,Vehicle，Weapon是抽象类，
    public class DefaultFactory extends AbstractFactory{
        @Override
        public Food createFood() {
            return new Apple();
        }
        @Override
        public Vehicle createVehicle() {
            return new Car();
        }
        @Override
        public Weapon createWeapon() {
            return new AK47();
        }
    }
    //测试类
    public class Test {
        public static void main(String[] args) {
            AbstractFactory f = new DefaultFactory();
            Vehicle v = f.createVehicle();
            v.run();
            Weapon w = f.createWeapon();
            w.shoot();
            Food a = f.createFood();
            a.printName();
        }
    }

### 3.观察者模式(Observer) ###

对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

public interface Person {
        //老王和老李通过这个接口可以接收到小美发过来的消息
        void getMessage(String s);
    }

public class LaoWang implements Person {
    
        private String name = "老王";
    
        public LaoWang() {
        }
    
        @Override
        public void getMessage(String s) {
            System.out.println(name + "接到了小美打过来的电话，电话内容是：" + s);
        }
    
    }

public class LaoLi implements Person {
    
        private String name = "老李";
    
        public LaoLi() {
        }
    
        @Override
        public void getMessage(String s) {
            System.out.println(name + "接到了小美打过来的电话，电话内容是：->" + s);
        }
    
    }

老王和老李都喜欢小美,并且都实现了Person接口

这天,小美给执行了一个方法,老王和老李都收到了信息

public class XiaoMei {
        List<Person> list = new ArrayList<Person>();
         public XiaoMei(){
         }
    
         public void addPerson(Person person){
             list.add(person);
         }
    
         //遍历list，把自己的通知发送给所有暗恋自己的人
         public void notifyPerson() {
             for(Person person:list){
                 person.getMessage("今天家里就我一个人，你们过来吧，谁先过来谁就能得到我!");
             }
         }
    }

![在这里插入图片描述][20190228223657781.png]

### 4.代理模式(Proxy) ###

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

/**
     * 代理接口
     */
    public interface ProxyInterface {
        //需要代理的是结婚这件事
        void marry();
    }

/**
     * 代理类
     */
    public class WeddingCompany implements ProxyInterface {
    
        private ProxyInterface proxyInterface;
    
        public WeddingCompany(ProxyInterface proxyInterface) {
      		this.proxyInterface = proxyInterface;
     }
    
        @Override
        public void marry() {
        	System.out.println("我们是婚庆公司的");
        	System.out.println("我们在做结婚前的准备工作");
        	System.out.println("节目彩排...");
        	System.out.println("礼物购买...");
        	System.out.println("工作人员分工...");
        	System.out.println("可以开始结婚了");
        	proxyInterface.marry();
        	System.out.println("结婚完毕，我们需要做后续处理，你们可以回家了，其余的事情我们公司来做");
        }
    
    }

/**
     * 客户类
     */
    public class NormalHome implements ProxyInterface{
    
        @Override
        public void marry() {
            System.out.println("我们结婚啦～");
        }
    
    }

public class Test {
        public static void main(String[] args) {
            ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());
            proxyInterface.marry();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dpbnRlcnNoaWk_size_16_color_FFFFFF_t_70]

[20190228222730583.png]: /images/20220315/67a5cfe0bb2341a0aae1ac880fcb2ccf.png
[20190228223657781.png]: /images/20220315/358a14566e7146509b50185c5fd47f62.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dpbnRlcnNoaWk_size_16_color_FFFFFF_t_70]: /images/20220315/f101df4492254ee6827ef4b2da216a7e.png