JAVA面向对象和面向过程有什么区别?一个栗子告诉你

╰半夏微凉° 2023-10-08 21:24 22阅读 0赞

![a2eb661e53dda72e5e062da0cd425a83.jpeg][]

## **一. 面向对象** ##

### 1. **概念** ###

可以说，在面向对象的编程规范中，**“一切皆对象”，对象就是面向对象编程的核心**。我们把现实世界中的一个个对象或物体，抽象地体现在编程世界中。就好比我们想驾驶一辆奥迪A6，A6就是一个对象，制造商给A6赋予了各种功能和特性，我们就可以调用这个对象完成一系列操控。所以每一个对象都可以包含一系列具体的操作，最终一个个的对象又组成了完整的Java程序。这些对象可以是独立存在的，也可以是从别的对象中继承过来的。对象之间通过相互作用传递信息，实现程序开发。

给大家举个栗子，按照面向对象的解决思维就是：

1. 创造一个“餐厅”对象，去做饭；

2. 创造一个“人”对象，去吃饭；

### 2. **特点** ###

**在面向对象编程中，一个对象会有以下特点：**

> ● 对象具有属性和行为；  
> ● 对象具有变化的状态；  
> ● 对象具有唯一性；  
> ● 对象都是某个类的实例；  
> ● 一切皆对象，真实世界中所有的事物都可以视为对象。

当然，如果只是这样跟大家解释一通，很多小白肯定还是不明白到底啥是面向对象。

别急，面向对象是一种认知思维，一种思维的养成，并不是一朝一夕就可以形成的。有些科班出身的Java程序员，在学校里接触了很久的面向对象，甚至都做了几年的开发，真让他解释啥是面向对象，他依然很懵懂。**我们要想真正地理解面向对象，只看几篇文章和视频是很难吃透的。你需要进行大量的编程实践，写着写着，有一天你就会突然顿悟：“啊，原来这就是面向对象啊”！**

![3e8b8f3659be92afc2c27f32ad390e39.jpeg][]

## **二. 面向过程** ##

### 1. **概念** ###

面向过程的编程思想其实很机械粗暴，**所有的事情都可以拆分成一系列要执行的计算步骤，通常采用自上而下、顺序执行的方式来实现。**还是给大家举吃饭的栗子，如果是按照面向过程的解决思维就是：

> 1. 到餐厅；  
> 2. 点菜；  
> 3. 点餐具；  
> 4. 打印菜品明细；  
> 5. 打印餐具明细；  
> 6. 后厨根据菜品明细开始做饭；  
> 7. .......

**你看，整个执行逻辑就是这么机械粗暴，简单明了。面向过程就是把目标的实现拆分成了一个个的实现过程，而每一步又可以继续拆分成若干个子步骤。这种解决问题的思维，与面向对象是有明显不同的。**

### 2. **特点** ###

根据以上分析，我们可以感受到**面向过程的优点在于：性能上它比面向对象要高**

因为在面向对象中，我们在调用类时需要进行实例化，开销比较大。但面向过程的**缺点也很明显**，**代码不易维护、复用和扩展性都很差，开发效率较低**

所以面向过程的开发技术，主要是用在单片机、嵌入式开发、Linux/Unix等对性能要求较高，代码改动不频繁的场景中。

## **三. 面向对象和面向过程的区别** ##

接下来我们就按照上述描述的：“去吃饭”的栗子来给大家直观的看看面向对象和面向过程的区别是什么吧！

### 1. **面向对象** ###

// 创建一个人类
    class Person {
        private String name; // 人名
        private int age; // 年龄
        private String gender; // 性别
    
        // 构造函数
        public Person(String name, int age, String gender) {
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
    
        // getter方法
        public String getName() {
            return name;
        }
    
        public int getAge() {
            return age;
        }
    
        public String getGender() {
            return gender;
        }
    
        // 吃饭方法
        public void eat() {
            System.out.println(name + "正在吃饭");
        }
    }
    
    // 创建一个餐厅类
    class Restaurant {
        private String name; // 餐厅名
        private String address; // 地址
    
        // 构造函数
        public Restaurant(String name, String address) {
            this.name = name;
            this.address = address;
        }
    
        // getter方法
        public String getName() {
            return name;
        }
    
        public String getAddress() {
            return address;
        }
    
        // 提供餐食的方法
        public void provideFood() {
            System.out.println("提供美食，欢迎光临！");
        }
    }
    
    // 创建一个主函数类
    public class goToDinner {
        public static void main(String[] args) {
            // 创建一个人对象
            Person person = new Person("张三", 25, "男");
            System.out.println(person.getName() + "今年" + person.getAge() + "岁，是个成年" + person.getGender() + "人");
    
            // 创建一个餐厅对象
            Restaurant restaurant = new Restaurant("饕餮大酒楼", "上海市黄浦区南京东路");
            System.out.println("欢迎来到" + restaurant.getName() + "，地址：" + restaurant.getAddress());
    
            // 人在餐厅吃饭
            person.eat();
            restaurant.provideFood();
        }
    }

**在这个栗子中：**

首先我们通过创建Person类（定义了吃饭的方法eat()）和Restaurant类（定义了提供餐食的方法provideFood()），将人和餐厅抽象为对象，并在goToDinner类中通过实例化对象，模拟了一个人在餐厅吃饭的场景。

先不着急分析，我们继续向下看

### 2. **面向过程** ###

import java.util.Scanner;
    
    public class GoToEat {
        public static void main(String[] args) {
            Scanner input = new Scanner(System.in);
            
            // 输出欢迎信息
            System.out.println("欢迎来到餐厅！");
            
            // 获取用户输入
            System.out.print("请输入您要点的菜品：");
            String dish = input.nextLine();
            
            System.out.print("请输入您需要的餐具（筷子/勺子）：");
            String utensils = input.nextLine();
            
            // 打印用户输入
            System.out.println("您点的菜品是：" + dish);
            System.out.println("您需要的餐具是：" + utensils);
            
            // 做饭
            cook(dish);
            
            // 洗碗
            wash(utensils);
            
            // 输出结束信息
            System.out.println("餐点准备好了，开始用餐吧！");
        }
        
        // 做饭
        public static void cook(String dish) {
            System.out.println("开始做" + dish + "...");
            System.out.println("做好了！");
        }
        
        // 洗碗
        public static void wash(String utensils) {
            System.out.println("开始洗" + utensils + "...");
            System.out.println("洗好了！");
        }
    }

**在上述这个栗子中：**

首先输出欢迎来到餐厅的欢迎信息，然后需要获取用户输入的菜品和餐具信息，打印出来之后，调用cook()方法来做饭和调用wash()方法来洗碗，最后输出一切准备结束的信息："餐点准备好了，开始用餐吧！"表示可以用餐了，整个执行过程就非常的流程化。

**通过对比，面向过程的编程它的特点就是：**

强调程序执行的顺序和流程，不过面向过程编程最大的优点就是代码确实非常简单易懂，非常适合解决小规模的问题，但是他的缺点就是难以应对一些复杂的问题，代码的可读性差，不易维护和扩展。

相比较之下，面向对象编程更强调的是面向对象的设计，所有的事情都让指定的对象去做，通过定义类和对象，将问题分解成更小的问题，并通过将对象之间的交互解决问题。就像上述的面向对象编程中它人和餐厅抽象为对象，将去吃饭的问题看作是由对象组成的。

同时我们也发现面向对象的编程就是将复杂的问题抽象成简单的类，从而降低了程序的复杂程度，也提高了代码的可读性和可维护性，但是面向对象编程通常需要大量的类和对象来实现程序功能，这会导致代码的复杂度增加，从而降低代码的可读性和可维护性。

## **四. 总结** ##

**最后给大家做一下梳理吧：**

面向过程的优点和缺点是什么？

**1. 优点：**

> ● 特别易于理解和学习，面向过程编程非常直观和简单，因为它模拟了现实世界中的过程和操作。初学者可以很容易地理解和学习这种编程方式。  
> ● 面向过程编程的代码非常简单易懂，代码的结构相对简单，没有复杂的层次结构，因此易于阅读和理解。

**2. 缺点：**

> ● 面向过程编程缺乏高层次的抽象，因此当需要增加新的功能时，代码往往需要被完全重构。  
> ● 面向过程编程难以处理大规模项目，因为代码的结构很难管理和维护。此外，面向过程编程不利于代码复用和模块化，这使得大规模项目的开发更加困难。

**面向对象的优点和缺点是什么？**

**1. 优点：**

> ● 面向对象编程可以将复杂的问题抽象成简单的类，从而降低程序的复杂度，提高代码的可读性和可维护性。  
> ● 继承和多态是面向对象编程的两个重要特性。继承可以让子类继承父类的属性和方法，从而减少代码的重复性；多态则可以让不同的对象对同一消息作出不同的响应，提高了程序的灵活性和可扩展性。  
> ● 面向对象编程将数据和方法封装在类中，只对外部提供必要的接口，从而增强了程序的安全性和稳定性。

**2. 缺点：**

> ● 面向对象编程通常需要大量的类和对象来实现程序的功能，这会导致代码复杂度的增加，降低代码的可读性和可维护性。  
> ● 面向对象编程需要频繁地创建和销毁对象，这会导致一定的性能损失。  
> ● 面向对象编程需要掌握一定的面向对象思想和编程技巧，需要一定的学习成本。

**面向对象和面向过程的区别是什么？**

**1. 面向过程编程是一种基于程序和函数的编程范式**，它强调程序的执行顺序和数据的处理过程，通过将程序分解成一系列函数来完成任务。在面向过程编程中，数据和函数是分开的，数据被看作是被函数处理的对象。因此，面向过程编程更加注重解决问题的过程，而不是问题的对象。

**2. 面向对象编程是一种以对象为中心的编程范式**，它将数据和函数作为一个整体来处理，这些数据和函数被封装在一个对象中，通过对象之间的交互来完成任务。在面向对象编程中，对象被看作是问题的解决方案，因此，面向对象编程更加注重问题的对象，而不是解决问题的过程。

**3. 面向对象编程中有三个基本概念：封装、继承、多态。**

● 封装是指将数据和函数组合在一起形成一个对象，并将其隐藏在对象内部，只提供公共接口给外部使用。[JAVA面向对象三大特征之--封装][JAVA_--]（点击蓝字即可查看封装讲解）

● 继承是指从一个已有的类中派生出一个新类，新类可以使用已有类的属性和方法，同时也可以添加自己的属性和方法。[JAVA面向对象的三大特征--继承，干货详解][JAVA_-- 1]（点击蓝字即可查看继承讲解）

● 多态是指不同对象对同一消息做出不同的响应，即同一方法可以在不同的对象中具有不同的行为。

**总而言之，面向过程编程更加注重程序的执行过程，而面向对象编程更加注重的是对象和对象之间的交互。**

[a2eb661e53dda72e5e062da0cd425a83.jpeg]: https://img-blog.csdnimg.cn/img_convert/a2eb661e53dda72e5e062da0cd425a83.jpeg
[3e8b8f3659be92afc2c27f32ad390e39.jpeg]: https://img-blog.csdnimg.cn/img_convert/3e8b8f3659be92afc2c27f32ad390e39.jpeg
[JAVA_--]: https://qfdeu.blog.csdn.net/article/details/129491419
[JAVA_-- 1]: https://qfdeu.blog.csdn.net/article/details/129554032