设计模式
什么是设计模式
在代码开发中经常会遇到一些重复出现的问题，这些问题的重复出现，重复解决就会浪费时间，此时，有人总结了这一系列问题，总结出一套固有模式，主要用于解决这些问题。让代码更加简单，易于维护和理解。
设计模式基本原则
1.单一职责原则：对一个类而言，应当只有一个引起它变化的原因，永远不要让一个类存在多个改变的理由。因此，一个类应该只做一个职责相关的业务，不要把过多的职责放在同一个类中完成。
2.开闭原则：一个软件实体(类、方法、模块)，应该对扩展开放，对修改关闭。软件需要变化，尽量通过扩展软件实体的方式来完成，而不是通过修改原有代码来完成。开闭原则是设计原则中的核心原则。
3.里式替换原则：在一个软件系统中，子类能够完全替换父类出现的地方，并且进过替换后，不会改变原有的行为
4.依赖倒置原则：高层模块不应该依赖底层模块，二者都依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象
– 功能实现不能依赖于实体的类，应该依赖于抽象的接口，通过实现接口的方式来实现功能
5**.聚合/组合原则**:尽可能使用聚合/组合的方式，而不是使用继承来达到代码的复用
6.接口隔离原则：使用专门的接口比用统一接口好，便于项目的组织和分工。不要让开发者面对用不到的方法。
7.迪米特法则：一个对象应该对其他对象保持最少的了解，要很好的封装类，仅向外部暴露你提供的服务，内部的细节不需要让外界知道。
设计模式的分类
人们总结出23种设计模式，通分为三大类：
1.创建模式：创建一些特殊的对象，或者在特殊要求下创建对象
2.结构模式：主要利用组合/聚合或者继承，让类与类能够形成某种关联关系–代理
3.行为模式：刻画了类和对象交换及分配职责的方式
单例模式
在某些特殊情况下，我们创建的一个类，这个类只能产生一个对象
单例模式的实现方案：
1.饿汉模式
public class Singleton{
private Singleton(){}
private static Singleton sing = new Singleton();
public static Singleton getInstance(){
return sing;
}
}
2.懒汉模式(线程不安全、线程安全但效率低)
public class Singleton{
private Singleton(){}
private static Singleton sing;
// public static Singleton getInstance(){
// if(sing == null){
// sing = new Singleton();
// }
// return sing;
// }
public static synchronized Singleton getInstance(){
if(sing == null){
sing = new Singleton();
}
return sing;
}
}
3.双重检验模式(线程安全，且效率高的) 把锁的粒度变小，只锁第一次初始化时
public class Singleton{
private Singleton(){}
private static Singleton sing;
public static Singleton getInstance(){
if(sing == null){
synchronized(Singleton.class){
if(sing == null){
sing = new Singleton();
}
}
}
return sing;
}
}
4.内部类实现模式
public class Singleton{
private Singleton(){}
private static class Inner{
private static Singleton sing = new Singleton();
}
public static Singleton getInstance(){
return Inner.sing;
}
}
5.枚举实现
public class Singleton{
private Singleton(){}
private static enum SinEnum{
SIN;
private Singleton sing = new Singleton();
}
public static Singleton getInstance(){
return SinEnum.SIN.sing;
}
}
请外援就把这5种手抄5遍。再检查不会就继续哦
前面四种是面试的常客，要求能够分辨出各自的优缺点，以及手写完成实现方式
工厂模式
讲使用者和对象的生产者进行分离。
在工厂模式中，几乎都有三种角色，工厂(抽象工厂、具体工厂) 产品(抽象产品、具体产品) 使用者。使用者想要使用产品，不用自己去生产产品，把生产的动作交给工厂去做，使用者只需要从工厂提供产品的位置(方法)去拿就好。
1.简单工厂模式–顾客需要给出清单
变化点在产品对象上，所以我们会抽象产品，然后通过一个工厂，根据不同的情况产生不同的产品对象
2.工厂方法模式–根据工厂能产生什么顾客拿什么
工厂可以产生统一品牌的商品，会根据商品去抽象工厂，对每一个产品，提供一个工厂实现类
3.抽象工厂模式–根据工厂能产生什么顾客拿什么，但是工厂能产生的产品会有多种品牌
超级工厂，可以生产不同品牌的各种产品，抽象出超级工厂，也要抽象出产品，然后根据不同的品牌给出该品牌商品的工工厂实现类
原型模式
根据一个已经存在的对象，创建一个和他一样的对象。-- 克隆
浅克隆-- 利用Object中clone()实现
1.让被克隆的类实现Cloneable接口
2.重写clone方法，方法访问修饰符public
3.对象.clone()的方式的到一个一样的对象
浅克隆指，被克隆的对象会产生一个新的，但是对象属性不会产生。
深度克隆
1.克隆对象所涉及的自定义类，需要实现序列化接口
2.在需要克隆的类中，添加一个方法，完成序列化反序列化即可。
这里穿插一句：创建对象的方式有四种：
- new 使用构造器
- 克隆
- 反序列化
- 反射
代理模式–结构模式
在目标对象执行行为的前后，代理(附加)一些非功能性的逻辑
1.静态代理
根据目标对象需要代理的行为，抽象出一个接口(包含了需要代理的行为)，目标类和代理类都需要去实现该接口，然后将目标对象注入到代理类中，此时就可以在代理类中调用目标对象的行为，并为止附加非功能性逻辑
2.动态代理之JDK代理
第一步，实现接口InvocationHandler，然后重写invoke方法，在invoke方法中调用目标对的方法
第二步，提供一个自定义的方法，通过Proxy.newProxyInstance()得到代理对象
3.动态代理之Cglib代理
第一步，导入Cglib依赖(包)
第二步，实现接口MethodInterceptor，重写intercept方法，在其中完成目标对象的方法调用
第三步，提供自定义方法，通过工具类获取得到代理对象
装饰器模式
对象功能的扩展能够根据需要来动态地实现。
生活场景：星巴克的分店几乎开遍世界各地。它们提供了各式各样的美味咖啡：爱尔兰咖啡、蓝山咖啡、卡布基诺、雀巢。每样咖啡都有自己的描述属性和收费行为。另外它们还提供各种配料：奶、砂糖、冰块、豆浆。不同的咖啡加入不同的配料计算的价格是不一样的。
class Coffee{} // 咖啡父类
class ACoffee extends Coffee{} // 爱尔兰
class BCoffee extends Coffee{} // 蓝山
class KCoffee extends Coffee{} // 卡布基洛
class ACoffeeSuger extends ACoffee{} // 爱尔兰 加糖
class ACoffeeMilk extends ACoffee{} // 爱尔兰 奶
class ACoffeeSugerMilk extends ACoffeeSuger{} // 爱尔兰 加糖 加奶
class ACoffeeSugerDoubleMilk extends ACoffeeSugerMilk{} // 爱尔兰 加糖 加双倍奶
class BCoffeeSuger extends BCoffee{}// 蓝山 加糖
1.根据对象抽象一个公共的接口
2.根据接口给出不同的实现类(主料类(主料类产生的对象就是被装饰的对象) 和 配料类–装饰类)
3.在配料类中注入被装饰的对象
4.生产咖啡时，先生产主料(被修饰的对象)，然后用配料不断去修饰主料
interface Stuff{ getName getPrice}
class ACoffee implements Stuff{} // 爱尔兰
class BCoffee implements Stuff{} // 蓝山
class KCoffee implements Stuff{} // 卡布基洛
class Suger implements Stuff{ 注入主料对象 } // 糖
class Milk implements Stuff{ 注入主料对象 } // 牛奶
class Ice implements Stuff{ 注入主料对象 } // 冰块
// 爱尔兰 加糖 加奶
Stuff coffee = new ACoffee();// 爱尔兰
Stuff coffeeAddSuger = new Suger(coffee); // 爱尔兰 加糖
Stuff coffeeAddSugerAndMilk = new Milk(coffeeAddSuger);// 爱尔兰 加糖 加奶
适配器模式
使得原本不兼容的两个接口(功能)可以兼容–搭建了两个接口间的桥梁
假如：我们现在有一台座机，可以通话，有一个照相机，可以进行拍照，能不能有一台设备把两者的功能合一呢？
class Tel{
public void call(){}
}
class Carame{
public void make(){}
}
class Phone extends Tel{
private Carame c = new Carame();
public void make(){
c.make();
}
}
实现适配器的方案，继承或者依赖（推荐使用）
优点：可以让没有任何关联的类，一起运行；
提高了类的复用
灵活性好
缺点：过多的使用适配器，会导致系统非常混乱，不容具体把控
java是单继承，
观察者模式—行为模式
A球队（青年天才） 其他球队都对这个天才垂涎欲滴，都会派出球探观察青年天才的表现，根据它的表现决定球队，应该出多少钱买入该天才。在某一次比赛中，它面对一个传统豪强(强队)，世界级的变现(帽子戏法+助攻帽子戏法)，6-3大胜
生活场景：多个代理商代理同一个厂家的商品。不同代理商会在厂家出厂价基础上加上自己的利润，成为批发价。当商品的厂价发生变化时，不同代理商品的价格随之变化。
-
主题类(由它产生的对象 就是 被观察的对象) 继承 Observable的类
在主题类，需要针对主题(价格的变化进行关注，设置变化点，然后通知观察者价格有了变化)
public class Product extends Observable { private double price; public double getPrice() { return price; } public void setPrice(double price) { this.price = price; // 通知观察者注意到主题的变化 this.setChanged();// 设置变化点 this.notifyObservers(price);//通知观察者 } } -
观察者类(由它产生的对象 就是 观察者) 实现Observer接口
重写update(当主题发生变化时，会调用方法)
public class ProductProxy1 implements Observer { private double price; /** * 当主题类的值发生变化后，会调用该方法 * @param o 主题对象 * @param arg 主题更新的值对象 */ @Override public void update(Observable o, Object arg) { double factoryPrice = (double) arg; this.price = factoryPrice * 1.5; } public double getPrice() { return price; } } -
首先产生主题对象(被观察对象)，产生观察者对象，然后给主题对象设置观察者，最后通过更改主题的值，测试观察者是否有观测到主题值的改变
public class Test { public static void main(String[] args) { // 产生主题对象 -- 被观察者 Product product = new Product(); // 产生观察者 ProductProxy1 p1 = new ProductProxy1(); // 给主题对象添加观察者 product.addObserver(p1); // 主题发生变化 product.setPrice(1000); System.out.println("出厂价格："+ product.getPrice() + "\n代理商售卖价格：" + p1.getPrice()); // 主题发生变化 product.setPrice(2000); System.out.println("出厂价格："+ product.getPrice() + "\n代理商售卖价格：" + p1.getPrice()); } }
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
