场景
例题：学生管理类StudentManager包含如下功能，包括连接数据库方法getConnection()、操作数据库方法入search和delete、显示学生信息的方法display。
不使用单一职责原则的解法：
public class Demo {
    public void getConnection(String uri) {
        System.out.println("与"+uri+"建立联系");
    }
    public void searchStudent(String condition) {
        System.out.println("根据"+condition+"查询学生");
    }
    public void deleteStudent(String condition) {
        System.out.println("根据"+condition+"删除学生");
    }
    public void display() {
        System.out.println("显示学生信息！");
    }
//学生类有三个职责，连接数据库，查询、删除数据，显示查询结构
//存在问题
//1.如果需要修改连接的数据库服务器，需要修改这个类
//2.如果需要修改查询方式，或者增加插入学生数据，需要修改这个类。
//有两个引起变化的原因，职责不单一。

单一职责原则概念：





使用单一职责原则的解法：
类图：



代码实现：
//优点
//1.DBUtil封装了数据库连接操作，更改数据库服务器仅仅修改这个类或者配置文件
//2.studentDAO封装了操作数据库的方法，增减插入、更改查询方式等方法比较容易
//学生管理类，仅仅显示学生信息，职责单一
public class studentManager {
    private studentDAO dao;
    public studentManager(studentDAO dao) {
        super();
        this.dao = dao;
    }
    public void display() {
        System.out.println("显示学生信息！");
    }
}
//数据库操作类,职责单一
public class studentDAO {
    private DBUtil db;
    public studentDAO(DBUtil db) {
        super();
        this.db = db;
    }
    public void searchStudent(String condition) {
        System.out.println("根据"+condition+"查询学生");
    }
    public void deleteStudent(String condition) {
        System.out.println("根据"+condition+"删除学生");
    }
}
//数据库工具类，职责单一
public class DBUtil {
    public void getConnection(String uri) {
        System.out.println("与"+uri+"建立联系");
    }
}
//实例测试类
public class demo {
    public static void main(String[] args) {
        DBUtil db=new DBUtil();
        studentDAO dao=new studentDAO(db);
        studentManager sm=new studentManager(dao);
        db.getConnection("MYSQL");
        dao.searchStudent("孙悟空");
        sm.display();
    }
}

运行截图：

场景
例题：设计文件管理系统，能够读取txt、doc和Excel等文件，采用子类继承父类方式
不使用里氏替换原则的解法：
代码实现：
//具体类
class ReadFile {
        public void read(String fileName){
                System.out.println("读取Excel文件"+fileName);
        }
}
class ReadDoc extends ReadFile{
//子类覆写父类的方法
        public void read(String fileName){
                System.out.println("读取doc文件"+fileName);
        }
}
class Demo{
		public static void readFile(ReadFile a,String fileName){
			a.read(fileName);
		} 
        public static void main(String[] args){
               readFile(new ReadFile(),"a.xsl");
               readFile(new ReadDoc(),"a.xsl");
         }
}

里氏替换原则的概念

所有引用基类的地方必须能透明地使用其子类的对象，即替换成子类之后，系统的行为不会发生改变









使用里氏替换原则的解法：



代码实现：
//父类是接口

public interface Readable{

       void read(String fileName);

}

//子类实现了接口Readable

public class ReadDoc implements Readable{

       @Override

        public void read(String fileName){

               System.out.println("读取doc文件"+fileName);

        }

}

public class ReadXsl implements Readable{

       @Override

        public void read(String fileName){

               System.out.println("读取xsl文件"+fileName);

        }

}

//里式替换原则

public class Demo{

        public static void readFile(Readable r,String fileName){

                r.read(fileName);

        }

        public static void main(String[] args){

               Readable r= new ReadDoc();

                readFile(r,"a.doc");//读取doc文件

                ReadXsl rs = new ReadXsl();

                readFile(rs,"b.xsl");//子类透明替换父类（接口）

        }

}

运行截图：

场景
例题：设计学生信息管理系统，有查询成绩search、修改成绩update、增加成绩insert、删除成绩delete、打印成绩print等功能
不使用接口隔离原则的解法：



代码实现：
public interface HandleScore {
    void insert();
    void delete();
    void search();
    void updata();
    void print();
}

public class Student implements HandleScore{
    public static void main(String[] args) {

    }
    @Override
    public void insert() {}
    @Override
    public void delete() { }
    @Override
    public void search() {}
    @Override
    public void updata() {}
    @Override
    public void print() {
        System.out.println("输出学生成绩");
    }
}
//缺点，存在接口污染
//因为学生只能查询成绩，不能修改，删除记录
//HandleScore接口存在Student不需要的方法

//家排污管理人员实现修改查询接口
public class Academic implements Updatable,Searchable,Printable {
    @Override
    public void print() {}
    @Override
    public void search() {}
    @Override
    public void updata() { }
}

存在问题：如果学生仅仅能够查询成绩，学生类Student实现这个接口，存在不需要的方法，即接口污染
接口隔离原则的概念





接口隔离原则有四个作用：

（1）避免接口污染：一个类如果要实现一个接口，那么就要实现这个接口的所有方法，如果这个接口包含这个类不需要的方法，就会造成接口污染，为系统留下隐患

（2）提高灵活性：一个类可以同时实现多个接口，所以将一个臃肿的接口分割为若干个小接口，通过小接口的不同组合可以满足更多的需求

（3）提高定制服务：通过细化接口为访问者提高需要的方法

（4）实现高内聚：高内聚就是接口、类、模块中定义了一组相关的行为。接口是对外界的承诺，承诺越少对系统的开发越有利，变更的风险也就越少，同时也有利于降低成本。通过细化接口实现高内聚。
使用接口隔离原则的解法：



代码实现：
//对HandleScore接口进行细化
//修改接口
public interface Modifyable{
        void delete();
        void insert();
}


//输出学生成绩接口
public interface Printable {
    void print();
}

//查询学生成绩接口
public interface Searchable {
    void search();
}


public class Student implements Searchable{

    @Override
    public void search() {

    }
}

public class Teacher implements Searchable,Updatable,Printable {
    @Override
    public void print() { }
    @Override
    public void search() {}
    @Override
    public void updata() { }
}


public interface Updatable {
    void updata();
}

场景
例题：设计汽车Car，有start、run和stop方法，现在需要增加导航功能。
不使用开闭原则的解法：

在Car类中修改代码



代码实现：
//设计类
public class Car {
    public void start() {
        System.out.println("启动汽车");
    }


    public void run() {
//在run方法中增加导航功能
        System.out.println("开始导航！！");
        System.out.println("汽车在行驶");
    }


    public void stop() {
        System.out.println("停车！");
    }
}
//实例测试类
public class Demo {
    public static void main(String[] args) {
        Car gelly=new Car();
        gelly.start();
        gelly.run();
        gelly.stop();
    }
}

不足之处：

（1）有些汽车可能没有导航功能

（2）如果有些方法调用了run方法，可能出现问题
开闭原则 的概念

软件实体应当对扩展开放，对修改关闭





使用开闭原则的解法：

新类CarNavigation对Car进行扩展，重写run方法，按照导航行驶



代码实现：
//设计类
public class Car {
    public void start() {
        System.out.println("启动汽车");
    }


    public void run() {
        System.out.println("汽车在行驶");
    }


    public void stop() {
        System.out.println("停车！");
    }
}
//导航类
public class CarNavigation extends Car{
    private void navigate() {
        System.out.println("开始导航！");
    };
    public void run() {
        this.navigate();
        System.out.println("汽车跟着导航行驶！");
    }
}
//实例测试类
public class Demo {
    public static void main(String[] args) {
        CarNavigation gelly=new CarNavigation();
        gelly.start();
        gelly.run();
        gelly.stop();

        System.out.println("-----没有导航的汽车------");

        Car qq=new Car();
        qq.start();
        qq.run();
        qq.stop();
    }
}

运行截图：