深入理解面向过程和面向对象编程思想

张 楠

面向过程和面向对象这是两种编程思路。

面向过程中函数是一等公民，面向对象中对象是一等公民，且看解释。

以造车为例：

面向过程大致是如下思路：

1、造一个发动机

2、造四个车轮子

...

3、组装起来

/**
 * @author zn
 * @date 2020/1/30
 */

public class BuildCar {

    public static void main(String[] args) {

        String engine;
        String[] wheels;

        //1.创建发动机
        engine = buildEngine();
        //2.创建轮子
        wheels = buildWheels();
        //3.组装汽车
        boolean flag = buildCar(engine,wheels);
        //4，查看汽车是否组装成功
        if (flag){
            System.out.println("汽车组装成功，可以上路了！");
        }else{
            System.out.println("汽车缺少零件，未组装成功！");
        }
    }


    //组装汽车
    private static boolean buildCar(String engine, String[] wheels) {
        //组装汽车时进行判断，如果没有发动机，没有轮子，或者轮子数量不够，就组装失败
        if (engine.equals("") || wheels == null || wheels.length < 4){
            return false;
        }
        System.out.println("开始安装【" + engine +"】");
        for (String wheel : wheels) {
            System.out.println("开始安装【" + wheel + "】");
        }
        return true;
    }

    //创建发动机
    private static String buildEngine() {
        //省略创建的过程
        return "地球梦自然吸气发动机";
    }

    //创建轮子
    private static String[] buildWheels() {
        String[] wheels = new String[4];
        wheels[0] = "左前轮";
        wheels[1] = "右前轮";
        wheels[2] = "左后轮";
        wheels[3] = "右后轮";
        return wheels;
    }
}

  通过例子来看，在面向对象的编程当中，都是一直在调用方法，在面向过程编程中一般称为函数，每个函数封装一些功能，做事情都是按序就班一步一步来。这里都是直接调用函数，所以函数是一等公民，也就是就是函数最重要的组成部分。

  我们在没有学习面向对象之前所写的欣知人资管理和英雄者游戏就是使用面向过程写的，典型的面向过程语言就是c语言。

面向对象大致是如下思路：

  相比于面向过程，面向对象新增了一个关键字new，这个关键字，如同一个万能的工人一样，能够按照说明书，制造任何东西。

  1、搞一个发动机的说明书（Engine类）

  2、搞一个车轮子的说明书（Wheel类）

  3、搞一个汽车的说明书，首先我们要明白车子一定有，一个发动机，四个轮子，所以我们在如何制造汽车的说明（构造方法）里就去使用new这个万能功能直接造出一个发动机和四个轮子并装在汽车上。那么当我们创建汽车的时候所有的东西就一并创建好了。

  4、直接创建一个汽车，或者让汽车工厂生产一个汽车

/** 发动机的说明书，这种更高级的封装，分装了发动机的一些属性比如品牌名称，还有一些发动机的功能，也叫行为，
  * 也叫方法如发动机要运行。有了这个说明书我们就能使用new关键字，随意创建多个发动机，并且所有的创建出来的   * 发动机都有这些属性和方法。
**/
public class Engine {

    private String name;
    public void run(){
        System.out.println("【" + name + "】引擎发动了！");
    }
    public Engine(String name) {
        this.name = name;
    }
}

//轮子的说明书
public class Wheel {
    private String position;
    public void run(){
        System.out.println("【"+ position +"】开始转动了！");
    }

    public Wheel(String position) {
        this.position = position;
    }
}

//汽车的说明书
public class Car {

    //汽车的品牌
    private String type;
    //汽车肯定有发动机
    private Engine engine;
    //汽车还有几个轮子
    private Wheel wheels[];

    //Car的构造方法，定义了汽车是怎么被构造的，造车时要有发动机和轮子
    public Car(String type) {
        this.type = type;
        this.engine = new Engine("地球梦");
        this.wheels = new Wheel[4];
        this.wheels[0] = new Wheel("左前轮胎");
        this.wheels[1] = new Wheel("右前轮胎");
        this.wheels[2] = new Wheel("左后轮胎");
        this.wheels[3] = new Wheel("右后轮胎");
    }

    //让汽车跑起来的方法
    public void run(){
        System.out.println("----------第一步，启动发动机----------");
        this.engine.run();
        System.out.println("------第二步，发动机带动轮胎转动-------");
        for (Wheel wheel : wheels) {
            wheel.run();
        }
        System.out.println("---【"+ this.type +"】汽车跑起来了---");
    }
}


public class Test {
    public static void main(String[] args) {
        //这里边一般不直接调用方法
        System.out.println("------------------第一辆车-----------------");
        //一般使用new这个万能工匠，去创建一个对象
        Car car = new Car("日产奇骏");
        //我们使用对象去调用方法
        car.run();
        
        System.out.println("------------------第二辆车-----------------");
        Car crv = new Car("本田CRV");
        crv.run();
    }
}

结果：
------------------第一辆车-----------------
----------第一步，启动发动机----------
【地球梦】引擎发动了！
------第二步，发动机带动轮胎转动-------
【左前轮胎】开始转动了！
【右前轮胎】开始转动了！
【左后轮胎】开始转动了！
【右后轮胎】开始转动了！
---【日产奇骏】汽车跑起来了---
------------------第二辆车-----------------
----------第一步，启动发动机----------
【地球梦】引擎发动了！
------第二步，发动机带动轮胎转动-------
【左前轮胎】开始转动了！
【右前轮胎】开始转动了！
【左后轮胎】开始转动了！
【右后轮胎】开始转动了！
---【本田CRV】汽车跑起来了---

  在面向对象的思想当中，在main方法中，一般不直接调用方法，而是通过new创建很多对象，通过对象去使用方法，这也就解释了为什么对象是一等公民。

面向对象里没有面向过程吗？

  不对，我的理解是，面向对象是封装的也是过程，每一个方法都是封装了一些过程，这不过使用面向对象使我们编程的角度发生了改变，他更加适合完成一些大型的复制项目。

比如拿我们的英雄者游戏举例：

这里一定要重理解，重感受，闭着眼睛想，怎么写慢慢来。

我们脱离了面向过程，使用面向对象我们应该怎么写？

大致是：

定义一个英雄类，他有属性比如名字，血量等，他还有方法，比如走路，攻击，技能等能

再定义一个boss类，他依然有属性，有方法。

最后在main方法里，我们只需要new几个英雄，new几个boss让他们打架就行了。

注：在面向对象中我们一般不叫函数，这里的区别在于，方法是有所属的，他是属于某个对象的方法，而函数是独立的，他不属于任何其他的东西。