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