面向对象编程的精髓你真的掌握了吗？

已于 2024-07-29 16:09:08 修改
阅读量301 收藏 6
点赞数 3
文章标签： java 后端
于 2024-07-29 16:03:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heyongjin22/article/details/140773527
版权

设计原则与思想：面向对象

目录
  1. 引言
  2. 面向对象的基本概念
  3. 面向对象的设计原则
  4. 面向对象的设计模式
  5. 实战：构建一个简单的图书管理系统
  6. 总结

1. 引言

在软件开发的世界里，面向对象（Object-Oriented Programming, OOP）是当前主流的编程范式之一。面向对象的编程思想通过类和对象的设计，将复杂的问题分解成更容易管理的模块。本文旨在深入探讨面向对象编程的基本概念、设计原则和常见设计模式，并通过一个简单的图书管理系统实战，帮助读者对面向对象编程有一个全面的理解和掌握。

2. 面向对象的基本概念

面向对象编程的几个核心概念构成了其基础，通过理解和掌握这些概念，我们可以更好地应用面向对象的设计原则和模式。

2.1 对象

对象是面向对象编程的基本单位，是类的实例。每个对象都有自己的状态（属性）和行为（方法）。

// 示例代码
public class Car {
    // 属性
    String color;
    int maxSpeed;

    // 方法
    void drive() {
        System.out.println("Driving at max speed: " + maxSpeed);
    }
}

2.2 类

类是对象的模板，它定义了一类对象的共同属性和行为。

// 示例代码
Car myCar = new Car();
myCar.color = "Red";
myCar.maxSpeed = 150;
myCar.drive();

2.3 封装

封装是一种将数据和操作这些数据的方法进行绑定，并隐藏实现细节的手段。通过封装可以提高代码的模块化和安全性。

// 示例代码
public class Car {
    private String color;
    private int maxSpeed;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }

    public void drive() {
        System.out.println("Driving at max speed: " + maxSpeed);
    }
}

2.4 继承

继承是一种面向对象的机制，用于定义一个新类，通过从现有类中继承特性来减少代码重复，建立层次结构。

// 示例代码
public class SportsCar extends Car {
    private boolean turbo;

    public boolean isTurbo() {
        return turbo;
    }

    public void setTurbo(boolean turbo) {
        this.turbo = turbo;
    }

    @Override
    public void drive() {
        if (turbo) {
            System.out.println("Turbo driving at speed: " + getMaxSpeed());
        } else {
            System.out.println("Driving at speed: " + getMaxSpeed());
        }
    }
}

2.5 多态

多态允许方法调用在运行时根据对象的实际类型进行分派。它包括方法重载和方法覆盖两种形式。

// 示例代码
Car myCar = new SportsCar();
myCar.setMaxSpeed(200);
myCar.drive(); // 调用的是 SportsCar 的 drive 方法

3. 面向对象的设计原则

设计原则是面向对象设计的基石，遵循这些原则可以提高系统的可重用性、可维护性和扩展性。

3.1 单一职责原则 (SRP)

一个类应该只有一个引起变化的原因，即一个类只负责一项职责。

// 示例代码
public class Book {
    private String title;
    private String author;

    // Book 类只负责书籍的信息
}

public class BookPrinter {
    public void printBook(Book book) {
        // 负责打印书籍信息
    }
}

3.2 开闭原则 (OCP)

软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

// 示例代码
public abstract class Shape {
    abstract void draw();
}

public class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing Circle");
    }
}

public class Rectangle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing Rectangle");
    }
}

public class Drawing {
    public void drawShape(Shape shape) {
        shape.draw();
    }
}

3.3 里氏替换原则 (LSP)

如果 S 是 T 的子类，那么类型为 T 的对象可以被类型为 S 的对象替换而不改变程序的正确性。

// 示例代码
public class Bird {
    public void fly() {
        System.out.println("Flying");
    }
}

public class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Penguins can't fly");
    }
}

3.4 依赖倒置原则 (DIP)

高层模块不应该依赖于低层模块，两者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

// 示例代码
public interface Engine {
    void start();
}

public class PetrolEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Petrol engine starting");
    }
}

public class Car {
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.start();
    }
}

3.5 接口隔离原则 (ISP)

客户端不应该被强迫依赖于它们不使用的方法。一个接口应该只包含客户端需要的行为。

// 示例代码
public interface Printer {
    void print();
}

public interface Scanner {
    void scan();
}

public class AllInOnePrinter implements Printer, Scanner {
    @Override
    public void print() {
        System.out.println("Printing");
    }

    @Override
    public void scan() {
        System.out.println("Scanning");
    }
}

4. 面向对象的设计模式

设计模式是针对特定问题的成熟解决方案，遵循设计原则，能够提高代码的复用性、扩展性和可维护性。

4.1 创建型模式

4.1.1 单例模式

确保一个类只有一个实例，并提供全局访问点。

// 示例代码
public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

4.1.2 工厂模式

定义一个创建对象的接口，但让子类决定实例化哪一个类。

// 示例代码
public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        }
        return null;
    }
}

4.2 结构型模式

4.2.1 适配器模式

使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

// 示例代码
public interface MediaPlayer {
    void play(String audioType, String fileName);
}

public class AudioPlayer implements MediaPlayer {
    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file. Name: " + fileName);
        } else {
            // 适配其他格式
        }
    }
}

4.2.2 装饰器模式

动态地将责任附加到对象上。若要扩展功能，装饰模式提供了比继承更有弹性的替代方案。

// 示例代码
public interface Car {
    void assemble();
}

public class BasicCar implements Car {
    @Override
    public void assemble() {
        System.out.print("Basic Car.");
    }
}

public class CarDecorator implements Car {
    protected Car car;

    public CarDecorator(Car car) {
        this.car = car;
    }

    @Override
    public void assemble() {
        this.car.assemble();
    }
}

4.3 行为型模式

4.3.1 策略模式

定义一系列算法, 把它们一个个封装起来, 并且使它们可相互替换。

// 示例代码
public interface Strategy {
    int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

4.3.2 观察者模式

定义对象间的一种一对多的依赖关系，以便一个对象变化时，所有依赖于它的对象都能得到通知并自动更新。

// 示例代码
import java.util.ArrayList;
import java.util.List;

public class Subject {
    private List<Observer> observers = new ArrayList<>();
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyAllObservers();
    }

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}

public class ConcreteObserver extends Observer {
    public ConcreteObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("State changed to: " + subject.getState());
    }
}

5. 实战：构建一个简单的图书管理系统

5.1 需求分析

构建一个简单的图书管理系统，要求包括以下几个功能：

  • 用户可以添加书籍。
  • 用户可以删除书籍。
  • 用户可以查看所有书籍。
  • 用户可以查找特定书籍。

5.2 类图设计

根据需求分析，我们设计以下几个类：

  • Book：表示书籍。
  • Library：表示图书馆，包含书籍的管理操作。

5.3 代码实现
// Book 类
public class Book {
    private String title;
    private String author;
    private String isbn;

    public Book(String title, String author, String isbn) {
        this.title = title;
        this.author = author;
        this.isbn = isbn;
    }

    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public String getIsbn() {
        return isbn;
    }

    @Override
    public String toString() {
        return "Book{" +
                "title='" + title + '\'' +
                ", author='" + author + '\'' +
                ", isbn='" + isbn + '\'' +
                '}';
    }
}

// Library 类
import java.util.ArrayList;
import java.util.List;

public class Library {
    private List<Book> books;

    public Library() {
        this.books = new ArrayList<>();
    }

    public void addBook(Book book) {
        this.books.add(book);
        System.out.println("Book added: " + book);
    }

    public void removeBook(String isbn) {
        this.books.removeIf(book -> book.getIsbn().equals(isbn));
        System.out.println("Book removed with ISBN: " + isbn);
    }

    public void listBooks() {
        for (Book book : books) {
            System.out.println(book);
        }
    }

    public Book findBookByTitle(String title) {
        for (Book book : books) {
            if (book.getTitle().equalsIgnoreCase(title)) {
                return book;
            }
        }
        return null;
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        Library library = new Library();

        Book book1 = new Book("Effective Java", "Joshua Bloch", "123456789");
        Book book2 = new Book("Clean Code", "Robert C. Martin", "987654321");

        library.addBook(book1);
        library.addBook(book2);

        library.listBooks();

        library.removeBook("123456789");
        library.listBooks();

        Book foundBook = library.findBookByTitle("Clean Code");
        System.out.println("Book found: " + foundBook);
    }
}

6. 总结

本文从基础概念入手，深入探讨了面向对象编程的核心思想和设计原则，并通过设计模式的讲解和实战代码演示，能帮助大家系统地掌握面向对象编程的精髓。

有梦想的小何
关注
面向对象编程的精髓在于将行为绑定在数据上
02-27 1976
"面向对象编程的精髓在于将行为绑定在数据上"这句话是经典的，因为我们都知道，面向对象的思想是从面向过程编程中发展而来的，而在早期的面向过程编程语言中，程序是由一组结构体和操作该结构体对象的函数组成，并且，结构体和函数是分开的，离散的，通过在函数参数列表中声明一个结构体指针来和结构体产生关联，这样的关联关系使得数据和函数之间的的关系不够明显清晰，比如： Structtask_struct {
Java语言教程与案例：从入门到精通，掌握面向对象编程的精髓
02-05
Java语言教程与案例：从入门到精通，掌握面向对象编程的精髓。Java语言教程与案例：从入门到精通，掌握面向对象编程的精髓。Java语言教程与案例：从入门到精通，掌握面向对象编程的精髓。Java语言教程与案例：从入门...
Java 接口——面向对象的精髓
Java开发-破曉
12-05 200
接口有何用？面试宝典上背下来的总结，你真的明白吗？ 接口&amp;工厂方法 其实很简单&gt;。&lt;~ 什么是接口 先看看生活中的接口，比如USB接口。 USB接口的设计者在最初就知道USB能支持这么多功能吗？他们是怎样未卜先知地设计的呢？其实他们也不知道以后USB上会连什么设备，他们只是定义了一个数据传输与供电的标准而已。Java中也是类似的，定义了接口，就等于定义了调用对象的标...
面向对象的精髓（JAVA,C++）
qq_35050438的博客
01-21 478
面向对象和面向过程的区别： 小时候学过pascal，跨专业自学过c语言，都是面向过程编程 而如今学的C++，python，java都是面向对象编程。 网上所云是设计方式的不同 过程编程：你可以看到解决问题的每一个步骤，每一个步骤可能都有千丝万缕的联系。 对象编程：你仅仅能看到什么模块解决什么问题，模块之间相互独立，而怎么解决的具体过程，被黑盒化了。 虽然问题都被解决了，但是方式不同。 这样讲不通俗...
面向对象的核心
fencer2068的专栏
10-25 609
与题目名称一样，何为面向对象，只要是搞过java或者了解java的朋友都应该明白，在这里就不多说了哈哈(^,.^)，但是面向对象的核心又是什么呢？或者说它的精髓所在又是什么呢？貌似这个问题就值的朋友们深究了。 在面向对象的世界里，一切皆为对象，已是大家公知的了，在这里不再强调，而基于面向对象本身的核心又是什么呢？这里讲的并不是基于java的核心技术或者周边一些经典的第3方插件或者经典框架。当然也...
面向对象精要
做一个有知识的流氓
03-24 102
自己记录笔记 面向对象是软件开发中的一种方法，现在被广泛使用。面向对象是使用一种抽象的方式来模拟现实世界的编程模式。在面向对象中，我们可以将程序看做一个个对象互相协作的结果。 面向对象具有三大特性和六大原则。 三大特性是继承、多态和封装。 六大原则: 是单一职责原则（SRP） 开放封闭原则（OCP） 里氏替换原则（LSP） 依赖倒置原则（DIP） 接口分离原则（ISP） 最少知识原则（LKP） ...
Java面向对象精髓编程
10-18
面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它的核心思想是将现实世界的问题转化为计算机可以理解的模型，即对象。在Java中，对象是类（class）的实例。类定义了对象的属性（fields）和行为...
16丨设计模式基础：不会灵活应用设计模式，你就没有掌握面向对象编程.pdf
07-05
"设计模式基础" 本资源主要讲解了设计模式的基础知识，以及面向对象编程的基本...本资源对面向对象编程和设计模式的基础知识进行了详细的解释和讨论，为读者提供了深入的理解和掌握面向对象编程和设计模式的基础知识。
Java面向对象思想精华——总结
Superclover_的博客
08-27 421
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import
面向对象思想
贝西奇谈
03-07 1418
第一节 面向过程和面向对象思想 1. 面向过程和面向对象的区别   面向过程和面向对象都是对软件分析、设计和开发的一种思想,它指导着人们以不同的 方式去分析、设计和开发软件。早期先有面向过程思想，随着软件规模的扩大，问题复杂性 的提高，面向过程的弊端越来越明显的显示出来，出现了面向对象思想并成为目前主流的方 式。两者都贯穿于软件分析、设计和开发各个阶段，对应面向对象就分别称为面向对象分析 （OOA...
面向对象的思维方法
bon_jovi的专栏
07-08 1255
面向对象的思维方法 作者：范凯 E-mail: robbin_fan@yahoo.com.cn 我是从学习Java编程开始接触OOP(面向对象编程)，刚开始使用Java编写程序的时候感觉很别扭，因为我早以习惯用C来编写程序，很欣赏C的简洁性和高效性，喜欢C简练而表达能力丰富的风格，特别忍受不了Java运行起来慢吞吞的速度，相对冗长的代码，而且一个很简单的事情，要写好多类，一个类调用一个类，心里的抵
反思任务：面向对象的核心思想，三大特性以及面向过程的区别
liuyizhou95的博客
08-29 5907
问题参考：1.面向对象思想及核心—— https://blog.csdn.net/wofangfan/article/details/5925435                   2.第一章 面向对象思想的核心概念——http://www.cnblogs.com/xxlleworld/p/5742809.html                   3.面向对象和面向过程的区别——htt...
面试总结之谈谈你对面向对象的理解
热门推荐
SamHan的博客
09-27 4万+
对面向对象的理解 在我理解,面向对象是向现实世界模型的自然延伸，这是一种“万物皆对象”的编程思想。在现实生活中的任何物体都可以归为一类事物，而每一个个体都是一类事物的实例。面向对象的编程是以对象为中心，以消息为驱动，所以程序=对象+消息。 面向对象有三大特性，封装、继承和多态。 封装就是将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，提高了数据的隐秘性的同时，使代
面向对象的3个基本要素和5个基本设计原则(整理)
雕刻时间的专栏
10-24 975
面向对象的3个基本要素：[color=red][size=large]封装、继承、多态[/size][/color] 面向对象的5个基本设计原则： [color=red][size=large]单一职责原则（Single-Resposibility Principle）[/size][/color] 其核心思想为：[b]一个类，最好只做一件事，只有一个引起它的变化。[/b...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
最新发布
mm
11-11 191
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Java面向对象编程练习：掌握面向对象精髓
资源摘要信息:"在学习Java面向对象编程（Object-Oriented Programming，简称OOP）的过程中，编写练习代码是一个非常重要的环节。面向对象编程是一种编程范式，它以对象为基本单位组织程序结构，使得程序更加模块化和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

有梦想的小何

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值