Erlo

Java基础 -- 七大基本原则

时间:2020-09-17   阅读:16次   来源:博客园
页面报错
点赞

1、单一职责原则(Single-Responsibility Principle)

一个类应该只有一个能引起变化的原因,一个类的功能要单一,只做与它相关的事情

1.1 优点

1.2 示例

interface Human {
    void cry();
    void laugh();
    
    void punch();
    void kick();
}
interface Mood{
    void cry();
    void laugh();
}

interface Act{
    void punch();
    void kick();
}

2、开放封闭原则(Open-Closed principle)

软件实体(类,模块,函数等)应该是可扩展的,而不可修改的。实现该原则的核心思想就是对抽象编程,而不对具体编程,因为抽象相对稳定

2.1 优点

2.2 示例

interface Phone {
    void call();
}

class Nokia implements Phone {
    @Override
    public void call() {}
}
interface Phone {
    void call();
}

class Nokia implements Phone {
    @Override
    public void call() {}
}

class NokiaWP8 extends Nokia {
    @Override
    public void call() {}

    public void photograph() {}
    
    public void surfing() {}
}

3、里氏替换原则(Liskov-Substitution Principle)

子类应当可以替换父类并出现在父类能够出现的任何地方。这一思想体现为对继承机制的约束规范,只有子类能够替换父类时,才能保证系统在运行期内识别子类,这是保证继承复用的基础

该原则主要着眼于对抽象和多态建立在继承的基础上,因此只有遵循了里氏替换原则,才能保证继承复用是可靠的。实现的方法是面向接口编程:将公共部分抽象为接口或抽象类,在子类中通过覆写父类的方法实现新的方式支持同样的职责

3.1 优点

3.2 示例

public class Demo {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.say();	// 嗷~
        Animal human = new Human();
        human.say();	// 艹
    }
}

class Animal{
    void say() {
        System.out.println("嗷~");
    }
}

class Human extends Animal {
    @Override
    void say() {
        System.out.println("艹");
    }
}
public class Demo {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.say();	// 嗷~
        Animal human = new Human();
        human.say();	// 嗷~
    }
}

class Animal{
    void say() {
        System.out.println("嗷~");
    }
}

class Human extends Animal {
    @Override
    void say() {
        super.say();
    }
}

4、依赖倒置原则(Dependecy-Inversion Principle)

高层模块不依赖于底层模块,二者都同依赖于抽象;抽象不依赖于具体,具体依赖于抽象

依赖一定会存在于类与类、模块与模块之间。当两个模块之间存在紧密的耦合关系时,最好的方法就是分离接口和实现:在依赖之间定义一个抽象的接口使得高层模块调用接口,而底层模块实现接口的定义,以此来有效控制耦合关系,达到依赖于抽象的设计目标

4.1 优点

4.2 示例

public class Demo {
    public static void main(String[] args) {
        User user = new User();
        Phone phone = new Iphone();
        user.usePhone(phone);
    }
}

interface Phone {
    void call();
}

interface Human {
    void usePhone(Phone phone);
}

class Iphone implements Phone {
    @Override
    public void call() {
        System.out.println("calling...");
    }
}

class User extends Iphone implements Human {
    @Override
    public void usePhone(Phone phone) {
        phone.call();
    }
}

5、接口隔离原则(Interface-Segregation Principle)

客户端不应该依赖它不需要的接口,一个类对另一个类的依赖应该建立在最小的接口上。接口应该是内聚的,应该避免大接口。接口有效地将细节和抽象隔离,强调了接口的单一性

大接口存在明显的弊端,必须得完全实现接口的所有方法、属性等;而某些时候,并不需要所有的接口定义,而且对大接口的修改将导致一连串的程序需要修改。将大接口分解为多个特点的定制化方法,使得客户端仅仅依赖于它们的实际调用的方法

分离的手段主要有两种

5.1 优点

5.2 示例

interface Behavior {
    void eat();
    void fly();
    void speak();
}

class Bird implements Behavior {
    @Override
    public void eat() {}
    
    @Override
    public void fly() {}

    @Override
    public void speak() {}
}

class Human implements Behavior {
    @Override
    public void eat() {}
    
    @Override
    public void fly() {}

    @Override
    public void speak() {}
}
interface Beahvior {
    void eat();
}

interface Behavior1 extends Beahvior {
    void fly();
}

interface Behavior2 extends Beahvior {
    void speak();
}

class Bird implements Behavior1 {
    @Override
    public void fly() {}

    @Override
    public void eat() {}
}

class Human implements Behavior2 {
    @Override
    public void eat() {}

    @Override
    public void speak() {}
}

6、最少知道原则 / 迪米特法则(Least Knowledge Principle)

一个对象应当对其他对象有尽可能少的了解,每个类尽量减少对其他类的依赖

该原则不希望类之间建立直接的接触,如果真的有需要建立联系,也希望能通过中间类来转达。因此,迪米特原则有可能会造成系统中存在大量的中介类,这些类都是为了传递类之间的相互调用关系,在一定程度上增加了系统的复杂度

6.1 优点

6.2 示例

public class Demo {
    public static void main(String[] args) {
        Human human = new Human("Trump");
        Phone phone = new Phone();
        phone.call(new User(human));
    }
}

class Phone {
    void call(User user) {
        user.callSomeone();
    }
}

class Human {
    String name;

    public Human(String name) {
        this.name = name;
    }
}

class User {
    private Human human;

    public User(Human human) {
        this.human = human;
    }

    void callSomeone() {
        System.out.println("call: " + human.name);
    }
}

7 、组合 / 聚合复用原则(Composite / Aggregate Reuse Principle)

在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分,新对象通过向这些对象的委派达到复用已有功能的目的。尽量的使用合成和聚合,而不是继承关系达到复用的目的

7.1 优点

7.2 组合与继承

组合关系 继承关系
不破坏封装,整体类与局部类之间松耦合,彼此相对独立 破坏封装,子类与父类之间紧密耦合,子类依赖于父类的实现,子类缺乏独立性
具有较好的可扩展性 支持扩展,但是往往以增加系统结构的复杂度为代价
支持动态组合。在运行时,整体对象可以选择不同类型的局部对象 不支持动态继承。在运行时,子类无法选择不同的父类
整体类可以对局部类进行包装,封装局部类的接口,提供新的接口 子类不能改变父类的接口
整体类不能自动获得和局部类同样的接口 子类能自动继承父类的接口
创建整体类的对象时,需要创建所有局部类的对象 创建子类的对象时,无须创建父类的对象

7.3 示例

class Human {
}

class Air {
    private Human human;

    public Air() {
        human = new Human();
    }
}
class Phone {
}

class Human {
    private Phone phone;

    public Human() {
        phone = new Phone();
    }
}

相关推荐

提交留言

评论留言

还没有评论留言,赶紧来抢楼吧~~

吐槽小黑屋()

* 这里是“吐槽小黑屋”,所有人可看,只保留当天信息。

  • Erlo吐槽

    Erlo.vip2020-09-26 04:26:05Hello、欢迎使用吐槽小黑屋,这就是个吐槽的地方。
  • 返回顶部