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 list = new ArrayList();

    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 list = new ArrayList();

        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("造不了这种汽车。。。");
        }
    }

        }

未完待续~~~~

你可能感兴趣的:(java,设计模式,开发语言)