单例模式
观察者模式
装饰者模式
适配器模式
工厂模式
代理模式
单例模式
简单点说，就是一个应用程序中，某个类的实例对象只有一个，你没办法去new，因为构造器是被private修饰的，一般通过getInstance()的方法来获取它们的实例。
-
延时加载
public class Singleton { private static Singleton instance; private Singleton (){} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } -
立即加载
public class Singleton { private static Singleton instance = new Singleton(); private Singleton (){} public static Singleton getInstance() { return instance; } }
观察者模式
对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
示例：假设有三个人，小美（女，22），小王和小李。小美是被观察者，小王和小李是观察者，被观察者发出一条信息，然后观察者们进行相应的处理
• 定义接口
public interface Person {//小王和小李通过这个接口可以接收到小美发过来的消息void getMessage(String s);
}• 小王的实现类
@Data
public class LaoWang implements Person {@Overridepublic void getMessage(String s) {System.out.println("小王接到了小美打过来的电话，电话内容是：" + s);}}
• 小李的实现类
@Data
public class LaoLi implements Person {@Overridepublic void getMessage(String s) {System.out.println("小李接到了小美打过来的电话，电话内容是：->" + s);}}
• 小美的呼唤
@Data
public class XiaoMei {List<Person> list = new ArrayList<Person>();public void addPerson(Person person){list.add(person);}//遍历list，把自己的通知发送给所有暗恋自己的人public void notifyPerson() {for(Person person:list){person.getMessage("你们过来吧，谁先过来谁就能陪我一起玩儿游戏!");}}
}
• 场景测试
public class Test {public static void main(String[] args) {XiaoMei xiao_mei = new XiaoMei();LaoWang lao_wang = new LaoWang();LaoLi lao_li = new LaoLi();//小王和小李在小美那里都注册了一下xiao_mei.addPerson(lao_wang);xiao_mei.addPerson(lao_li);//小美向小王和小李发送通知xiao_mei.notifyPerson();}
}
装饰者模式
对已有的业务逻辑进一步的封装，使其增加额外的功能，用户在使用的时候，可以任意组装，达到自己想要的效果。
示例：三明治的组合（香肠+奶油+蔬菜+面包）
• 已有的业务类
@Data
public class Food {private String foodName;public Food(String foodName) {this.foodName = foodName;}public String make() {return foodName;};
}
• 面包类
//面包类
public class Bread extends Food {private Food basicFood;public Bread(Food basicFood) {this.basicFood= basicFood;}public String make() {return basicFood.make()+"+面包";}
}
• 奶油类
//奶油类
public class Cream extends Food {private Food basicFood;public Cream(Food basicFood) {this.basicFood = basicFood;}public String make() {return basicFood.make()+"+奶油";}
}
• 蔬菜类
//蔬菜类
public class Vegetable extends Food {private Food basicFood;public Vegetable(Food basicFood) {this.basicFood = basicFood;}public String make() {return basicFood.make()+"+蔬菜";}}
• 测试组合
public class Test {public static void main(String[] args) {Food food = new Bread(new Vegetable(new Cream(new Food("香肠"))));System.out.println(food.make());}
}适配器模式
通过适配器将两种不同的事物联系起来。
示例：手机充电器需要的电压是20V，正常的电压是220V，增加一个变压器即可
public class Test {public static void main(String[] args) {Phone phone = new Phone();VoltageAdapter adapter = new VoltageAdapter();phone.setAdapter(adapter);phone.charge();}
}// 手机类
class Phone {public static final int V = 220;// 正常电压220v，是一个常量private VoltageAdapter adapter;// 充电public void charge() {adapter.changeVoltage();}public void setAdapter(VoltageAdapter adapter) {this.adapter = adapter;}
}// 变压器
class VoltageAdapter {// 改变电压的功能public void changeVoltage() {System.out.println("正在充电...");System.out.println("原始电压：" + Phone.V + "V");System.out.println("经过变压器转换之后的电压:" + (Phone.V - 200) + "V");}
}
工厂模式
包含：简单工厂模式、工厂方法模式、抽象工厂模式
-
简答工厂模式
一个抽象接口，多个实现抽象接口的类，一个工厂类（用来实例化抽象的接口）
// 抽象产品类 abstract class Car {public void run();public void stop(); }// 具体实现类 class Benz implements Car {public void run() {System.out.println("Benz开始启动了。。。。。");}public void stop() {System.out.println("Benz停车了。。。。。");} }class Ford implements 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("造不了这种汽车。。。");}}} -
工厂方法模式
有四个角色，抽象工厂模式，具体工厂模式，抽象产品模式，具体产品模式。
不再是由一个工厂类去实例化具体的产品，而是由抽象工厂的子类去实例化产品// 抽象产品角色 public interface Moveable {void run(); }// 具体产品角色 public class Plane implements Moveable {@Overridepublic void run() {System.out.println("plane....");} }public class Broom implements Moveable {@Overridepublic 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();} } -
抽象工厂模式
与工厂方法模式不同的是，工厂方法模式中的工厂只生产单一的产品，而抽象工厂模式中的工厂生产多个产品
public abstract class AbstractFactory {public abstract Vehicle createVehicle();public abstract Weapon createWeapon();public abstract Food createFood(); } //具体工厂类，其中Food,Vehicle，Weapon是抽象类， public class DefaultFactory extends AbstractFactory{@Overridepublic Food createFood() {return new Apple();}@Overridepublic Vehicle createVehicle() {return new Car();}@Overridepublic 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();} }
代理模式
将任务交由第三方处理即为代理模式。代理模式分静态代理和动态代理两种。
-
静态代理
• 代理接口
//代理接口 public interface ProxyInterface { //需要代理的是结婚这件事，如果还有其他事情需要代理，比如吃饭睡觉上厕所，也可以写 void marry();}• 代理实现
public class WeddingCompany implements ProxyInterface {private ProxyInterface proxyInterface;public WeddingCompany(ProxyInterface proxyInterface) {this.proxyInterface = proxyInterface;}@Overridepublic 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{@Overridepublic void marry() {System.out.println("我们结婚啦～");} }• 场景测试
public class Test {public static void main(String[] args) {ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());proxyInterface.marry();} }
