一，前言
小编学习在java的时候，对于面向对象和对象过程，只知道面向对象有四大特性（封装，继承，抽象，多态），也有三大特性的说明，小编更倾向于四个。懂得并不是很多。经过两年工作经验对这方面又有点新收获。写出来分享一些，大佬路过希望能够多多指正问题，以便纠正。
二，面向对象
2.1 面向对象、设计原则、设计模式、编程规范和代码重构五者的关系
面向对象具有（封装，继承，抽象，多态），可以实现复杂的业务拆分（以人的角度），更可以编写出复杂的设计思路，也是很多设计原则，设计模式的实现基础。
设计原则是指导我们代码设计的一些经验总结，对于具体场景具体分析具有指导意义，比如开闭原则是（策略模式，模板模式）的指导原则。
设计模式是针对软件开发中经常遇到的一些设计问题，总结出来的一套解决方案或者是设计思路。
编程规范主要解决的是代码的可读性问题，编码规范相对于设计原则，设计模式，更加具体，更加偏重代码细节，更加能落地。持续的小重构依赖的理论基础主要就是编程规范。
代码重构作为保持代码质量不下降的有效手段，利用的就是面向对象、设计原则、设计模式式、编码规范这些理论
2.2 什么是面向对象编程与面向对象编程语言
面向对象编程OOP(Object Oriented Programming)，是一种编程风格或者编程范式。它最小基本单元以类或者对象作为组织代码的基本单元，并将其封装，抽象，继承，多态四个特性，作为代码设计和实现的基石。
面向对象编程语言OOPL(Object Oriented Programming Language)是支持类或对象的语法机制，并有现成的语法机制，能方便地实现面向对象编程四大特性的编程语言。
2.3 面向对象四大特性分别解决了什么问题
2.3.1 封装
2.3.2 关于抽象
2.3.3 关于继承特性
2.3.4 关于多态特性
2.4 面向对象与面向过程相比，有哪些优势
面向过程编程它是以计算机角度进行拆分业务的，通俗一点就是在拆分业务时都是以从上到下（面条式执行方式）进行拆分任务，通过一定的顺序进行步骤来拆分解决问题，这种过程的编程方式需要强制性按照一定的顺序执行一系列步骤来解决问题（从上到下，面条式执行）。（面向对象编程是可以以人的思维逻辑进行拆分。之所以能够从人的角度进行拆分是因为面向对象有四大特性支撑着，为我们提供这样的解析思路。并且面向对象的四大特性还可以提高代码的组织性。而不再是单一的从上到下）
缺点：面向过程编程随着代码业务量上涨时，代码可能变得难以维护和扩展。函数之间的依赖关系可能变得复杂，代码可读性可能下降。
优点：编写小脚本更快，省去了面相对象的开销。
图书管理服务案例：面向对象编程风格 VS 面向过程编程风格
（C语言）
#include <stdio.h>
#include <string.h>
#define MAX_BOOKS 100
typedef struct
{
int id;
char title[50];
char author[30];
} Book;
Book books[MAX_BOOKS];
int num_books = 0;
void add_book(Book book)
{
if (num_books == MAX_BOOKS)
{
printf("图书容量已满!\n");
return;
}
books[num_books++] = book;
printf("书籍新增成功!\n");
}
void update_book(int id, Book new_book)
{
int i;
for (i = 0; i < num_books; i++)
{
if (books[i].id == id)
{
books[i] = new_book;
printf("书籍修改成功!\n");
return;
}
}
printf("书籍修改失败!\n");
}
void delete_book(int id)
{
int i;
for (i = 0; i < num_books; i++)
{
if (books[i].id == id)
{
memmove(&books[i], &books[i + 1], (num_books - i - 1) * sizeof(Book));
num_books--;
printf("书籍删除成功!\n");
return;
}
}
printf("书籍删除失败!\n");
}
void find_book(int id)
{
int i;
for (i = 0; i < num_books; i++)
{
if (books[i].id == id)
{
printf("查询书籍:\n");
printf("ID: %d\nTitle: %s\nAuthor: %s\n", books[i].id, books[i].title, books[i].author);
return;
}
}
printf("书籍ID为: %d 查询失败!\n", id);
}
void show_book_list()
{
int i;
printf("【书籍列表】\n");
for (i = 0; i < num_books; i++)
{
printf("%d. %s by %s\n", books[i].id, books[i].title, books[i].author);
}
}
int main()
{
add_book((Book){1, "《java 从入门到精通》", "1XX"});
add_book((Book){2, "《JavaScript 从入门到精通》", "2XX"});
show_book_list();
update_book(2, (Book){2, "《MySQL 从入门到精通》", "3xx"});
delete_book(1);
find_book(2);
show_book_list();
return 0;
}（java语言）
package org.toast.codestandards;
/**
* @author toast
* @time 2024/1/10
* @description
*/
public class Book {
/**
* ID
*/
private int id;
/**
* 主题
*/
private String title;
/**
* 作者
*/
private String author;
public Book(int id, String title, String author) {
this.id = id;
this.title = title;
this.author = author;
}
public int getId() {
return id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
@Override
public String toString() {
return "Book{" +
"id=" + id +
", title='" + title + '\'' +
", author='" + author + '\'' +
'}';
}
}
package org.toast.codestandards;
/**
* @author toast
* @time 2024/1/10
* @description
*/
import java.util.ArrayList;
public class BookManager {
private ArrayList<Book> books = new ArrayList<>();
/**
* 新增书籍
* @param book
*/
public void addBook(Book book) {
books.add(book);
System.out.printf("%s 书籍新增成功!\n", book.getTitle());
}
/**
* 修改书籍
* @param id
* @param newBook
*/
public void updateBook(int id, Book newBook) {
for (int i = 0; i < books.size(); i++) {
if (books.get(i).getId() == id) {
books.set(i, newBook);
System.out.printf("%s 书籍修改成功!\n", newBook.getTitle());
return;
}
}
System.out.printf("%s 书籍修改失败!\n", newBook.getTitle());
}
/**
* 删除书籍
* @param id
*/
public void deleteBook(int id) {
for (int i = 0; i < books.size(); i++) {
if (books.get(i).getId() == id) {
books.remove(i);
System.out.printf("书籍ID为: %d 删除成功!\n", id);
return;
}
}
System.out.printf("书籍ID为: %d 删除失败!\n", id);
}
/**
* 查询书籍
* @param id
*/
public void findBook(int id) {
for (int i = 0; i < books.size(); i++) {
if (books.get(i).getId() == id) {
Book book = books.get(i);
System.out.println("【书籍ID为：" + id + "的查询结果】");
System.out.println("ID: " + book.getId());
System.out.println("Title: " + book.getTitle());
System.out.println("Author: " + book.getAuthor());
return;
}
}
System.out.printf("书籍ID为: %d 查询失败!", id);
}
/**
* 展示书籍列表
*/
public void showBookList() {
System.out.println("【书籍列表】");
for (int i = 0; i < books.size(); i++) {
Book book = books.get(i);
System.out.println(book);
}
}
}package org.toast.test.codestandards;
import org.junit.jupiter.api.Test;
import org.toast.codestandards.Book;
import org.toast.codestandards.BookManager;
/**
* @author toast
* @time 2024/1/10
* @description
*/
public class BookTest {
/**
* 【执行结果】
《java 从入门到精通》 书籍新增成功!
《JavaScript 从入门到精通》 书籍新增成功!
【书籍列表】
Book{id=1, title='《java 从入门到精通》', author='1XX'}
Book{id=2, title='《JavaScript 从入门到精通》', author='2xx'}
《MySQL 从入门到精通》 书籍修改成功!
书籍ID为: 1 删除成功!
【书籍ID2查询结果】
ID: 2
Title: 《MySQL 从入门到精通》
Author: 3xx
【书籍列表】
Book{id=2, title='《MySQL 从入门到精通》', author='3xx'}
*/
@Test
public void test() {
BookManager manager = new BookManager();
manager.addBook(new Book(1, "《java 从入门到精通》", "1XX"));
manager.addBook(new Book(2, "《JavaScript 从入门到精通》", "2xx"));
manager.showBookList();
manager.updateBook(2, new Book(2, "《MySQL 从入门到精通》", "3xx"));
manager.deleteBook(1);
manager.findBook(2);
manager.showBookList();
}
}
面向过程编程的实现中，我们自定义了一系列函数来完成与图书相关的操作。每个函数都需要传递参数，并且在函数内部进行计算和处理。虽然这种实现方式非常简单，但它更注重计算机角度，对业务拆分是从计算机的角度进行拆分。
面向对象编程中，我们将图书管理系统的业务逻辑封装在一个BookManager类中，这个类包含了新增，修改，删除，查询，列表显示等方法。这种方式实现更加直观和易于理解，能够更好地组织和管理代码，并提供代码的可读性，可维护性。这种实现方式更注重人的角度。对业务拆分是从人的角度进行拆分。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
