public class Singleton { //1,私有构造方法 private Singleton() {} //2,在本类中创建本类对象 private static Singleton instance = new Singleton(); //3,提供一个公共的访问方式,让外界获取该对象 public static Singleton getInstance() { return instance; } }
public class Singleton { //私有构造方法 private Singleton() {} //声明Singleton类型的变量 private static Singleton instance; //null //在静态代码块中进行赋值 static { instance = new Singleton(); } //对外提供获取该类对象的方法 public static Singleton getInstance() { return instance; } }
public class Singleton { //私有构造方法 private Singleton() {} //声明Singleton类型的变量instance private static Singleton instance; //只是声明一个该类型的变量,并没有进行赋值 //对外提供访问方式 public static synchronized Singleton getInstance() { //判断instance是否为null,如果为null,说明还没有创建Singleton类的对象 //如果没有,创建一个并返回,如果有,直接返回 if(instance == null) { //线程1等待,线程2获取到cpu的执行权,也会进入到该判断里面 instance = new Singleton(); } return instance; } }
public class Singleton { //私有构造方法 private Singleton() {} //声明Singleton类型的变量 private static volatile Singleton instance; //对外提供公共的访问方式 public static Singleton getInstance() { //第一次判断,如果instance的值不为null,不需要抢占锁,直接返回对象 if(instance == null) { synchronized (Singleton.class) {//因为是静态的,所以当前锁为CLass对象 //第二次判断 if(instance == null) { instance = new Singleton(); } } } return instance; } }
public enum Singleton { INSTANCE; }
public class Client { public static void main(String[] args) { Singleton instance = Singleton.INSTANCE; Singleton instance1 = Singleton.INSTANCE; System.out.println(instance == instance1); } }
public interface CoffeeFactory { //创建咖啡对象的方法 Coffee createCoffee(); }
public class AmericanCoffeeFactory implements CoffeeFactory { public Coffee createCoffee() { return new AmericanCoffee(); } }
public class LatteCoffeeFactory implements CoffeeFactory { public Coffee createCoffee() { return new LatteCoffee(); } }
public abstract class Coffee { public abstract String getName(); //加糖 public void addsugar() { System.out.println("加糖"); } //加奶 public void addMilk() { System.out.println("加奶"); } }
public class AmericanCoffee extends Coffee { public String getName() { return "美式咖啡"; } }
public class LatteCoffee extends Coffee { public String getName() { return "拿铁咖啡"; } }
public class CoffeeStore { //私有工厂对象 private CoffeeFactory factory; //根据具体的工厂获取对象 public void setFactory(CoffeeFactory factory) { this.factory = factory; } //点咖啡功能 public Coffee orderCoffee() { Coffee coffee = factory.createCoffee(); //加配料 coffee.addMilk(); coffee.addsugar(); return coffee; } }
public class Client { public static void main(String[] args) { //创建咖啡店对象 CoffeeStore store = new CoffeeStore(); //创建对象 //CoffeeFactory factory = new AmericanCoffeeFactory(); CoffeeFactory factory = new LatteCoffeeFactory(); store.setFactory(factory); //点咖啡 Coffee coffee = store.orderCoffee(); System.out.println(coffee.getName()); } }
public abstract class Coffee { public abstract String getName(); //加糖 public void addsugar() { System.out.println("加糖"); } //加奶 public void addMilk() { System.out.println("加奶"); } }
public abstract class Dessert { public abstract void show(); }
public class AmericanCoffee extends Coffee { public String getName() { return "美式咖啡"; } }
public class LatteCoffee extends Coffee { public String getName() { return "拿铁咖啡"; } }
public class MatchaMousse extends Dessert { public void show() { System.out.println("抹茶慕斯"); } }
public class Trimisu extends Dessert { public void show() { System.out.println("提拉米苏"); } }
public class ItalyDessertFactory implements DessertFactory { public Coffee createCoffee() { return new LatteCoffee(); } public Dessert createDessert() { return new Trimisu(); } }
public class AmericanDessertFactory implements DessertFactory { public Coffee createCoffee() { return new AmericanCoffee(); } public Dessert createDessert() { return new MatchaMousse(); } }
public class Client { public static void main(String[] args) { //创建的是意大利风味甜品工厂对象 ItalyDessertFactory factory = new ItalyDessertFactory(); // AmericanDessertFactory factory = new AmericanDessertFactory(); //获取拿铁咖啡和提拉米苏甜品 Coffee coffee = factory.createCoffee(); Dessert dessert = factory.createDessert(); System.out.println(coffee.getName()); dessert.show(); } }
【例】火车站卖票
如果要买火车票的话,需要去火车站买票,坐车到火车站,排队等一系列的操作,显然比较麻烦。而火车站在多个地方都有代售点,我们去代售点买票就方便很多了。这个例子其实就是典型的代理模式,火车站是目标对象,代售点是代理对象。类图如下:
使用组合,在代理类中,将真正的类作为自己的属性。方法还是调用的真正的类去执行的。测试的时候直接访问的是代理对象,即:代理类作为访问对象和目标对象的中介,同时对方法进行了增强。
//卖票接口 public interface SellTickets { void sell(); } //火车站 火车站具有卖票功能,所以需要实现SellTickets接口 public class TrainStation implements SellTickets { public void sell() { System.out.println("火车站卖票"); } } //代售点 public class ProxyPoint implements SellTickets { private TrainStation station = new TrainStation(); public void sell() { System.out.println("代理点收取一些服务费用"); station.sell(); } } //测试类 public class Client { public static void main(String[] args) { ProxyPoint pp = new ProxyPoint(); pp.sell(); } }
public interface UserDao { int add(int a,int b); }
public class UserDaoImpl implements UserDao { @Override public int add(int a, int b) { System.out.println("add方法执行了....."); return a+b; } }
//创建代理对象代码 class UserDaoProxy implements InvocationHandler { //1 把创建的是谁的代理对象,把谁传递过来 //有参数构造传递 private Object obj; public UserDaoProxy(Object obj) { this.obj = obj; } //增强的逻辑 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //方法之前 System.out.println("方法之前执行...."+method.getName()+" :传递的参数..."+ Arrays.toString(args)); //被增强的方法执行 Object res = method.invoke(obj, args); //方法之后 System.out.println("方法之后执行...."+obj); return res; } }
public class JDKProxy { public static void main(String[] args) { //创建接口实现类代理对象 Class[] interfaces = {UserDao.class}; UserDaoImpl userDao = new UserDaoImpl(); UserDao dao = (UserDao)Proxy.newProxyInstance(UserDao.class.getClassLoader(), interfaces, new UserDaoProxy(userDao)); int result = dao.add(1, 2); System.out.println("result:"+result); } }
Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
,第一个参数值针对哪个接口的实现类(也可以写接口)加载器;第二个参数是代理类要实现的接口列表(记:接口.class就是一个接口列表);第三个参数代理对象。五分钟学设计模式-装饰器模式
类图:
3. 举例:有一个产品,但是功能很少,厂家说出第二代,那么这个第二代就要继承第一代的功能,此时你自己动手给这个第一个代加了一个壳子,使用这个壳子完成了想要的功能,这个壳子就是装饰器,同时保持了第一代产品功能的不改变。
4. 在JDK源码中,IO流大量的使用了装饰器模式。
5. 代码示例:
public interface Robot { void doSomething(); }
public class FirstRobot implements Robot{ public void doSomething() { System.out.println("唱歌"); System.out.println("移动"); } }
public class RobotDecorator implements Robot{ private Robot robot; public RobotDecorator(Robot robot) { this.robot = robot; } public void doSomething() { robot.doSomething(); } public void doMoreThing(){ robot.doSomething(); System.out.println("跳舞"); } }
public class DecoratorPattern { public static void main(String[] args) { RobotDecorator robotDecorator = new RobotDecorator(new FirstRobot()); robotDecorator.doMoreThing(); } }
促销活动共同的接口(抽象策略类)
public interface Strategy { void show(); }
具体算法
public class StrategyA implements Strategy { public void show() { System.out.println("买一送一"); } }
public class StrategyB implements Strategy { public void show() { System.out.println("满200元减50元"); } }
public class StrategyC implements Strategy { public void show() { System.out.println("满1000元加一元换购任意200元以下商品"); } }
促销员(环境类):此时将策略对象设置为自己的一个属性
public class SalesMan { //聚合策略类对象 private Strategy strategy; public SalesMan(Strategy strategy) { this.strategy = strategy; } public Strategy getStrategy() { return strategy; } public void setStrategy(Strategy strategy) { this.strategy = strategy; } //由促销员展示促销活动给用户 public void salesManShow() { strategy.show(); } }
测试类
public class Client { public static void main(String[] args) { //春节来了,使用春节促销活动 SalesMan salesMan = new SalesMan(new StrategyA()); //展示促销活动 salesMan.salesManShow(); System.out.println("=============="); //中秋节到了,使用中秋节的促销活动 salesMan.setStrategy(new StrategyB()); //展示促销活动 salesMan.salesManShow(); System.out.println("=============="); //圣诞节到了,使用圣诞节的促销活动 salesMan.setStrategy(new StrategyC()); //展示促销活动 salesMan.salesManShow(); } }
抽象主题角色类(公众号的接口)
public interface Subject { //添加订阅者(添加观察者对象) void attach(Observer observer); //删除订阅者 void detach(Observer observer); //通知订阅者更新消息 void notify(String message); }
抽象观察者类
public interface Observer { void update(String message); }
具体主题角色类(订阅的公众号)
public class SubscriptionSubject implements Subject { //定义一个集合,用来存储多个观察者对象 private List<Observer> weiXinUserList = new ArrayList<Observer>(); public void attach(Observer observer) { weiXinUserList.add(observer); } public void detach(Observer observer) { weiXinUserList.remove(observer); } public void notify(String message) { //遍历集合 for (Observer observer : weiXinUserList) { //调用观察者对象中的update方法 observer.update(message); } } }
具体的观察者角色类(每个用户)
public class WeiXinUser implements Observer { private String name; public WeiXinUser(String name) { this.name = name; } public void update(String message) { System.out.println(name + "-" + message); } }
测试类
public class Client { public static void main(String[] args) { //1,创建公众号对象 SubscriptionSubject subject = new SubscriptionSubject(); //2,订阅公众号 subject.attach(new WeiXinUser("孙悟空")); subject.attach(new WeiXinUser("猪悟能")); subject.attach(new WeiXinUser("沙悟净")); //3,公众号更新,发出消息给订阅者(观察者对象) subject.notify("传智黑马的专栏更新了!"); } }
示例2:【欠债还钱】
找人借钱的接口:
public interface Debit { void borrow(Credit credit);//借钱 void notifyCredits();//通知还钱 }
给人借钱的接口
public interface Credit { void takeMoney(); }
具体给人借钱的对象
public class Wangwu implements Credit{ public void takeMoney() { System.out.println("王五要钱"); } }
public class Zhaosi implements Credit{ public void takeMoney() { System.out.println("赵四要钱"); } }
具体找人借钱的对象
public class Zhangsan implements Debit{ private List<Credit> allCredits = new ArrayList<Credit>(); private Integer state = 0;//状态的改变位置,1表示有钱 public void borrow(Credit credit) { allCredits.add(credit); } public void notifyCredits(Integer state) { this.state = state; allCredits.forEach(credit -> credit.takeMoney()); } }
测试类
public class ObserverPattern { public static void main(String[] args) { Debit zhangsan = new Zhangsan(); zhangsan.borrow(new Wangwu()); zhangsan.borrow(new Zhaosi()); //状态改变 zhangsan.notifyCredits(8); } }