按照软件设计原则、创建模式、结构模式、行为模式行文
1. 软件设计原则
1.1 开闭原则
对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。
想要达到这样的效果，我们需要使用接口和抽象类。
//皮肤抽象类public abstract class AbstractSkin { public abstract void display();}//子类public class DefaultSkin extends AbstractSkin { public void display() { System.out.println("默认皮肤"); }}public class HeimaSkin extends AbstractSkin { public void display() { System.out.println("黑马皮肤"); }}//聚合类public class SougouInput {//抽象类 private AbstractSkin skin; //经典包一层，而不是直接 private DefaultSkin skin；如果有多个皮肤就要有多个 public void setSkin(AbstractSkin skin) { this.skin = skin; } public void display() { skin.display(); }} //1,创建搜狗输入法对象 SougouInput input = new SougouInput(); //2,创建皮肤对象 //DefaultSkin skin = new DefaultSkin(); HeimaSkin skin = new HeimaSkin(); //3,将皮肤设置到输入法中 input.setSkin(skin); //4,显示皮肤 input.display();1.2 里氏代换原则
里氏代换原则：任何基类可以出现的地方，子类一定可以出现。通俗理解：子类可以扩展父类的功能，但不能改变父类原有的功能。换句话说，子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。
如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。
//长方形public class Rectangle { private double length; private double width;// 正方形继承长方形，正方形是特殊的长方形public class Square extends Rectangle { @Override public void setLength(double length) { super.setLength(length); super.setWidth(length); } @Override public void setWidth(double width) { super.setLength(width); super.setWidth(width); }}//测试类 public static void main(String[] args) { //创建长方形对象 Rectangle r = new Rectangle(); //设置长和宽 r.setLength(20); r.setWidth(10); //调用resize方法进行扩宽 resize(r); printLengthAndWidth(r); System.out.println("=================="); //创建正方形对象 Square s = new Square(); //设置长和宽 s.setLength(10); //调用resize方法进行扩宽 resize(s); printLengthAndWidth(s); } //长方形扩宽方法 public static void resize(Rectangle rectangle) { //判断宽如果比长小，进行扩宽的操作 while(rectangle.getWidth() <= rectangle.getLength()) { rectangle.setWidth(rectangle.getWidth() + 1); } } //打印长方形长和宽 public static void printLengthAndWidth(Rectangle rectangle) { System.out.println(rectangle.getLength()); System.out.println(rectangle.getWidth()); }再进行解耦
接口
package com.itheima.principles.demo2.after;/** * @version v1.0 * @ClassName: Quadrilateral * @Description: 四边形接口 * @Author: */public interface Quadrilateral { /** * 获取长 * */ double getLength(); /** * 获取宽 * */ double getWidth();}类
package com.itheima.principles.demo2.after;/** * @version v1.0 * @ClassName: Rectangle * @Description: 长方形类 * @Author: */public class Rectangle implements Quadrilateral { private double length; private double width; public void setLength(double length) { this.length = length; } public void setWidth(double width) { this.width = width; } public double getLength() { return length; } public double getWidth() { return width; }}package com.itheima.principles.demo2.after;/** * @version v1.0 * @ClassName: Square * @Description: 正方形 * @Author: */public class Square implements Quadrilateral { private double side; public double getSide() { return side; } public void setSide(double side) { this.side = side; } public double getLength() { return side; } public double getWidth() { return side; }}测试
package com.itheima.principles.demo2.after;/** * @version v1.0 * @ClassName: RectangleDemo * @Description: TODO(一句话描述该类的功能) * @Author: */public class RectangleDemo { public static void main(String[] args) { //创建长方形对象 Rectangle r = new Rectangle(); r.setLength(20); r.setWidth(10); //调用方法进行扩宽操作 resize(r); printLengthAndWidth(r); } //扩宽的方法 public static void resize(Rectangle rectangle) { //判断宽如果比长小，进行扩宽的操作 while(rectangle.getWidth() <= rectangle.getLength()) { rectangle.setWidth(rectangle.getWidth() + 1); } } //打印长和宽 public static void printLengthAndWidth(Quadrilateral quadrilateral) { System.out.println(quadrilateral.getLength()); System.out.println(quadrilateral.getWidth()); }}1.3依赖倒转原则
依赖倒转原则：高层模块不应该依赖低层模块，两者都应该依赖其抽象。
抽象不应该依赖细节，细节应该依赖抽象。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。
【例】组装电脑
现要组装一台电脑，需要配件 cpu、硬盘、内存条，只有这些配置都有了，计算机才能正常的运行。
cpu 有很多选择，如 Intel、AMD 等，硬盘可以选择希捷、西数等，内存条可以选择金士顿、海盗船等。
类
package com.itheima.principles.demo3.before;/** * @version v1.0 * @ClassName: IntelCpu * @Description: Intel cpu * @Author: */public class IntelCpu { public void run() { System.out.println("使用Intel处理器"); }}package com.itheima.principles.demo3.before;/** * @version v1.0 * @ClassName: KingstonMemory * @Description: 金士顿内存条类 * @Author: */public class KingstonMemory { public void save() { System.out.println("使用金士顿内存条"); }}package com.itheima.principles.demo3.before;/** * @version v1.0 * @ClassName: XiJieHardDisk * @Description: 希捷硬盘 * @Author: */public class XiJieHardDisk { //存储数据的方法 public void save(String data) { System.out.println("使用希捷硬盘存储数据为：" + data); } //获取数据的方法 public String get() { System.out.println("使用希捷希捷硬盘取数据"); return "数据"; }}package com.it.principles.demo3.before;/** * @version v1.0 * @ClassName: Computer * @Description: TODO(一句话描述该类的功能) * @Author: */public class Computer { private XiJieHardDisk hardDisk; private IntelCpu cpu; private KingstonMemory memory; public XiJieHardDisk getHardDisk() { return hardDisk; } public void setHardDisk(XiJieHardDisk hardDisk) { this.hardDisk = hardDisk; } public IntelCpu getCpu() { return cpu; } public void setCpu(IntelCpu cpu) { this.cpu = cpu; } public KingstonMemory getMemory() { return memory; } public void setMemory(KingstonMemory memory) { this.memory = memory; } public void run() { System.out.println("运行计算机"); String data = hardDisk.get(); System.out.println("从硬盘上获取的数据是：" + data); cpu.run(); memory.save(); }}运行
package com.it.principles.demo3.before;/** * @version v1.0 * @ClassName: ComputerDemo * @Description: TODO(一句话描述该类的功能) * @Author: */public class ComputerDemo { public static void main(String[] args) { //创建组件对象 XiJieHardDisk hardDisk = new XiJieHardDisk(); IntelCpu cpu = new IntelCpu(); KingstonMemory memory = new KingstonMemory(); //创建计算机对象 Computer c = new Computer(); //组装计算机 c.setCpu(cpu); c.setHardDisk(hardDisk); c.setMemory(memory); //运行计算机 c.run(); }}上面代码可以看到已经组装了一台电脑，但是似乎组装的电脑的 cpu 只能是 Intel 的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户肯定是不友好的，用户有了机箱肯定是想按照自己的喜好，选择自己喜欢的配件。
以上代码不满足依赖倒转原则，因为 Computer 类依赖了各个组件的具体实现。
接口
package com.it.principles.demo3.after;/** * @version v1.0 * @ClassName: Cpu * @Description: cpu接口 * @Author: */public interface Cpu { //运行cpu public void run();}package com.it.principles.demo3.after;/** * @version v1.0 * @ClassName: HardDisk * @Description: 硬盘接口 * @Author: */public interface HardDisk { //存储数据 public void save(String data); //获取数据 public String get();}package com.it.principles.demo3.after;/** * @version v1.0 * @ClassName: Memory * @Description: 内存条接口 * @Author: */public interface Memory { public void save();}package com.it.principles.demo3.after;/** * @version v1.0 * @ClassName: IntelCpu * @Description: Intel cpu * @Author: */public class IntelCpu implements Cpu { public void run() { System.out.println("使用Intel处理器"); }}package com.it.principles.demo3.after;/** * @version v1.0 * @ClassName: XiJieHardDisk * @Description: 希捷硬盘 * @Author: */public class XiJieHardDisk implements HardDisk { //存储数据的方法 public void save(String data) { System.out.println("使用希捷硬盘存储数据为：" + data); } //获取数据的方法 public String get() { System.out.println("使用希捷希捷硬盘取数据"); return "数据"; }}package com.it.principles.demo3.after;/** * @version v1.0 * @ClassName: Computer * @Description: TODO(一句话描述该类的功能) * @Author: */public class Computer { private HardDisk hardDisk; private Cpu cpu; private Memory memory; public HardDisk getHardDisk() { return hardDisk; } public void setHardDisk(HardDisk hardDisk) { this.hardDisk = hardDisk; } public Cpu getCpu() { return cpu; } public void setCpu(Cpu cpu) { this.cpu = cpu; } public Memory getMemory() { return memory; } public void setMemory(Memory memory) { this.memory = memory; } //运行计算机 public void run() { System.out.println("运行计算机"); String data = hardDisk.get(); System.out.println("从硬盘上获取的数据是：" + data); cpu.run(); memory.save(); }}package com.it.principles.demo3.after;/** * @version v1.0 * @ClassName: ComputerDemo * @Description: TODO(一句话描述该类的功能) * @Author: */public class ComputerDemo { public static void main(String[] args) { //创建计算机的组件对象 HardDisk hardDisk = new XiJieHardDisk(); Cpu cpu = new IntelCpu(); Memory memory = new KingstonMemory(); //创建计算机对象 Computer c = new Computer(); //组装计算机 c.setCpu(cpu); c.setHardDisk(hardDisk); c.setMemory(memory); //运行计算机 c.run(); }}1.4 接口隔离原则
接口隔离原则：客户端不应该被迫依赖于它不使用的方法，一个类对另一个类的依赖应该建立在最小的接口上。
package com.it.principles.demo4.before;/** * @version v1.0 * @ClassName: SafetyDoor * @Description: 安全门接口 * @Author: */public interface SafetyDoor { //防盗 void antiTheft(); //防火 void fireProof(); //防水 void waterProof();}package com.it.principles.demo4.before;/** * @version v1.0 * @ClassName: HeimaSafetyDoor * @Description: 黑马品牌的安全门 * @Author: */public class HeimaSafetyDoor implements SafetyDoor { public void antiTheft() { System.out.println("防盗"); } public void fireProof() { System.out.println("防火"); } public void waterProof() { System.out.println("防水"); }}package com.it.principles.demo4.before;/** * @version v1.0 * @ClassName: Client * @Description: TODO(一句话描述该类的功能) * @Author: */public class Client { public static void main(String[] args) { HeimaSafetyDoor door = new HeimaSafetyDoor(); door.antiTheft(); door.fireProof(); door.waterProof(); }}上面的设计我们发现了它存在的问题，一个安全门具有防盗，防水，防火的功能。
现在如果我们还需要再创建一个安全门，而该安全门只具有防盗、防水功能呢？很显然如果实现 SafetyDoor接口就违背了接口隔离原则，将接口进行拆分
/** * 防盗接口 */public interface AntiTheft { void antiTheft();}/** * 防火接口 */public interface Fireproof { void fireproof();}/** * 防水接口 */public interface Waterproof { void waterproof();}package com.it.principles.demo4.after;/** * @version v1.0 * @ClassName: HeiMaSafetyDoor * @Description: TODO(一句话描述该类的功能) * @Author: */public class HeiMaSafetyDoor implements AntiTheft,Fireproof,Waterproof { public void antiTheft() { System.out.println("防盗"); } public void fireproof() { System.out.println("防火"); } public void waterproof() { System.out.println("防水"); }}package com.it.principles.demo4.after;/** * @version v1.0 * @ClassName: ItcastSafetyDoor * @Description: 传智安全门 * @Author: */public class ItcastSafetyDoor implements AntiTheft,Fireproof { public void antiTheft() { System.out.println("防盗"); } public void fireproof() { System.out.println("防火"); }}package com.it.principles.demo4.after;import com.it.principles.demo4.before.HeimaSafetyDoor;/** * @version v1.0 * @ClassName: Client * @Description: TODO(一句话描述该类的功能) * @Author: */public class Client { public static void main(String[] args) { //创建黑马安全门对象 HeimaSafetyDoor door = new HeimaSafetyDoor(); //调用功能 door.antiTheft(); door.fireProof(); door.waterProof(); System.out.println("============"); //创建传智安全门对象 ItcastSafetyDoor door1 = new ItcastSafetyDoor(); //调用功能 door1.antiTheft(); door1.fireproof(); }}1.5 迪米特法则
迪米特法则又叫最少知识原则。其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。
其目的是：降低类之间的耦合度，提高模块的相对独立性。
迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。
【例】明星与经纪人的关系实例
明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，如和粉丝的见面会，和媒体公司的业务洽淡等。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则。
package com.it.principles.demo5;/** * @version v1.0 * @ClassName: Company * @Description: 媒体公司类 * @Author: */public class Company { private String name; public String getName() { return name; } public Company(String name) { this.name = name; }}package com.it.principles.demo5;/** * @version v1.0 * @ClassName: Fans * @Description: 粉丝类 * @Author: */public class Fans { private String name; public String getName() { return name; } public Fans(String name) { this.name = name; }}package com.it.principles.demo5;/** * @version v1.0 * @ClassName: Star * @Description: 明星类 * @Author: */public class Star { private String name; public Star(String name) { this.name = name; } public String getName() { return name; }}代理类
package com.it.principles.demo5;/** * @version v1.0 * @ClassName: Agent * @Description: 经纪人类 * @Author: */public class Agent { private Star star; private Fans fans; private Company company; public void setStar(Star star) { this.star = star; } public void setFans(Fans fans) { this.fans = fans; } public void setCompany(Company company) { this.company = company; } //和粉丝见面的方法 public void meeting() { System.out.println(star.getName() + "和粉丝" + fans.getName() + "见面"); } //和媒体公司洽谈的方法 public void business() { System.out.println(star.getName() + "和" + company.getName() + "洽谈"); }}使用
package com.it.principles.demo5;/** * @version v1.0 * @ClassName: Client * @Description: TODO(一句话描述该类的功能) * @Author: */public class Client { public static void main(String[] args) { //创建经纪人类 Agent agent = new Agent(); //创建明星对象 Star star = new Star("林青霞"); agent.setStar(star); //创建粉丝对象 Fans fans = new Fans("李四"); agent.setFans(fans); //创建媒体公司对象 Company company = new Company(" 媒体公司"); agent.setCompany(company); agent.meeting();//和粉丝见面 agent.business();//和媒体公司洽谈业务 }}1.6 合成复用原则
通常类的复用分为继承复用和合成复用两种。
继承复用虽然有简单和易实现的优点，但它也存在以下缺点：
1. 继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。
2. 子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。
3. 它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。
采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点：
1. 它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
2. 对象间的耦合度低。可以在类的成员位置声明抽象。
3. 复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。
4.
【例】汽车分类管理程序
汽车按“动力源”划分可分为汽油汽车、电动汽车等；按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等。如果同时考虑这两种分类，其组合就很多。类图如下：
