Java基础十 - 设计模式

一、单例

1. 创建

• 饿汉式

package basic;

public class ESingleton {
    // 先私有化静态实例
    private static ESingleton eSingleton = new ESingleton();
    // 私有化构造方法，防止外部实例化
    private ESingleton(){};

    // 提供全局访问方法
    public static ESingleton geteSingleton(){
        return eSingleton;
    }

}

• 懒汉式

package basic;

public class LazySingleton {
    // 创建私有静态实例，null
    private static LazySingleton lazySingleton = null;
    // 私有构造方法，防止外部实例化
    private LazySingleton(){};
    // 提供全局访问点，使用同步方法解决线程安全问题
    public static synchronized LazySingleton getLazySingleton(){
        if (lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

2. 区别

1. 饿汉式是在实例化私有静态类加载时就创建，不管是否需要用；
2. 懒汉式是在实例加载时声明但是木有创建，只有外部调用get需要用的时候才会创建
    需要注意线程安全

二、观察者模式

1. 创建及概念

• 概念

1. 观察者模式是1对多，其中1发生变化后会自动通知，也能感知到变化
2. 例如：假设有三个人，小美（女，22），小王和小李。小美很漂亮，小王和小李是两个程序猿，时刻关注着小美的一举一动。有一天，小美说了一句：“谁来陪我打游戏啊。”这句话被小王和小李听到了，结果乐坏了，蹭蹭蹭，没一会儿，小王就冲到小美家门口了，在这里，小美是被观察者，小王和小李是观察者，被观察者发出一条信息，然后观察者们进行相应的处理

• 创建
  • 写一个接口用于获取消息

package basic.pattern;

public interface Person {
    // 用于获取消息
    void getMessage(String s);
}

•  声明3个人的类

package basic.pattern;

public class Li implements Person {
    private static String name = "Xiao Li";

    public Li(){};

    @Override
    public void getMessage(String s) {
        System.out.println(name + "收到消息" + s);
    }
}

  

package basic.pattern;

public class Wang implements Person{
    private static String name = "Xiao Wang";
    public Wang(){};

    @Override
    public void getMessage(String s){
        System.out.println(name + "收到消息: " + s);
    }
}

package basic.pattern;

import java.util.ArrayList;
import java.util.List;

public class Mei {
    List<Person> list = new ArrayList<Person>();

    public Mei(){};
    public void addPerson(Person person){
        list.add(person);
    }

    //遍历list，把自己的通知发送给所有暗恋自己的人
    public void notifyPerson(){
        for (Person person:list){
            //主要这一步，调用对应人的getMessage方法，达到通知的目的
            person.getMessage("Come here!");
        }
    }


}

• 测试

package basic.pattern;

public class TestObserverPattern {
    public static void main(String[] args) {
        Mei mei = new Mei(); //执行这个的时候已经执行了List<Person> list = new ArrayList<Person>();

        Li li = new Li();
        Wang wang = new Wang();

        mei.addPerson(li);
        mei.addPerson(wang);

        mei.notifyPerson();
    }
}

输出：

Xiao Li收到消息Come here!
Xiao Wang收到消息: Come here!

三、适配器模式

1. 概念

将两种完全不同的事物联系到一起，就像现实生活中的变压器。假设一个手机充电器需要的电压是20V，但是正常的电压是220V，这时候就需要一个变压器，将220V的电压转换成20V的电压，这样，变压器就将20V的电压和手机联系起来了。

2. 创建

package basic.pattern;

public class AdapterTest {
    public static void main(String[] args) {
        System.out.println();
        Phone phone = new Phone();
        VoltageAdapter adapter = new VoltageAdapter();
        phone.setAdapter(adapter);
        phone.charge();
    }

    // 手机类
    static class Phone {
        public static final int V = 220; // 原始常量
        private VoltageAdapter adapter;

        // 充电
        public void charge() {
            adapter.changeVoltage();
        }

        public void setAdapter(VoltageAdapter adapter) {
            this.adapter = adapter;
        }
    }

    // 变压器类
    static class VoltageAdapter {
        public void changeVoltage() {
            System.out.println("正在充电");
            System.out.println("原始电压是：" + Phone.V + "V");
            System.out.println("变压后电压是：" + (Phone.V - 200) + "V");
        }
    }
}

说明：

1. Phone（手机类）：

这个类表示手机。在充电时，手机需要一个适配器来转换电压。
V 是手机需要的电压，初始值为 220V。
charge() 方法是手机充电的方法，调用适配器的方法来改变电压。

2.VoltageAdapter（变压器类）：

这个类表示电压适配器，用于将原始电压转换成适合手机的电压。
changeVoltage() 方法改变电压，输出充电信息，原始电压和转换后电压。

3. AdapterTest（适配器测试类）：

main 方法创建了一个手机和一个电压适配器的实例。
phone.setAdapter(adapter) 将适配器设置给手机。
phone.charge() 调用手机的充电方法，实际上会调用适配器的电压转换方法。

四、工厂模式

1. 简介

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的方式，
将对象的创建与使用分离。工厂模式通过使用一个共同的接口来创建不同类型的对象，
使得客户端代码不需要直接依赖于具体类的实例化。

说白了就是把创建对象和使用分离，降低耦合

封装了对象的创建过程，客户端只需要调用工厂方法，而不需要关心对象的具体创建细节。
降低了客户端和具体类之间的耦合，使得代码更加灵活和可维护。

2. 上代码

创建Car的接口，实名有哪些方法

package basic.pattern;

public interface Car {
    public void run();
    public void stop();
}

package basic.pattern;

class Benz implements Car{

    @Override
    public void run() {
        System.out.println("Benz is running");
    }

    @Override
    public void stop() {
        System.out.println("Benz is stopping");

    }
}

class Ford implements Car{

    @Override
    public void run() {
        System.out.println("Ford is running");
    }

    @Override
    public void stop() {
        System.out.println("Ford is stopping");
    }
}

class Factory{
    public static Car getCarInstance(String carType){
        Car c = null;
        if (carType.equals("Benz")){
            c = new Benz();
        }
        if (carType.equals("Ford")){
            c = new Ford();
        }
        return c;
    }
}


class Test{
    public static void main(String[] args) {
        Car c = Factory.getCarInstance("Benz");
        if(c != null){
            c.run();
            c.stop();
        }else {
            System.out.println("造不了这种汽车。。。");
        }
    }

        }

未完待续~~~~