一、开闭原则

对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。

1，案例

【例】搜狗输入法的皮肤设计。
分析：搜狗输入法的皮肤是输入法背景图片、窗口颜色和声音等元素的组合。用户可以根据自己的喜爱更换自己的输入法的皮肤，也可以从网上下载新的皮肤。这些皮肤有共同的特点，可以为其定义一个抽象（AbstractSkin），而每个具体的皮肤（DefaultSpecificSkin和HeimaSpecificSkin）是其子类。用户窗体可以根据需要选择或者增加新的主题，而不需要修改原代码，所以它是满足开闭原则的。

2，代码演示

2.1，项目搭建

2.2，抽离抽象类AbstractSkin

package xyz.zhouge.principle.open_close.abstractObject;
/**
 * @Author zhouge
 * @Date 2022/6/12 10:36
 * @PackageName:xyz.zhouge.principle.open_close.abstractObject
 * @ClassName: AbstractObject
 * @Description: 抽象皮肤类
 * @Version 1.0
 */
public abstract class AbstractSkin {
    /**
     * 抽象方法 显示皮肤
     */
    public abstract void display();
}

2.3，实现拓展类

package xyz.zhouge.principle.open_close.extendObject;
import xyz.zhouge.principle.open_close.abstractObject.AbstractSkin;
/**
 * @Author zhouGe
 * @Date 2022/6/12 10:40
 * @PackageName:xyz.zhouge.principle.open_close.extendObject
 * @ClassName: DefaultSkin
 * @Description: 拓展类，默认皮肤类
 * @Version 1.0
 */
public class DefaultSkin extends AbstractSkin {
    @Override
    public void display() {
        System.out.println("display defaultSkin...");
    }
}

package xyz.zhouge.principle.open_close.extendObject;
import xyz.zhouge.principle.open_close.abstractObject.AbstractSkin;
/**
 * @Author zhouGe
 * @Date 2022/6/12 10:42
 * @PackageName:xyz.zhouge.principle.open_close.extendObject
 * @ClassName: zhouGeSkin
 * @Description: 拓展类，我的皮肤对象
 * @Version 1.0
 */
public class zhouGeSkin extends AbstractSkin {
    @Override
    public void display() {
        System.out.println("display zhouGeSkin ...");
    }
}

2.4，搜狗输入法类

package xyz.zhouge.principle.open_close;
import xyz.zhouge.principle.open_close.abstractObject.AbstractSkin;
/**
 * @Author zhouGe
 * @Date 2022/6/12 10:43
 * @PackageName:xyz.zhouge.principle.open_close
 * @ClassName: SouGouInput
 * @Description: 搜狗输入法
 * @Version 1.0
 */
public class SouGouInput{
    //抽象皮肤对象
    private AbstractSkin skin ;
    //供外部设置皮肤对象
    public void setSkin(AbstractSkin skin){
        this.skin=skin;
    }
    //显示皮肤
    public void display(){
        //调用abstractSkin的display() 方法显示皮肤
        skin.display();
    }
}

2.5，客户端

package xyz.zhouge.principle.open_close;
import xyz.zhouge.principle.open_close.abstractObject.AbstractSkin;
import xyz.zhouge.principle.open_close.extendObject.DefaultSkin;
import xyz.zhouge.principle.open_close.extendObject.zhouGeSkin;
/**
 * @Author zhouGe
 * @Date 2022/6/12 10:47
 * @PackageName:xyz.zhouge.principle.open_close
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        //1，创建搜狗输入法
        SouGouInput input = new SouGouInput();
        //2,创建皮肤对象
        //DefaultSkin defaultSkin = new DefaultSkin();
        zhouGeSkin zhouGeSkin = new zhouGeSkin();
        //3,将皮肤设置在输入法中
        input.setSkin(zhouGeSkin);
        //4,显示皮肤
        input.display();
    }
}

二、里氏代换原则

里氏代换原则是面向对象设计的基本原则之一。
里氏代换原则：任何基类可以出现的地方，子类一定可以出现。通俗理解：子类可以扩展父类的功能，但不能改变父类原有的功能。换句话说，子类继承父类时，除添加新的方法完成新增功能外，尽量不要
重写父类的方法。
如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。

1，案例

【例】正方形不是长方形。
在数学领域里，正方形毫无疑问是长方形，它是一个长宽相等的长方形。所以，我们开发的一个与几何
图形相关的软件系统，就可以顺理成章的让正方形继承自长方形。

2，代码演示

2.1，项目搭建

2.2，长方形类

package xyz.zhouge.principle.liskov_substitution.before;
/**
 * @Author zhouGe
 * @Date 2022/6/12 11:47
 * @PackageName:xyz.zhouge.principle.liskov_substitution.before
 * @ClassName: Rectangle
 * @Description: 长方形类
 * @Version 1.0
 */
public class Rectangle {
    private double length ;
    private double width ;
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
}

2.3，正方形类

package xyz.zhouge.principle.liskov_substitution.before;
import sun.security.util.Length;
/**
 * @Author zhouGe
 * @Date 2022/6/12 11:49
 * @PackageName:xyz.zhouge.principle.liskov_substitution.before
 * @ClassName: Square
 * @Description: 正方形类
 * @Version 1.0
 */
public class Square extends Rectangle {
    //设置正方形宽
    public void setWidth(double width){
        //调用父类的方法
        super.setWidth(width);//长宽一致
        super.setLength(width);//长宽一致
    }
    //设置正方形的长
    public void setLength(double length){
        //调用父类的方法
        super.setWidth(length);//长宽一致
        super.setLength(length);//长宽一致
    }
}

2.4，客户端类

package xyz.zhouge.principle.liskov_substitution.before;
import jdk.internal.org.objectweb.asm.commons.RemappingAnnotationAdapter;
import javax.swing.*;
/**
 * @Author zhouGe
 * @Date 2022/6/12 11:53
 * @PackageName:xyz.zhouge.principle.liskov_substitution.before
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
         //长方形测试
        Rectangle rectangle = new Rectangle();
        rectangle.setLength(20);
        rectangle.setWidth(10);
        //拓宽
        resize(rectangle);
        //打印
        print(rectangle);
        System.out.println("======================");
        //正方形测试  因为正方形重写的长宽方法,会不断的更新长宽，使其长宽一直。这与resize() 方法的while判断相撞，导致死循环
        Square square = new Square();
        square.setLength(10);
        //拓宽
        resize(square);
        //打印
        print(square);
    }
    //拓宽方法
    public static void resize(Rectangle rectangle){
        //当宽度小于长度时
        while (rectangle.getWidth() <= rectangle.getLength()){
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }
    //输出长和宽
    public static void print(Rectangle rectangle){
        System.out.println("宽度： "+rectangle.getWidth());
        System.out.println("长度： "+rectangle.getLength());
    }
}

2.5，存在问题

正方形的设边方法setLength() setWidth() 与resize()相撞，导致程序进入死循环

3，改进

3.1，项目搭建

3.2，抽象类

package xyz.zhouge.principle.liskov_substitution.after.abstractObject;
/**
 * @Author zhouGe
 * @Date 2022/6/12 12:19
 * @PackageName:xyz.zhouge.principle.liskov_substitution.after.abstractObject
 * @ClassName: Quadrilateral
 * @Description: TODO
 * @Version 1.0
 */
public interface Quadrilateral {
    double getWidth();
    double getLength();
}

3.3，拓展类

package xyz.zhouge.principle.liskov_substitution.after.extendObject;
import xyz.zhouge.principle.liskov_substitution.after.abstractObject.Quadrilateral;
/**
 * @Author zhouGe
 * @Date 2022/6/12 14:38
 * @PackageName:xyz.zhouge.principle.liskov_substitution.after.extendObject
 * @ClassName: Rectangle
 * @Description: 长方形
 * @Version 1.0
 */
public class Rectangle implements Quadrilateral {
    //自定义长宽
    private double width ;
    private double length ;
    //自定义设置方法
    public void setWidth(double width) {
        this.width = width;
    }
    public void setLength(double length) {
        this.length = length;
    }
    //重写方法
    @Override
    public double getWidth() {
        return width;
    }
    @Override
    public double getLength() {
        return length;
    }
}

package xyz.zhouge.principle.liskov_substitution.after.extendObject;
import xyz.zhouge.principle.liskov_substitution.after.abstractObject.Quadrilateral;
/**
 * @Author zhouGe
 * @Date 2022/6/12 14:40
 * @PackageName:xyz.zhouge.principle.liskov_substitution.after.extendObject
 * @ClassName: Square
 * @Description: 正方形
 * @Version 1.0
 */
public class Square implements Quadrilateral {
    //自定义边长
    private double side ;
    public void setSide(double side) {
        this.side = side;
    }
    //重写方法
    @Override
    public double getWidth() {
        return side;
    }
    @Override
    public double getLength() {
        return side;
    }
}

3.4，客户端类

package xyz.zhouge.principle.liskov_substitution.after;
import xyz.zhouge.principle.liskov_substitution.after.abstractObject.Quadrilateral;
import xyz.zhouge.principle.liskov_substitution.after.extendObject.Rectangle;
import xyz.zhouge.principle.liskov_substitution.after.extendObject.Square;
/**
 * @Author zhouGe
 * @Date 2022/6/12 14:41
 * @PackageName:xyz.zhouge.principle.liskov_substitution.after
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        //长方形测试
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(10);
        rectangle.setLength(20);
        //拓宽
        resize(rectangle);
        print(rectangle);
        System.out.println("===================");
        //正方形测试  resize() print()
        Square square = new Square();
        square.setSide(10);
        print(square);
    }
    //对长方形进行扩宽  正方形不可用
    public static void resize(Rectangle rectangle){
        while (rectangle.getWidth() <= rectangle.getLength()){
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }
    //打印
    public static void print(Quadrilateral quadrilateral){
        System.out.println("宽度："+quadrilateral.getWidth());
        System.out.println("长度："+quadrilateral.getLength());
    }
}

三、依赖倒转原则

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

1，案例

【例】组装电脑
现要组装一台电脑，需要配件cpu，硬盘，内存条。只有这些配置都有了，计算机才能正常的运行。选择cpu有很多选择，如Intel，AMD等，硬盘可以选择希捷，西数等，内存条可以选择金士顿，海盗船等。

2，代码演示

2.1，项目搭建

2.2，XiJieHardDisk类

/**
 * @Author zhouGe
 * @Date 2022/6/12 19:27
 * @PackageName:xyz.zhouge.principle.dependence_inversion.before
 * @ClassName: XiJieHardDisk
 * @Description: 希捷硬盘
 * @Version 1.0
 */
public class XiJieHardDisk {
    /**
     * @descriptions Method of storing data
     * @author zhou_ge
     * @date 2022/6/22 15:00
     * @param data
     * @return void
     */
    public void save(String data){
        System.out.println("Using the XiJieHardDisk to store data...");
    }
    /**
     * @descriptions Method of obtaining data
     * @author zhou_ge
     * @date 2022/6/22 15:01
     * @param "infos"
     * @return java.lang.String
     */
    public String getData(){
        System.out.println("Using the XiJieHardDisk to get data...");
        return "infos";
    }
}

2.3，InterCpu 类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:03
 * @PackageName:xyz.zhouge.principle.dependence_inversion.before
 * @ClassName: InterCPU
 * @Description: InterCpu
 * @Version 1.0
 */
public class InterCPU {
    /**
     * @descriptions method of running InterCPU
     * @author zhou_ge
     * @date 2022/6/22 15:04
     * @param
     * @return void
     */
    public void runCPU(){
        System.out.println("Using InterCPU as the central processor ...");
    }
}

2.4，KingstonMemory 类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:05
 * @PackageName:xyz.zhouge.principle.dependence_inversion.before
 * @ClassName: KingstonMemory
 * @Description: TODO
 * @Version 1.0
 */
public class KingstonMemory {
    public void saveData(){
        System.out.println("Using KingstonMemory as a memory module ...");
    }
}

2.5，Computer 类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:08
 * @PackageName:xyz.zhouge.principle.dependence_inversion.before
 * @ClassName: Computer
 * @Description: TODO
 * @Version 1.0
 */
public class Computer {
    private XiJieHardDisk hardDisk ;
    private InterCPU cpu ;
    private KingstonMemory memory ;
    public XiJieHardDisk getHardDisk() {
        return hardDisk;
    }
    public void setHardDisk(XiJieHardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }
    public InterCPU getCpu() {
        return cpu;
    }
    public void setCpu(InterCPU cpu) {
        this.cpu = cpu;
    }
    public KingstonMemory getMemory() {
        return memory;
    }
    public void setMemory(KingstonMemory memory) {
        this.memory = memory;
    }
    public void runComputer(){
        System.out.println("Computer is running ...");
        cpu.runCPU();
        memory.saveData();
        String data = hardDisk.getData();
        System.out.println("The data obtained from memory is : " + data);
    }
}

2.6，Client 类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:12
 * @PackageName:xyz.zhouge.principle.dependence_inversion.before
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setCpu(new InterCPU());
        computer.setMemory(new KingstonMemory());
        computer.setHardDisk(new XiJieHardDisk());
        computer.runComputer();
    }
}

3，改进

3.1，项目搭建

3.2，抽象类

public interface CPU {
    void runCPU();
}

public interface HardDisk {
    void saveData();
    String getData();
}

public interface Memory {
    void saveData();
}

3.3，扩展类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:20
 * @PackageName:xyz.zhouge.principle.dependence_inversion.after.extendObject
 * @ClassName: InterCPU
 * @Description: TODO
 * @Version 1.0
 */
public class InterCPU implements CPU {
    @Override
    public void runCPU() {
        System.out.println("Using InterCPU as the central processor ...");
    }
}

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:21
 * @PackageName:xyz.zhouge.principle.dependence_inversion.after.extendObject
 * @ClassName: XiJieHardDisk
 * @Description: TODO
 * @Version 1.0
 */
public class XiJieHardDisk implements HardDisk {
    @Override
    public void saveData() {
        System.out.println("Using the XiJieHardDisk to storing data...");
    }
    @Override
    public String getData() {
        System.out.println("Using the XiJieHardDisk to get data...");
        return "info";
    }
}

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:21
 * @PackageName:xyz.zhouge.principle.dependence_inversion.after.extendObject
 * @ClassName: KingstonMemory
 * @Description: TODO
 * @Version 1.0
 */
public class KingstonMemory implements Memory {
    @Override
    public void saveData() {
        System.out.println("Using KingstonMemory as a memory module ...");
    }
}

3.4，Computer类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:23
 * @PackageName:xyz.zhouge.principle.dependence_inversion.after
 * @ClassName: Computer
 * @Description: TODO
 * @Version 1.0
 */
public class Computer {
    private CPU cpu ;
    private Memory memory ;
    private 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 HardDisk getHardDisk() {
        return hardDisk;
    }
    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }
    public void runComputer(){
        System.out.println("Computer is running ...");
        cpu.runCPU();
        hardDisk.saveData();
        String data = hardDisk.getData();
        memory.saveData();
        System.out.println("The data obtained from memory is : "+ data);
    }
}

3.5，Client 类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:27
 * @PackageName:xyz.zhouge.principle.dependence_inversion.after
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setCpu(new InterCPU());
        computer.setHardDisk(new XiJieHardDisk());
        computer.setMemory(new KingstonMemory());
        computer.runComputer();
    }
}

四、接口隔离原则

客户端不应该被迫依赖于它不使用的方法；一个类对另一个类的依赖应该建立在最小的接口上。

1，案例

例】安全门案例
我们需要创建一个黑马品牌的安全门，该安全门具有防火、防水、防盗的功能。可以将防火，防水，防盗功能提取成一个接口，形成一套规范。

2，代码演示

2.1，项目搭建

2.2，SafetyDoor 类

public interface SafetyDoor {
    /**
     * @descriptions Anti theft device
     * @author zhou_ge
     * @date 2022/6/22 15:45
     * @param
     * @return void
     */
    void antiTheft();
    /**
     * @descriptions Fire protection device
     * @author zhou_ge
     * @date 2022/6/22 15:46
     * @param
     * @return void
     */
    void fireProof();
    /**
     * @descriptions Water protection device
     * @author zhou_ge
     * @date 2022/6/22 15:47
     * @param
     * @return void
     */
    void waterProof();
}

2.3， ZGSafetyDoor 类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:47
 * @PackageName:xyz.zhouge.principle.interface_segregation.before
 * @ClassName: ZGSafetyDoor
 * @Description: TODO
 * @Version 1.0
 */
public class ZGSafetyDoor implements SafetyDoor{
    @Override
    public void antiTheft() {
        System.out.println("Anti theft function ...");
    }
    @Override
    public void fireProof() {
        System.out.println("Fire protection function ...");
    }
    @Override
    public void waterProof() {
        System.out.println("Water protection function ...");
    }
}

2.4，Client 类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 15:49
 * @PackageName:xyz.zhouge.principle.interface_segregation.before
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        ZGSafetyDoor door = new ZGSafetyDoor();
        door.antiTheft();
        door.fireProof();
        door.waterProof();
    }
}

3，改进

3.1，项目搭建

3.2，抽象类

public interface AntiTheft {
    void antiTheft();
}

public interface FireProof {
    void fireProof();
}

public interface WaterProof {
    void waterProof();
}

3.3，拓展类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 16:35
 * @PackageName:xyz.zhouge.principle.interface_segregation.after.extendObject
 * @ClassName: AtGuiguSafetyDoor
 * @Description: TODO
 * @Version 1.0
 */
public class AtGuiguSafetyDoor implements AntiTheft, FireProof, WaterProof {
    @Override
    public void antiTheft() {
        System.out.println("Anti theft function ....");
    }
    @Override
    public void fireProof() {
        System.out.println("Fire protection function ...");
    }
    @Override
    public void waterProof() {
        System.out.println("Water protection function ...");
    }
}

/**
 * @Author zhou_ge
 * @Date 2022/6/22 16:33
 * @PackageName:xyz.zhouge.principle.interface_segregation.after.extendObject
 * @ClassName: ZGSafetyDoor
 * @Description: TODO
 * @Version 1.0
 */
public class ZGSafetyDoor implements AntiTheft, FireProof {
    @Override
    public void antiTheft() {
        System.out.println("Anti theft function ...");
    }
    @Override
    public void fireProof() {
        System.out.println("Fire protection function ...");
    }
}

3.4，Client 类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 16:36
 * @PackageName:xyz.zhouge.principle.interface_segregation.after
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        new Client().ZGSafetyDoor();
    }
    public void ZGSafetyDoor(){
        ZGSafetyDoor door = new ZGSafetyDoor();
        door.antiTheft();
        door.fireProof();
    }
    public void AtguiguSafetyDoor(){
        AtGuiguSafetyDoor door = new AtGuiguSafetyDoor();
        door.antiTheft();
        door.fireProof();
        door.waterProof();
    }
}

五、迪米特原则

迪米特法则又叫最少知识原则。
只和你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。
其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。
迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

1，案例

【例】明星与经纪人的关系实例
明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，如和粉丝的见面会，和媒体公司的业务洽淡等。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则。

2，代码演示

2.1，朋友类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 17:12
 * @PackageName:xyz.zhouge.principle.law_demeter.friend
 * @ClassName: Agent
 * @Description: TODO
 * @Version 1.0
 */
public class Agent {
    private Star star ;
    private Company company ;
    private Fans fans ;
    public void setStar(Star star) {
        this.star = star;
    }
    public void setCompany(Company company) {
        this.company = company;
    }
    public void setFans(Fans fans) {
        this.fans = fans;
    }
    /**
     * @descriptions Method of meeting with fans
     * @author zhou_ge
     * @date 2022/6/22 17:14
     * @param
     * @return void
     */
    public void meeting(){
        System.out.println("Star :" + star.getStarName() +  " is meeting with fans : " + fans.getFansName());
    }
    /**
     * @descriptions Method of talk with company
     * @author zhou_ge
     * @date 2022/6/22 17:15
     * @param
     * @return void
     */
    public void business(){
        System.out.println("Star :" + star.getStarName() +  " is talking with company : " + company.getCompanyName());
    }
}

2.2，陌生人类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 17:09
 * @PackageName:xyz.zhouge.principle.law_demeter.stranger
 * @ClassName: Company
 * @Description: Company
 * @Version 1.0
 */
public class Company {
    private String companyName ;
    public Company(String companyName) {
        this.companyName = companyName;
    }
    public String getCompanyName() {
        return companyName;
    }
}

/**
 * @Author zhou_ge
 * @Date 2022/6/22 17:12
 * @PackageName:xyz.zhouge.principle.law_demeter.stranger
 * @ClassName: Fans
 * @Description: TODO
 * @Version 1.0
 */
public class Fans {
    private String fansName ;
    public Fans(String fansName) {
        this.fansName = fansName;
    }
    public String getFansName() {
        return fansName;
    }
}

2.3，Star类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 17:12
 * @PackageName:xyz.zhouge.principle.law_demeter
 * @ClassName: Star
 * @Description: TODO
 * @Version 1.0
 */
public class Star {
    private String starName ;
    public Star(String starName) {
        this.starName = starName;
    }
    public String getStarName() {
        return starName;
    }
}

2.4，Client 类

/**
 * @Author zhou_ge
 * @Date 2022/6/22 17:18
 * @PackageName:xyz.zhouge.principle.law_demeter
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        //new object
        Star star = new Star("yuYaTing");
        Fans fan = new Fans("zhou_ge");
        Company company = new Company("yuShiCompany");
        //new agent
        Agent agent = new Agent();
        //init args
        agent.setFans(fan);
        agent.setCompany(company);
        agent.setStar(star);
        //method
        agent.meeting();
        agent.business();
    }
}

六、合成复用原则

合成复用原则是指：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。
通常类的复用分为继承复用和合成复用两种。
继承复用虽然有简单和易实现的优点，但它也存在以下缺点：

继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。
子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。
它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。

采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点：

它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
对象间的耦合度低。可以在类的成员位置声明抽象。
复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

1，案例

【例】汽车分类管理程序
汽车按“动力源”划分可分为汽油汽车、电动汽车等；按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等。如果同时考虑这两种分类，其组合就很多。

从上面类图我们可以看到使用继承复用产生了很多子类，如果现在又有新的动力源或者新的颜色的话，就需要再定义新的类。我们试着将继承复用改为聚合复用看一下。

设计原则

一、开闭原则

1，案例

2，代码演示

2.1，项目搭建

2.2，抽离抽象类AbstractSkin

2.3，实现拓展类

2.4，搜狗输入法类

2.5，客户端

二、里氏代换原则

1，案例

2，代码演示

2.1，项目搭建

2.2，长方形类

2.3，正方形类

2.4，客户端类

2.5，存在问题

3，改进

3.1，项目搭建

3.2，抽象类

3.3，拓展类

3.4，客户端类

三、依赖倒转原则

1，案例

2，代码演示

2.1，项目搭建

2.2，XiJieHardDisk类

2.3，InterCpu 类

2.4，KingstonMemory 类

2.5，Computer 类

2.6，Client 类

3，改进

3.1，项目搭建

3.2，抽象类

3.3，扩展类

3.4，Computer类

3.5，Client 类

四、接口隔离原则

1，案例

2，代码演示

2.1，项目搭建

2.2，SafetyDoor 类

2.3， ZGSafetyDoor 类

2.4，Client 类

3，改进

3.1，项目搭建

3.2，抽象类

3.3，拓展类

3.4，Client 类

五、迪米特原则

1，案例

2，代码演示

2.1，朋友类

2.2，陌生人类

2.3，Star类

2.4，Client 类

六、合成复用原则

1，案例

2，代码演示