开发规范原则（面向对象的精髓就是接口）

最新推荐文章于 2021-06-12 23:48:39 发布

haoyu_zhang

最新推荐文章于 2021-06-12 23:48:39 发布

阅读量244

点赞数

分类专栏： # java 文章标签： java

本文链接：https://blog.csdn.net/haoyu_zhang/article/details/107930408

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

开发规范原则（面向对象的精髓就是接口）

//面向对象的精髓就是接口
//接口的作用，如何产生接口，接口具有什么样的特性
//接口是抽象出来的，抽取其共同行为，属性和方法

单一职责原则 (SRP)

//动物类，会呼吸空气或会呼吸水，用类描述动物呼吸这个场景

单一原则

class Terrestrial{
    public void breathe(String animal){
        System.out.println(animal + "呼吸空气");
    }
}
class Aquatic{
    public void breathe(String animal){
        System.out.println(animal + "呼吸水");
    }
}
public class Client{
    public static void main(String[] args){
        Terrestrial terrestrial =new Terrestrial();
        terrestrial.breathe("牛");
        terrestrial.breathe("羊");
        terrestrial.breathe("猪");

        Aquatic aquatic = new Aquatic();
        aquatic.breathe("鱼");
    }
}

非单一原则

class Animal {
    public void breathe(String animal) {
        if ("鱼".equals(animal)) {
            System.out.println(animal + "呼吸水");
        } else {
            System.out.println(animal + "呼吸空气");
        }
    }
}
public class Client{
    public static void  main (String[] args){
        Animal animal = new Animal();
        animal.breathe("牛");
        animal.breathe("羊");
        animal.breathe("猪");
        animal.breathe("鱼");
    }
}

总结：
1.单一原则SRP是一个简单又直观的原则，但是在实际编码的过程中很难将它恰当地运用，需要结合实际情况进行运用
2.单一职责原则可以降低类的复杂度，一个类仅负责一项职责，其逻辑肯定比负责多项指责简单。
3.提高了代码的可读性，提高系统的可维护性

接口分离原则（ISP）

定义：多个特定的客户端接口用好于一个通用性的总接口

进行了接口分离

在这里插入图片描述

interface I1 {
    public void method1();
}
interface I2{
    public void method2();
    public void method3();
}
interface I3{
    public void method4();
    public void method5();
}
class A{
    public void depend1(I1 i){
        i.method1();
    }
    public void depend2(I2 i){
        i.method2();
    }
    public void depend3(I2 i){
        i.method3();
    }

    public void depend1(B b) {
    }
}
class B implements  I1, I2 {
    @Override
    public void method1() {
        System.out.println("类 B 实现接口 I1 的方法 1");
    }

    @Override
    public void method2() {
        System.out.println("类 B 实现接口 I2 的方法 2");
    }

    @Override
    public void method3() {
        System.out.println("类 B 实现接口 I2 的方法 3");
    }
}
class C{
    public void depend1(I1 i){
        i.method1();
    }
    public void depend2(I3 i){
        i.method4();
    }
    public void depend3(I3 i){
        i.method5();
    }
}
class D implements  I1, I3{
    @Override
    public void method1() {
        System.out.println("类 D 实现接口 I1 的方法 1");
    }

    @Override
    public void method4() {
        System.out.println("类 D 实现接口 I3 的方法 4");
    }

    @Override
    public void method5() {
        System.out.println("类 D 实现接口 I3 的方法 5");
    }
}

没有进行接口分离

interface I {
    public void method1();
    public void method2();
    public void method3();
    public void method4();
    public void method5();
}
class A {
    public void depend1(I i){
        i.method1();
    }
    public void depend2(I i){
        i.method2();
    }
    public void depend3(I i) {
        i.method3();
    }
}
class B implements I{
    //类B只需要实现1，2，3，而其他方法它并不需要，但是也需要实现
    public void method1(){
        System.out.println("类 B 实现接口 I 的方法1");
    }
    public void method2(){
        System.out.println("类 B 实现接口 I 的方法3");
    }
    public void method3(){
        System.out.println("类 B 实现接口 I 的方法3");
    }
    public void depend4( ) { }
    public void depend5( ) { }
}
class C{
    public void depend1(I i) {
        i.method1();
    }
    public void depend2(I i) {
        i.method4();
    }
    public void depend3(I i) {
        i.method5();
    }
}
class D implements I{
    //类D只需要实现方法1，4，5，而其他方法它并不需要，但是也需要实现
    public void method1(){
        System.out.println("类 D 实现接口 I 的方法1");
    }
    public void method2(){}
    public void method3(){}
    public void method4(){
        System.out.println("类 D 实现接口 I 的方法4");
    }
    public void method5(){
        System.out.println("类 D 实现接口 I 的方法5");
    }
}
public class Client{
    public static void main(String[] args){
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());
        c.depend2(new D());
        c.depend3(new D());
    }
}

总结
1.接口隔离原则的思想在于建立单一接口，尽可能地区细化接口，接口中的方法尽可能少
2.但是凡事都要有个度，如果接口设计过小，则会造成接口数量过多，使设计复杂化，所以一定要适度

开放封闭原则（OCP）

定义：一个软件实体，如类，模块和函数应该对外扩展开发，对内修改关闭用抽象构建框架，用实现扩展细节。不以改动原有类的方式来实现新需求，而是应该以实现接口（或具体类继承抽象类）的方式来实现

//举个简单例子，这里有个生产电脑的公司，根据输入的类型，生产出不同的电脑，代码如下：

违背了开放-关闭原则

interface  Computer {}
class Macbook implements Computer {}
class Surface implements Computer {}
class Factory {
    public Computer produceComputer(String type)
    {
    Computer c = null;
        if(type.equals("macbook"))

    {
        c = new Macbook();
    }
        else if(type.equals("surface"))

    {
        c = new Surface();
    }
        return c;
}
}

//如果需要添加新的电脑产品，那么修改produceComputer原本已有的方法，正确的方式如下：

正确的开放-关闭原则

interface  Computer {}
class Macbook implements Computer {}
class Surface implements Computer {}
//Factory 工厂
class Factory {
    public Computer produceComputer() {
        return null;
    }
}
   class AppleFactory extends Factory {
       @Override
       public Computer produceComputer() {
           return new Macbook();
       }
   }
    class MSFactory extends Factory {
        @Override
        public Computer produceComputer() {
            return new Surface();
        }
    }

正确的方式应该是将Factory抽象成接口，让具体的工厂（如苹果工厂，微软工厂）去实现它，生产它们相应的产品，这样写有利于扩展，如果这是需要新增加戴尔工厂生产戴尔电脑，我们仅仅需要创建新的电脑类和新的工厂类，而不需要去修改已经写好的代码。
总结：
1.OCP可以具有良好的可扩展性，可维护性
2.不可能让一个系统的所有模块都满足OCP原则，我们能做到的事尽可能地不要修改已经写好的代码，已有的功能，而是去扩展它

里氏替换原则

定义：所有引用基类的地方必须能透明地使用其子类的对象，
也就是说子类对象可以替换其父类对象，而程序执行效果不变
解释：在继承体系中，子类中可以增加自己特有的方法，也可以实现父类的抽象方法，但是不能重写父类的非抽象方法，否则该继承关系就不是一个正确的继承关系。
里氏替换原则的重点在于不影响原功能，而不是不覆盖原方法。

//举个例子，我们需要完成一个两数相减的功能

class A{
    public int func1(int a, int b){
        return a-b;
    }
}

/*后来我们需要增加一个新的功能：完成两数相加，然后再与100求和，由类B；来负责。
即类B需要完成两个功能：两数相加，然后再加100由于类A已经实现了第一个功能，所以类B继承类A后，只需要再完成第二个功能就可以了，代码如下：

class A{
    public int func1(int a, int b){
        return a+b;
    }
    public int func2(int a, int b){
        return func1(a,b)+100;
    }
}

组合/聚合复用原则CRP

定义：在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分；
新的对象通过向这些对象的委派达到复用已有功能的目的。

依赖倒置原则DIP（Dependency Inversion Principle）

*定义：依赖抽象而不是依赖实现。抽象不应该以来细节，细节应该以来抽象。
高层模块不能依赖低层模块，二者都应该依赖抽象。

场景：母亲给孩子讲故事，只要给她一本书，他就可以照着书给孩子讲故事了，代码如下：
名词即为对象，动作即为某一对象的方法
···
/*class Book{
public String getContent(){
return “这是一个有趣的故事”;
}
}
class Mother{
public void say(Book book){
System.out.println(“妈妈开始讲故事”);
System.out.println(book.getContent());
}
}
public class Client{
public static void main(String[] args){
Mother mother = new Mother();
mother.say(new Book());
}
}
*/
···

若加入母亲读报纸，则无法加入，需要接口，如下代码

···
interface IReader{
public String getContent();
}

class Newspaper implements IReader{
public String getContent(){
return “这个一则重要的新闻”;
}
}

class Book implements IReader{
public String getContent(){
return “这是一个有趣的故事”;
}
}

class Mother{
public void say(IReader reader){
System.out.println(“妈妈开始讲故事”);
System.out.println(reader.getContent());
}
}

public class Client{
public static void main(String[] args){
Mother mother = new Mother();
mother.say(new Book());
mother.say(new Newspaper());
}
}
···

总结：
1.通过抽象来搭建框架，建立类和类的关联，以减少类间的耦合性。而且以抽象搭建的系统要比
以具体实现搭建的系统更加稳定，扩展性更高，同时也便于维护。
2.依赖倒转原则的核心就是要我们面向接口编程，理解了面向接口编程，也就理解了依赖倒转。

haoyu_zhang

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
开发规范原则（面向对象的精髓就是接口）

开发规范原则//面向对象的精髓就是接口//接口的作用，如何产生接口，接口具有什么样的特性//接口是抽象出来的，抽取其共同行为，属性和方法单一职责原则//动物类，会呼吸空气或会呼吸水，用类描述动物呼吸这个场景*单一原则class Terrestrial{ public void breathe(String animal){ System.out.println(animal + "呼吸空气"); }}class Aquatic{ public voi
复制链接

扫一扫

专栏目录