1. 单例模式（一个类只有一个实例）
package ch.test.notes.designmodel; /** * Description: 单例模式 （饿汉模式 线程安全的） * * @author cy * @date 2019年05月10日 9:33 * version 1.0 */ public class Singelon { private static Singelon si = new Singelon(); public static Singelon getInstance() { return si; } private Singelon() { // 将构造方法封装为私有化 } public void print(){ System.out.println("打印--------->"); } }
package ch.test.notes.designmodel; /** * Description: 单例模式 （懒汉模式）线程不安全 * * @author cy * @date 2019年05月10日 9:33 * version 1.0 */ public class Singelon { private static Singelon si = null; private Singelon() { // 将构造方法封装为私有化 } public static Singelon getInstance() { if(si == null){ si = new Singelon(); } return si; } public void print(){ System.out.println("打印--------->"); } }
2. 工厂模式（多个子类实现一个接口，根据不同子类复写父类方法，根据业务产生不同的实例）
package ch.test.notes.designmodel; /** * Description:定义一个人的接口 * * @author cy * @date 2019年05月10日 9:50 * version 1.0 */ public interface Person1 { // 人的身高 String getHeight(); // 职位 String getWork(); }
创建两个实现类
package ch.test.notes.designmodel; /** * Description: 实现类 * * @author cy * @date 2019年05月10日 9:52 * version 1.0 */ public class Student implements Person1 { @Override public String getHeight() { return "12"; } @Override public String getWork() { return "我的职位是学生！"; } }
package ch.test.notes.designmodel; /** * Description:实现类 * * @author cy * @date 2019年05月10日 9:53 * version 1.0 */ public class Tearch implements Person1 { @Override public String getHeight() { return "150"; } @Override public String getWork() { return "我的职位是教师！"; } }
创建一个工厂，根据类型不同创建不同的对象
package ch.test.notes.designmodel; /** * Description: 人员工厂 * * @author cy * @date 2019年05月10日 9:55 * version 1.0 */ public class Factory { public static Person1 getInstance(String type){ Person1 person = null; if("1".equals(type)){ person = new Student(); }else { person = new Tearch(); } return person; } }
测试（传入不同的类型，得到不同的对象内容）
package ch.test.notes.designmodel; /** * Description: // 设计模式 * * @author cy * @date 2019年05月10日 9:16 * version 1.0 */ public class main { public static void main(String[] args) { Person1 instance = Factory.getInstance("0"); String work = instance.getWork(); System.out.println(work); } }
3. 代理模式 （由一个主题来操作一个真实主题，代理服务器来完成一个真实业务以外的业务）
角色（要做的东西， 假设只有vip 能做， 代理就是vip 普通人员不是，所以需要代理人代理）
package ch.test.notes.designmodel; /** * Description: 商店 * * @author cy * @date 2019年05月10日 10:32 * version 1.0 */ public interface Store { // 买东西 String getGoods(boolean vip); }
package ch.test.notes.designmodel; /** * Description: * * @author cy * @date 2019年05月10日 10:35 * version 1.0 */ public class StoreImpl implements Store { private int num = 10; @Override public String getGoods(boolean vip) { if(!vip){ System.out.println("只有VIP才能购买商品！"); return "只有VIP才能购买商品！"; } num --; System.out.println("购买了货物，剩余数量为"+ num); return "购买了货物，剩余数量为"+ num; } }
package ch.test.notes.designmodel; /** * Description: 代理 * * @author cy * @date 2019年05月10日 10:34 * version 1.0 */ public class Proxy{ private Store store; private Boolean vip = true; public Proxy(Store store){ this.store = store; } // 购买商品 public String getGoods() { // 这里也可以做一些校验 // 检查身份证 return store.getGoods(this.vip); } }
package ch.test.notes.designmodel; /** * Description: // 设计模式 * * @author cy * @date 2019年05月10日 9:16 * version 1.0 */ public class main { public static void main(String[] args) { StoreImpl store = new StoreImpl(); store.getGoods(false); new Proxy(store).getGoods(); } }
结果：
只有VIP才能购买商品！
购买了货物，剩余数量为9
4. 委派模式（相当于领导给项目经理下达任务，项目经理将不同的任务，下达到不同的人上面，和上面的区别是注重的是结果，不需要过程）
（角色 做任务 员工A 员工B 组长 组长接到任务后，分配给A和B）
package ch.test.notes.designmodel; /** * Description: 老板需要做的任务 * * @author cy * @date 2019年05月10日 11:08 * version 1.0 */ public interface ITarget { public void doSomething(String command); }
package ch.test.notes.designmodel; /** * Description: * * @author cy * @date 2019年05月10日 11:10 * version 1.0 */ public class TargetA implements ITarget{ @Override public void doSomething(String command) { System.out.println("我是员工A,开始做"+command+"工作"); } }
package ch.test.notes.designmodel; /** * Description: * * @author cy * @date 2019年05月10日 11:10 * version 1.0 */ public class TargetB implements ITarget{ @Override public void doSomething(String command) { System.out.println("我是员工B,开始做"+command+"工作"); } }
package ch.test.notes.designmodel; import java.util.HashMap; import java.util.Map; /** * Description: 组长 * * @author cy * @date 2019年05月10日 11:11 * version 1.0 */ public class Leader implements ITarget { private Map<String,ITarget> map = new HashMap<>(); public Leader(){ map.put("打扫",new TargetA()); map.put("吃饭",new TargetB()); } @Override public void doSomething(String command) { map.get(command).doSomething(command); } public static void main(String[] args) { new Leader().doSomething("吃饭"); new Leader().doSomething("打扫"); } }
5. 策略模式
背景：在软件开发过程中，要实现一种功能，需要多种算法或者策略，我们可以根据应用场景不同，选择不同算法和策略和实现该功能。比如一系列算法，把每个算法封装
起来，并且使他们可以相互替换，这就是策略模式。
假如我们有一个鸭子的抽象类，包含行为所有的鸭子都会游泳，属性鸭子的信息，如果我们增加一个飞行的功能，但是有些鸭子没有飞行的能力，所以我们不能再抽象类
中加入飞行的方法。这时候，就需要我们抽象一个飞的接口。
1.首先抽象一个策略接口
package ch.test.notes.designmodel; /** * Description:策略接口 * * @author cy * @date 2019年05月10日 12:37 * version 1.0 */ public interface CarFunction { void run(); //每辆车有不同的行驶方法 }
2.具体策略父类
package ch.test.notes.designmodel; /** * Description:每个车都具有的相同的属性和行为 * * @author cy * @date 2019年05月10日 12:38 * version 1.0 */ public class Car implements CarFunction { protected String name; //车名字 protected String color; //车颜色 public Car(String name, String color) { this.name = name; this.color = color; } @Override public void run() { System.out.println(color +" " + name +"在行驶。。。"); } }
具体策略实现子类
package ch.test.notes.designmodel; /** * Description: * * @author cy * @date 2019年05月10日 13:09 * version 1.0 */ public class SmallCar extends Car { public SmallCar(String name, String color) { super(name, color); } @Override public void run() { System.out.println(color +" " + name +"在高速的行驶。。。"); } }
package ch.test.notes.designmodel; /** * Description: * * @author cy * @date 2019年05月10日 13:11 * version 1.0 */ public class BussCar extends Car { public BussCar(String name, String color) { super(name, color); } @Override public void run() { System.out.println(color +" " + name +"在缓慢的行驶。。。"); } }
应用场景
package com.design.strategy; /** * * @ClassName : Person * @Description : 应用场景类 * */ public class Person { private String name; //姓名 private Integer age; //年龄 private Car car; //拥有车 public void driver(Car car){ System.out.print(name +" "+ age+" 岁 "+" 开着"); car.run(); } public Person(String name,Integer age) { this.name=name; this.age=age; } }
运行环境
package com.design.strategy; /** * * @ClassName : Strategy * @Description : 运行环境类:Strategy * @date : 2017年12月9日 上午11:43:58 * */ public class Strategy { public static void main(String[] args) { Car smallCar = new SmallCar("路虎","黑色"); Car bussCar = new BussCar("公交车","白色"); Person p1 = new Person("小明", 20); p1.driver(smallCar); p1.driver(bussCar); } } 运行结果： 小明 20 岁 开着黑色 路虎在高速的行驶。。。 小明 20 岁 开着白色 公交车在缓慢的行驶。。。
6.原型模式
就是对对象的拷贝，深拷贝、浅拷贝生成新的对象。
7.适配器模式 （由源到目标的适配）
目标
public interface Robot { public void cry(); public void move(); }
源
public class Dog { public void shout() { System.out.println("狗可以汪汪叫！"); } public void run() { System.out.println("狗可以跑！"); } }
进行适配
public class DogAdapter extends Dog implements Robot { public void cry(){ System.out.print("机器人模仿："); super.shout(); } public void move(){ System.out.print("机器人模仿："); super.run(); } }
如果想要实现一个接口，但是又不想实现所有的接口，我们可以抽象出来一个方法，然后再去继承这个类，进行方法的复写，这也是适配模式