Java设计模式-面向对象7大原则

最新推荐文章于 2023-08-14 10:13:52 发布
最新推荐文章于 2023-08-14 10:13:52 发布
阅读量293 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41804870/article/details/109132932
版权

文章目录

1、面向对象7大原则

**1、开闭原则：**对扩展开放，对修改改变。

**2、里氏替换原则：**只要父类出现的地方，子类都可以替换他，使用者可能都不知道到底是子类还是父类（就是子类继承了超类，在子类中保持超类的特性）

**3、单一职责原则：**对类来说，就是一个类应该只负责一项职责。

**4、依赖倒置原则：**要面向接口编程，不要面向实现编程。

**5、接口隔离原则：**客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

**6、迪米特原则：**一个类对自己依赖的其他类知道的越少越好。

**7、合成复用原则：**尽量先使用组合或聚合等关联关系，其次才考虑使用继承关系来实现。

1.1 单一职责原则

对类来说，就是一个类应该只负责一项职责，这就是单一职责原则。

违反单一职责原则例子：

public class SingleReponsibility1 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("汽车");  //输出： 汽车 在公路上跑
        vehicle.run("摩托车");//输出： 摩托车 在公路上跑
        vehicle.run("飞机");//输出： 飞机 在公路上跑
        // 飞机的输出不符合常理，因为违反单一职责原则。
    }
}

// 交通工具类
class Vehicle {
    public void run(String vehicle){
        System.out.println(vehicle + " 在公路上跑");
    }
}

单一职责原则例子：

public class SingleReponsibility1 {
    public static void main(String[] args) {
        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("汽车");  //输出： 汽车 在公路上跑
        roadVehicle.run("摩托车");//输出： 摩托车 在公路上跑
        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");//输出： 飞机 在天上跑
    }
}

// 路上交通工具类
class RoadVehicle {
    public void run(String vehicle){
        System.out.println(vehicle + " 在公路上跑");
    }
}

//空中交通工具类
class AirVehicle {
    public void run(String vehicle){
        System.out.println(vehicle + " 在天上跑");
    }
}

不过上面这个例子不是最好的，变成这个例子例子改动太大，最好是使用接口+多态的方式。

总结：

  1. 降低类的复杂度，一个类只负责一项职责。
  2. 提高类的可读性，可维护性。
  3. 减低变更引起的风险。
  4. 只有类的方法比较少，可以只在方法级别保持单一原则。

1.2 接口隔离原则

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

违反接口隔离原则：

类B、D都实现了接口interface1，类A只需要使用到B的operation1和operation3方法，类C只需要用到D的operation2和operation4方法，这样就是 依赖了所不需要的接口了。

在这里插入图片描述

public class SegregationTest {
    public static void main(String[] args) {
        A a = new A();
        a.dependOn1(new B());
        a.dependOn3(new B());
        C c = new C();
        c.dependOn2(new D());
        c.dependOn4(new D());
    }
}

interface interface1{
    void operation1();
    void operation2();
    void operation3();
    void operation4();
}

class B implements interface1{   //B只被用到了operation1和operation3方法，却实现了所有接口方法。
    @Override
    public void operation1() {
        System.out.println("B 实现了 operation1");
    }

    @Override
    public void operation2() {
        System.out.println("B 实现了 operation2");
    }

    @Override
    public void operation3() {
        System.out.println("B 实现了 operation3");
    }

    @Override
    public void operation4() {
        System.out.println("B 实现了 operation4");
    }
}

class D implements interface1{   //D只被用到了operation2和operation4方法，却实现了所有接口。
    @Override
    public void operation1() {
        System.out.println("D 实现了 operation1");
    }

    @Override
    public void operation2() {
        System.out.println("D 实现了 operation2");
    }

    @Override
    public void operation3() {
        System.out.println("D 实现了 operation3");
    }

    @Override
    public void operation4() {
        System.out.println("D 实现了 operation4");
    }
}

class A{   //A只需要B的operation1和operation3方法
    public void dependOn1(interface1 i){
        i.operation1();
    }
    public void dependOn3(interface1 i){
        i.operation3();
    }
}

class C{  //只需要用到D的operation2和operation4方法
    public void dependOn2(interface1 i){
        i.operation2();
    }
    public void dependOn4(interface1 i){
        i.operation4();
    }
}

正确例子：

进行接口分离。

public class SegregationTest {
    public static void main(String[] args) {
        A a = new A();
        a.dependOn1(new B());
        a.dependOn3(new B());
        C c = new C();
        c.dependOn2(new D());
        c.dependOn4(new D());
    }
}

interface interface1{
    void operation1();
    void operation3();
}

interface interface2{
    void operation2();
    void operation4();
}

class B implements interface1{
    @Override
    public void operation1() {
        System.out.println("B 实现了 operation1");
    }

    @Override
    public void operation3() {
        System.out.println("B 实现了 operation3");
    }
}

class D implements interface2{
    @Override
    public void operation2() {
        System.out.println("D 实现了 operation2");
    }

    @Override
    public void operation4() {
        System.out.println("D 实现了 operation4");
    }
}

class A{
    public void dependOn1(interface1 i){
        i.operation1();
    }
    public void dependOn3(interface1 i){
        i.operation3();
    }
}

class C{
    public void dependOn2(interface2 i){
        i.operation2();
    }
    public void dependOn4(interface2 i){
        i.operation4();
    }
}

1.3 依赖倒置原则

依赖倒置原则：

  1. 高层模块不应该依赖底层模块，二者都应该依赖其抽象。（高层理解为吃动作，底层理解为面包等具体食物）
  2. 抽象不应该依赖细节，细节应该依赖抽象。
  3. 依赖倒置的中心思想就是面向接口编程。

在继承时要遵循里氏替换原则。

错误示例：

class DependencyInversionTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

//电子邮箱类
class Email{
    public String getInfo(){
        return "获得电子邮件信息";
    }
}

//完成Person接受消息的功能
//缺点：如果要接受消息的对象是 微信类、短信类，就得增加相应的方法。
class Person{
    public void receive(Email email){
        System.out.println(email.getInfo());
    }
}

解决示例：

引入一个抽象的接口IReceiver，表示接收者，这样Person类就只与接口发送依赖

class DependencyInversionTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new Wechat());
    }
}

interface IReceiver{
    String getInfo();
}

//电子邮箱类
class Email implements IReceiver{
    public String getInfo(){
        return "获得电子邮件信息";
    }
}

//微信类
class Wechat implements IReceiver{
    @Override
    public String getInfo() {
        return "获得微信信息";
    }
}

//完成Person接受消息的功能
class Person{
    //这样就不需要每添加一个消息对象就写相应的方法
    public void receive(IReceiver receiver){
        System.out.println(receiver.getInfo());
    }
}

上面的示例是基于接口实现的，下面的示例是基于构造函数来实现的：

class DependencyInversionTest {
    public static void main(String[] args) {
        Person person = new Person(new Email());
        person.receive();
        person = new Person(new Wechat());
        person.receive();
    }
}

interface IReceiver{
    String getInfo();
}

//电子邮箱类
class Email implements IReceiver{
    public String getInfo(){
        return "获得电子邮件信息";
    }
}

//微信类
class Wechat implements IReceiver{
    @Override
    public String getInfo() {
        return "获得微信信息";
    }
}

//完成Person接受消息的功能
class Person{
    private IReceiver iReceiver;

    public Person(IReceiver iReceiver) {
        this.iReceiver = iReceiver;
    }

    public void receive(){
        System.out.println(iReceiver.getInfo());
    }
}

下面的示例是基于setter方法来实现：

class DependencyInversionTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.setiReceiver(new Email());
        person.receive();
        person.setiReceiver(new Wechat());
        person.receive();
    }
}

interface IReceiver{
    String getInfo();
}

//电子邮箱类
class Email implements IReceiver{
    public String getInfo(){
        return "获得电子邮件信息";
    }
}

//微信类
class Wechat implements IReceiver{
    @Override
    public String getInfo() {
        return "获得微信信息";
    }
}

//完成Person接受消息的功能
class Person{
    private IReceiver iReceiver;

    public void setiReceiver(IReceiver iReceiver) {
        this.iReceiver = iReceiver;
    }

    public void receive(){
        System.out.println(iReceiver.getInfo());
    }
}

1.4 里氏替换原则

**里氏替换原则：**所有引用基类（父类）的地方必须能透明地使用其子类的对象。也就是说子类可以扩展父类的功能，但不能改变父类原有功能。

透明使用的关键就是，子类不能改变父类原有功能。

错误示例：子类改变了父类原有功能后，当我们在引用父类的地方使用其子类的时候，没办法透明使用add方法了。

public class Test53 {
    public static void main(String[] args) {
        //当我们在引用父类的地方使用其子类的时候，无法透明的使用add方法
        Person person = new Children();
        person.add();
    }
}

class Person{
    public void add(){
        System.out.println("父类");
    }
}

class Children extends Person{
    public void add(){
        System.out.println("子类");
    }
}

正确示例：将原来的父类和子类都继承一个更通俗的基类（抽象类）。

public class Test53 {
    public static void main(String[] args) {
       // Person person = new Children();  这个用不了
        All all = new Person();
        all.add();
        all = new Children();
        all.add();
    }
}

abstract class All{
    public abstract void add();
}

class Person extends All{
    public void add(){
        System.out.println("父类");
    }
}

class Children extends All{
    public void add(){
        System.out.println("子类");
    }
}

1.5 开闭原则

**开闭原则：**对扩展开发，对修改关闭。

错误示例：

public class OcpTest {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Retangle());
        graphicEditor.drawShape(new Circle());
    }
}

//绘制图形的类
class GraphicEditor{
    //当我再加一个图形时，这个方法就必须改动。不符合对修改关闭。
    public void drawShape(Shape shape){
        if(shape.type==1){
            drawRetangle();
        }else if(shape.type==2){
            drawCircle();
        }
    }

    public void drawRetangle(){
        System.out.println("绘制矩形");
    }

    public void drawCircle(){
        System.out.println("绘制圆形");
    }
}

//图形类
class Shape {
    int type;
}

//矩形类
class Retangle extends Shape {
    public Retangle() {
        super.type = 1;
    }
}

//圆形类
class Circle extends Shape {
    public Circle() {
        super.type = 2;
    }
}

正确示例：使用抽象类。

public class OcpTest {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Retangle());
        graphicEditor.drawShape(new Circle());
    }
}

//绘制图形的类
class GraphicEditor{
    public void drawShape(Shape shape){
       shape.draw();
    }
}

//图形类
abstract class Shape {
    abstract public void draw();
}

//矩形类
class Retangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

//圆形类
class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

1.6 迪米特法则

**迪米特法则（又称最小知道法则）：**一个类对自己依赖的其他类知道的越少越好。

一个对象应该对其他对象有最少的了解要满足这两点：

  1. 只和直接朋友交流。
  2. 减少对朋友的了解。

**直接朋友：**出现在成员变量、方法的返回类型，方法参数就是直接的朋友。（只出现在方法体内部的类不是直接朋友）

**迪米特法则的目的：**减低类之间的耦合度，但并不是要求完全没有依赖关系。

错误示例：

public class DemeterTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.washClothes();
    }
}

//洗衣机类
class WashingMachine{
    public void receiveClothes(){
        System.out.println("洗衣街接收到了衣服");
    }

    public void wash(){
        System.out.println("洗衣机洗衣服");
    }

    public void dry(){
        System.out.println("洗衣机烘干衣服");
    }
}

//人
class Person{
    //让洗衣机洗衣服的方法
    public void washClothes(){
        //由人来指定洗衣机洗衣服的顺序，Person类对WashingMachine类知道的太多。
        WashingMachine washingMachine = new WashingMachine();
        washingMachine.receiveClothes();
        washingMachine.wash();
        washingMachine.dry();
    }
}

正确示例：

public class DemeterTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.washClothes(new WashingMachine());
    }
}

//洗衣机类
class WashingMachine{
    public void receiveClothes(){
        System.out.println("洗衣街接收到了衣服");
    }

    public void wash(){
        System.out.println("洗衣机洗衣服");
    }

    public void dry(){
        System.out.println("洗衣机烘干衣服");
    }

    public void autoWash(){
        receiveClothes();
        wash();
        dry();
    }
}

//人
class Person{
    //让洗衣机洗衣服的方法
    public void washClothes(WashingMachine washingMachine){
        washingMachine.autoWash();
    }
}

1.7 合成复用原则

原则是尽量使用合成/聚合的方式。而不是使用继承。

做不秃头的程序员
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 设计原则：七种方法帮助你更好地设计软件
qq_35090943的博客
12-29 1166
总结一下，设计模式中的7大原则是：单一职责原则、开放封闭原则、里氏替换原则、依赖倒转原则、迪维恩原则、合成复用原则和接口隔离原则。这些原则都是在软件设计中常用的原则，它们可以帮助我们在设计软件系统时避免一些常见的问题。
Java设计模式-面向对象七大设计原则
02-06
例如：随着计算机的不断发展，程序学习这门技术也越来越重要，很多人都开启了...面向对象设计原则一共有七个：开闭原则、里氏替换原则、依赖倒转原则、单一职责原则、接口隔离原则、组合/聚合复用原则、迪米特法则。
Java面向对象7大设计原则
狐言
08-15 592
设计原则单一职责原则 SRP开闭原则 OCP里氏替换原则 LSP依赖倒置原则 DIP接口隔离原则 ISP组合复用原则 CRP迪米特法则 LOD 单一职责原则 SRP 开闭原则 OCP 里氏替换原则 LSP 依赖倒置原则 DIP 接口隔离原则 ISP 组合复用原则 CRP 迪米特法则 LOD ...
Java面向对象设计的7大原则
FeelTouch Labs
10-27 623
原则一：（SRP：Single responsibility principle）单一职责原则又称单一功能原则 核心：解耦和增强内聚性（高内聚，低耦合） 描述：类被修改的几率很大，因此应该专注于单一的功能。如果你把多个功能放在同一个类中，功能之间就形成了关联，改变其中一个功能，有可能中止另一个功能，这时就需要新一轮的测试来避免可能出现的问题。 原则二：开闭原则（OCP：Open Cl
【java】面向对象的七大设计原则
Ez4Sterben的博客
07-10 1321
面向对象的七大设计原则
java进阶之面向对象设计七大原则
码农先锋的博客
07-03 256
目录概述1.单一职责原则2.开闭原则3.里氏代换原则4.依赖倒转原则5.接口隔离原则6.合成复用原则7.迪米特法则 概述 对于面向对象软件系统的设计而言，在支持可维护性的同时，提高系统的可复用性是一个至关重要的问题，如何同时提高一个软件系统的可维护性和可复用性是面向对象设计需要解决的核心问题之一。 在面向对象设计中，可维护性的复用是以设计原则为基础的。每一个原则都蕴含一些面向对象设计的思想，可以...
Java设计模式-图解-附代码.doc
09-19
本文件“Java设计模式-图解-附代码.doc”主要探讨了Java语言中的设计模式，分为创建型、结构型和行为型三大类。下面将对这些模式进行详细解释。 1. **创建型模式**： - **工厂方法**：提供一个接口用于创建对象，...
【Java设计模式-源码】装饰器模式：动态扩展类的功能
最新发布
08-31
它通过提供一种将对象“包裹”在具有类似接口的对象中的方式来实现这一点，增强了Java设计模式的灵活性。 ## 二、详细解释及实际示例 1. **实际示例**： - 想象一个咖啡店，你可以在这里定制你的咖啡订单。你从一...
Java面向对象系统分析与设计作业（对程序提供两种及两种以上的设计原则和设计模式优化附含类图）
05-20
面向对象系统分析与设计作业（对程序提供两种及以上的设计原则和设计模式优化） 一、项目总体要求 1、分为两次完成。第一次为基本原则的应用，第二次为设计模式的应用。 2、每个人提交一份，包括文档撰写和代码实现...
JAVA设计模式六大原则详细讲解（面向对象语言通用）
08-11
1.单一职责原则： 不要存在多于一个导致类变更的原因 ...接口隔离原则告诉我们在设计接口的时候要精简单一；迪米特法则告诉我们要降低耦合。而开闭原则是总纲，他告诉我们要对扩展开放，对修改关闭。
java面向对象的原则
weixin_42331540的博客
08-06 423
 单一职责原则：一个类只做它该做的事情。（单一职责原则想表达的就是"高内聚"，写代码最终极的原则只有六个字"高内聚、低耦合"，就如同葵花宝典或辟邪剑谱的中心思想就八个字"欲练此功必先自宫"，所谓的高内聚就是一个代码模块只完成一项功能，在面向对象中，如果只让一个类完成它该做的事，而不涉及与它无关的领域就是践行了高内聚的原则，这个类就只有单一职责。我们都知道一句话叫"因为专注，所以专业"，一个对象如果...
公共技术点之面向对象六大原则
Mr.Simple的专栏
02-24 7528
概述在工作初期，我们可能会经常会有这样的感觉，自己的代码接口设计混乱、代码耦合较为严重、一个类的代码过多等等，自己回头看的时候都觉得汗颜。再看那些知名的开源库，它们大多有着整洁的代码、清晰简单的接口、职责单一的类，这个时候我们通常会捶胸顿足而感叹：什么时候老夫才能写出这样的代码！ 在做开发的这些年中，我渐渐的感觉到，其实国内的一些初、中级工程师写的东西不规范或者说不够清晰的原因是缺乏一些指导
Java的设计原则
LCF_lxf_ldy的博客
11-11 579
             java的设计原则在程序员写代码应该去掌握原则性的东西，这样才能使得自己的代码不会腐臭，都说好代码是“简约而不简单”，甚至还有人说封装、继承、多态只是入门， 重点是 OOD（面向对象设计）和设计模式背后的思想，思想，思想，那就一定要看看这设计模式，没有银弹，先来看看Java的六大心法，之后再看23种武功招式： Single responsibility principl...
java设计原则
Alex十年的博客
08-20 224
设计模式就是前辈们总结出来的设计方法。不同的设计模式适用于不同的场景。 公认的设计模式有23种。千万不要认为有任何一种设计模式能够解决任何问题，每一种设计模式只能用于特定的场景，而不是万能的。设计模式有优点，也有缺点，不能为了使用设计模式而使用设计模式。切记模式的滥用。 单一职责原则：每个方法，每个类，每个框架只负责一件事。 优点：代码的重用性提高，代码的可读性提高，就像大纲一样。 开闭原则：对扩...
JAVA设计原则
qq_53799708的博客
08-14 89
高层模块不应该依赖低层模块，两者都应该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象，简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。
Java中的设计原则
weixin_28876327的博客
01-14 251
单一职责原则         单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。         在软件系统中，一个类（大到模块，小到方法）承担的职责越多，它被复用的可能性就越小，而且一个类承担的职责过多，就相当于将这些职责耦合在一起，当其中一个职责变化时，...
Java软件设计原则
Crook的专栏
06-10 546
先了解UML相关知识 UML类图 + 表示public - 表示privae # 表示protected ~ 表示defualt 下划线 表示static 斜体 表示abstract 开闭原则：对扩展开放，对修改闭合。 // 1.首先创建一个接口ICourse public interface ICourse { Integer getid(); S...
Java面向对象设计七大原则详解
面向对象设计原则是软件开发中的核心指导思想，尤其在Java这样的面向对象编程语言中，这些原则对于构建高质量、可维护和可复用的软件至关重要。以下是这些原则的详细解释： 1. 单一职责原则（Single Responsibility...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值