设计原则

单一职责原则 : 一个类只有一个职责。A.B两个类，  A：用户的基础信息，姓名，年龄的：B:用户的行为，吃饭，睡觉。   按照单一原则，获取用户基础信息的类，和用户行为的类，应该是两种类。职责不一样

接口隔离原则：一个接口只服务一个模块或者业务逻辑。  现在有两个服务，一个服务需要获得用户基础信息，一个服务需要调用用户行为。   那么需要有两个接口，给服务一提供获得用户基础信息的接口，给服务而提供用户行为的接口

                          而不是，提供一个接口，给俩服务。虽然都是关于用户的数据。

里氏替换原则：只要有父类出现的地方，子类都可以出现，而且替换为子类也不会产生任何错误（反之，有子类出现的地方，父类未必能适应）（使用父类作为参数，传递不同的子类完成不同的业务逻辑，）

依赖倒置原则：通过抽象或者接口类，使各个类或者模块的实现彼此独立，不互相影响（尽量每个类都有自己的接口或者抽象）（查看里氏替换原则代码）

迪米特法则   ： 最少知识原则，一个对象应该对其它对象有最少的了解.只和朋友交流：朋友类的定义是这样的：出现在成员变量、方法的输入输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类。 不属于朋友的类，                               不能出现该类中

开闭原则      ： 软件实体应该对扩展开放，对修改关闭尽可能通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来完成变化（对扩展开方，对修改关闭）

 

单一职责原则：要求一个类，只有一个原因引起的变化，也就是一个接口或者类只有一个职责

/**
 * \* Created with IntelliJ IDEA.
 * \* User: chenhao
 * \* Date: 2021/5/17
 * \* Time: 9:49
 * \* Description:
 * \
 */
public class Demo {

    /***
     *   单一职责原则：要求一个接口或者类只有一个原因引起的变化，也就是一个接口或类只有一个职责
     */
}

class UserInfo {
    /***
     *   根据单一职责  用户的行为，必须是同一种类型，如果在一个类中两种不同的用户行为，就违反了单一职责
     *
     *   getName,getPassword,getSex获取用户基本属性行为
     *
     *   GoBed，GoEat   获取用户其它行为
     *
     *   根据单一原则： 需要把这两种不同的行为放在不同的类中。才符合单一原则
     *
     *   优点：类的复杂度降低，可读性高，可维护性高。变更引起的风险降低，
     *   变更是必不可少的，如果接口的单一职责做得好，一个接口修
     * 改只对相应的实现类有影响，对其他的接口无影响，这对系统的扩展性、维护性都有非常大
     * 的帮助
     *   缺点： 在真实项目中，完全做到单一职责很难，增加了系统的复杂性，需要根据具体情况。斟酌处理
     */

    //===============================  用户属性
    private String name; //用户名称
    private String password; //用户密码
    private String sex; //性别

    //=============================== 获取基本信息的用户属性

    public String getName() {
        return name;
    }

    public String getPassword() {
        return password;
    }

    public String getSex() {
        return sex;
    }


    //===============================  获取用户属性信息

    /**
     * 去睡觉
     */
    public void GoBed() {
        System.out.println("去睡觉");
    }

    /**
     * 去吃饭
     */
    public void GoEat() {
        System.out.println("去吃饭");
    }

}

接口隔离原则：一个接口只服务于一个子模块或者业务逻辑（类似于单一原则，只是角度不一样）

/**
 * \* Created with IntelliJ IDEA.
 * \* User: chenhao
 * \* Date: 2021/5/17
 * \* Time: 16:08
 * \* Description:
 * \
 */
public class Demo {

    /**
     * 接口隔离原则：一个接口只服务于一个子模块或者业务逻辑（类似于单一原则，只是角度不一样）
     * 如果一个服务只需要查看用户的基本信息，那么提供基本信息接口，如果是行为，那么提供行为接口，   不把不需要的接口提供出去
     * 1：客户端不应该依赖它不需要的接口
     * 2：类间的依赖关系应该建立在最小的接口上
     *
     */
}

// 获取用户基本信息
interface IUserInfo {
    public void getName();

    public void getSex();
}

class UserInfo implements IUserInfo {

    @Override
    public void getName() {
        System.out.println("chenchen");
    }


    @Override
    public void getSex() {
        System.out.println("15岁");
    }

}
// 获取用户动作行为，
interface IUserGo {
    public void GoBed();

    public void GoEat();
}


class UserGo implements IUserGo {
    /**
     * 去睡觉
     */
    @Override
    public void GoBed() {
        System.out.println("去睡觉");
    }

    /**
     * 去吃饭
     */
    @Override
    public void GoEat() {
        System.out.println("去吃饭");
    }
}

里氏替换原则： 只要有父类出现的地方，子类都可以出现，而且替换为子类也不会产生任何错误（反之，有子类出现的地方，父类未必能适应） 使用父类作为参数，传递不同的子类完成不同的业务逻辑，非常完美！

/**
 * \* Created with IntelliJ IDEA.
 * \* User: chenhao
 * \* Date: 2021/5/17
 * \* Time: 10:28
 * \* Description:
 * \
 */
public class Demo {
    /**
     * 里氏替换原则： 只要有父类出现的地方，子类都可以出现，而且替换为子类也不会产生任何错误（反之，有子类出现的地方，父类未必能适应）
     *
     * 使用父类作为参数，传递不同的子类完成不同的业务逻辑，非常完美！
     */
}

/**
 * 主类
 */
class Client {
    public static void main(String[] args) {
//产生三毛这个士兵
        Soldier sanMao = new Soldier();
        //多态
        AbstractGun rfle = new Rifle();
        //多态
        Rifle rfle2 = new Rifle();
        //给三毛一支枪
        sanMao.setGun(rfle);
        sanMao.killEnemy();
    }
}

/**
 * 枪支
 */
abstract class AbstractGun {
    //枪用来干什么的？杀敌！
    public abstract void shoot();
}

/**
 * 手枪
 */
class Handgun extends AbstractGun {
    //手枪的特点是携带方便，射程短
    @Override
    public void shoot() {
        System.out.println("手枪射击...");
    }
}

/**
 * 步枪
 */
class Rifle extends AbstractGun {
    //步枪的特点是射程远，威力大
    @Override
    public void shoot() {
        System.out.println("步枪射击...");
    }
}

/**
 * 机枪
 */
class MachineGun extends AbstractGun {
    @Override
    public void shoot() {
        System.out.println("机枪扫射...");
    }
}

class Soldier {
    //定义士兵的枪支
    private AbstractGun gun;

    //给士兵一支枪
    public void setGun(AbstractGun _gun) {
        this.gun = _gun;
    }

    public void killEnemy() {
        System.out.println("士兵开始杀敌人...");
        gun.shoot();
    }
}

 迪米特法则：最少知识原则，一个对象应该对其它对象有最少的了解.只和朋友交流：朋友类的定义是这样的：出现在成员变量、方法的输入输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类。  不属于朋友的类，  不能出现该类中

public class Demo {
    /**
     *  迪米特法则：最少知识原则，一个对象应该对其它对象有最少的了解
     *  只和朋友交流：
     *  朋友类的定义是这样的：出现在成员变量、方法的输入输出参数中的类称为成员朋友类，而出现在方法体内
     *  部的类不属于朋友类。  不属于朋友的类，  不能出现该类中
     */

}

/**
 * 违反迪米特法原则
 *
 * 列子：老师想让体育委员确认一下全班女生来齐没有，就对他
 * 说：“你去把全班女生清一下
 * <p>
 * 结论：首先确定Teacher类有几个朋友类，它仅有一个朋友类——
 * GroupLeader。为什么Girl不是朋友类呢？Teacher也对它产生了依赖关系呀！朋友类的定义是
 * 这样的：出现在成员变量、方法的输入输出参数中的类称为成员朋友类，而出现在方法体内
 * 部的类不属于朋友类，而Girl这个类就是出现在commond方法体内，因此不属于Teacher类的
 * 朋友类。迪米特法则告诉我们一个类只和朋友类交流，
 */
class Client {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
//老师发布命令
        teacher.commond(new GroupLeader());
    }
}

class Girl {
    String name;
}

class Teacher {
    //老师对学生发布命令，清一下女生
    public void commond(GroupLeader groupLeader) {
        List listGirls = new ArrayList();
//初始化女生
        for (int i = 0; i < 20; i++) {
            listGirls.add(new Girl());
        }
//告诉体育委员开始执行清查任务
        groupLeader.countGirls(listGirls);
    }
}

class GroupLeader {
    //清查女生数量
    public void countGirls(List<Girl> listGirls) {
        System.out.println("女生数量是：" + listGirls.size());
    }
}

//============================================================

/**、
 * 遵循迪米特法原则
 */
class Client1 {
    public static void main(String[] args) {
        //产生一个女生群体
        List<Gir1l> listGirls = new ArrayList<Gir1l>();
//初始化女生
        for(int i=0;i<30;i++){
            listGirls.add(new Gir1l());
        }

        Teacher1 teacher = new Teacher1();
//老师发布命令
        teacher.commond(new GroupLeader1(listGirls));
    }
}

class Gir1l {
    String name;
}

class Teacher1 {
    //老师对学生发布命令，清一下女生
    public void commond(GroupLeader1 groupLeader) {
        groupLeader.countGirls();
    }
}

class GroupLeader1 {

    private List<Gir1l> listGirls;

    //传递全班的女生进来
    public GroupLeader1(List<Gir1l> _listGirls) {
        this.listGirls = _listGirls;
    }

    //清查女生数量
    public void countGirls() {
//告诉体育委员开始执行清查任务

        System.out.println("女生数量是：" + listGirls.size());
    }
}

  开闭原则      ： 软件实体应该对扩展开放，对修改关闭尽可能通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来完成变化（对扩展开方，对修改关闭）

public class Demo {
    /**
     * 开闭原则：软件实体应该对扩展开放，对修改关闭
     * 尽可能通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来完成变化（对扩展开方，对修改关闭）
     */
}

interface IBook {
    //书籍有名称
    public String getName();

    //书籍有售价
    public int getPrice();

    //书籍有作者
    public String getAuthor();
}

class NovelBook implements IBook {
    //书籍名称
    private String name;
    //书籍的价格
    private int price;
    //书籍的作者
    private String author;

    //通过构造函数传递书籍数据
    public NovelBook(String _name, int _price, String _author) {
        this.name = _name;
        this.price = _price;
        this.author = _author;
    }

    //获得作者是谁
    @Override
    public String getAuthor() {
        return this.author;
    }

    //书籍叫什么名字
    @Override
    public String getName() {
        return this.name;
    }

    //获得书籍的价格
    @Override
    public int getPrice() {
        return this.price;
    }
}

class BookStore {
    private final static ArrayList<IBook> bookList = new ArrayList<IBook>();

    //static静态模块初始化数据，实际项目中一般是由持久层完成
    static {
        bookList.add(new NovelBook("天龙八部", 3200, "金庸"));
        bookList.add(new NovelBook("巴黎圣母院", 5600, "雨果"));
        bookList.add(new NovelBook("悲惨世界", 3500, "雨果"));
        bookList.add(new NovelBook("金瓶梅", 4300, "兰陵笑笑生"));
    }

    //模拟书店买书
    public static void main(String[] args) {
        NumberFormat formatter = NumberFormat.getCurrencyInstance();
        formatter.setMaximumFractionDigits(2);
        System.out.println("-----------书店卖出去的书籍记录如下：-----------");
        for (IBook book : bookList) {
            System.out.println("书籍名称：" + book.getName() + "\t书籍作者：" +
                    book.getAuthor() + "\t书籍价格：" + formatter.format(book.getPrice() /
                    100.0) + "元");
        }
    }
}


/**
 *
 * 开闭原则体现：
 *   从2008年开始，全球经济开始下滑，
 * 对零售业影响比较大，书店为了生存开始打折销售：所有40元以上的书籍9折销售，其他的8
 * 折销售
 *
 *  增加一个子类OffNovelBook，覆写getPrice方法，高层次的模块（也就是static静态模块
 * 区）通过OffNovelBook类产生新的对象，完成业务变化对系统的最小化开发。好办法，修改
 * 也少，风险也小，
 *
 */

class OffNovelBook extends NovelBook {
    public OffNovelBook(String _name,int _price,String _author){
        super(_name,_price,_author);
    }
    //覆写销售价格
    @Override
    public int getPrice(){
//原价
        int selfPrice = super.getPrice();
        int offPrice=0;
        if(selfPrice>4000){ //原价大于40元，则打9折
            offPrice = selfPrice * 90 /100;
        }else{
            offPrice = selfPrice * 80 /100;
        }
        return offPrice;
    }
}
class BookStore2 {
    private final static ArrayList<IBook> bookList = new ArrayList<IBook>();
    //static静态模块初始化数据，实际项目中一般是由持久层完成
    static{
        bookList.add(new OffNovelBook("天龙八部",3200,"金庸"));
        bookList.add(new OffNovelBook("巴黎圣母院",5600,"雨果"));
        bookList.add(new OffNovelBook("悲惨世界",3500,"雨果"));
        bookList.add(new OffNovelBook("金瓶梅",4300,"兰陵笑笑生"));
    }
    //模拟书店买书
    public static void main(String[] args) {
        NumberFormat formatter = NumberFormat.getCurrencyInstance();
        formatter.setMaximumFractionDigits(2);
        System.out.println("-----------书店卖出去的书籍记录如下：-----------");
        for(IBook book:bookList){
            System.out.println("书籍名称：" + book.getName()+"\t书籍作者：" + book.getAuthor()+ "\t书籍价格：" + formatter.format (book.getPrice()/100.0)+"元");
        }
    }
}