到底什么是面向对象编程？

面向对象编程？你说的是看着女朋友进行编程吗？

注释：没有对象怎办？

 

前几天网上看到一个有趣的面试问题：

农场有头大母牛，每年生头小母牛，小母牛五年后生小母牛，年龄大于15便死亡?，问20年后农场一共有多少头牛？（使用面向对象编程思维解答）

 

这个面试问题让我想到了面向过程与面向对象编程的区别，咱们先简单了解下这两者定义上区别：

• 面向过程 就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
• 面向对象 是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

看了定义，是不是感觉还是没明白这两者之间的区别，（我信你个鬼，糟老头子坏的很）,

那咱们就用图片来作下对比吧：

然后我就写了两套代码来作对比，一套是面向过程编程，一套是面向对象编程。咱们一起来看看这两者这间到底有何区别？

面向过程：

public static void main(String[] args){
        //所有牛的集合
        List<Integer> cowAgeList = new ArrayList<>();
        //添加第一只5岁的大母牛
        cowAgeList.add(5);
        //循环20年
        for(int i=0;i<20;i++){
            int count_new = 0;//当年新生数量
            int count_dead = 0;//当年死亡数量
            //当年新生的集合
            List<Integer> cowChild = new ArrayList<>();
            //遍历当年所有母牛，年龄自增、看看生不生
            for(int index=0;index<cowAgeList.size();index++){
                //新的一年，加一岁
                int age = cowAgeList.get(index) + 1;
                //将新年龄设置回集合中
                cowAgeList.set(index,age);
                //看下这头母牛是否该GameOver了
                if(age>15){
                    count_dead++;
                    continue;
                }
                //试下生只小母牛吧，生不生的出来说不准（看年龄）
                Integer cowNew = produce(age);
                //哎，如果还生出来了，那咱们就挪窝到当年新生牛犊（不是牛肚哈）集合中
                if(cowNew!=null){
                    count_new++;
                    //这里有个小细节，容易出错，我开始就想，直接把新生小母牛放到所有牛集合中不就行了，
                    //为啥非得先放到当年新生小母牛集合中，后面再统一放到所有牛集合中，你先想下这个问题
                    //咱们后面再说为什么需要这么做
                    cowChild.add(cowNew);
                }
            }
            //今年生牛这个过程结束了，然后再把新生小母牛都放到所有牛集合中
            cowAgeList.addAll(cowChild);
            //我们上面说到为什么不直接把新生的小母牛直接放到所有牛集合中
            //因为如果把新新生小母牛直接放到所有牛集合中，
            // 那么当年这个新生的小母牛就会在后面的遍历中再次遍历一次
            //新生的小母牛年龄是0吧，直接放到所有牛集合中，
            // 新生小母牛年龄就也自增了，这不是我们想要的
            System.out.println(String.format("第%d年，出生：%d,死亡：%s",i,count_new,count_dead));
        }

        //使用迭代器移除已经死亡的母牛，剩下的就是20年后所有存活的母牛了
        Iterator<Integer> iterator = cowAgeList.iterator();
        while(iterator.hasNext()){
            if(iterator.next().intValue()>15){
                iterator.remove();
            }
        }
        System.out.println(String.format("20年后农场存活牛的数量为：%d",cowAgeList.size()));
    }

    /**
     * 根据母牛年龄生产小母牛
     * @param age-母牛年龄
     * @return 新生小牛年龄（null表示没有生）
     */
    private static Integer produce(int age){
        if(age>=5 && age<=15){
            return 0;
        }
        return null;
    }

 

面向对象：

牛的对象：

/**
 * 这是头牛
 *
 * @Date: 2019/7/26
 */
public class Cow {
    /**
     * 年龄
     */
    private int age;

    /**
     * 是否活者
     */
    private boolean alive = true;

    public Cow(int age) {
        this.age = age;
    }

    /**
     * 生牛动作
     * 是否能生的出来，得看年龄
     *
     * @return
     */
    public Cow produceCow() {
        if (this.age < 5 || !this.isAlive()) {
            return null;
        }
        return new Cow(0);
    }

    /**
     * 每年长一岁
     */
    public void addAge() {
        this.age += 1;
        //年龄大于15就挂掉
        if (this.age > 15) {
            this.alive = false;
        }
    }

    public boolean isAlive() {
        return alive;
    }
}

 

农场对象：

import java.util.ArrayList;
import java.util.List;

/**
 * 这就是一个农场
 *
 * @Date: 2019/7/26
 */
public class Farm {
    //农场里所有牛的集合
    private List<Cow> cowList = new ArrayList<>();

    public Farm() {
    }

    public List<Cow> getCowList() {
        return cowList;
    }

    public void setCowList(List<Cow> cowList) {
        this.cowList = cowList;
    }
}

 

上帝角色（主宰一切）：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 微信关注[Java知己]，每天更新技术干货
 * 发送「1024」，免费领取 30 本经典编程书籍。
 * 发送「Group」，与 10 万程序员一起进步。
 * 发送「JavaEE实战」，领取《JavaEE实战》系列视频教程。
 * 发送「玩转算法」，领取《玩转算法》系列视频教程。
 */
public class Main {

    /**
     * 这里是上帝角色，控制着一切
     * @param args
     */
    public static void main(String[] args) {
        //实例化农场
        Farm farm = new Farm();
        //实例出来第一头母牛
        Cow cow = new Cow(5);
        //将第一只牛放到农场里面
        farm.getCowList().add(cow);

        for(int year=0;year<20;year++){
            int count_dead = 0;//死亡数量
            List<Cow> cowChilds = new ArrayList<>();
            for(Cow cowTemp:farm.getCowList()){
                cowTemp.addAge();
                Cow child = cowTemp.produceCow();
                if(child!=null){
                    cowChilds.add(child);
                }
                if(!cowTemp.isAlive()){
                    count_dead++;
                }
            }
            farm.getCowList().addAll(cowChilds);
            System.out.println(String.format("第%d年，出生：%d,死亡：%d",year,cowChilds.size(),count_dead));
        }

        //移除已经死亡的牛
        Iterator<Cow> iterator = farm.getCowList().iterator();
        while(iterator.hasNext()){
            if(!iterator.next().isAlive()){
                iterator.remove();
            }
        }
        System.out.println(String.format("20年后农场存活牛的数量为：%d",farm.getCowList().size()));
    }
}

 

下面是运行结果：（两种方式的运行结果是一致的）

第0年，出生：1,死亡：0
第1年，出生：1,死亡：0
第2年，出生：1,死亡：0
第3年，出生：1,死亡：0
第4年，出生：1,死亡：0
第5年，出生：2,死亡：0
第6年，出生：3,死亡：0
第7年，出生：4,死亡：0
第8年，出生：5,死亡：0
第9年，出生：6,死亡：0
第10年，出生：7,死亡：1
第11年，出生：10,死亡：1
第12年，出生：14,死亡：1
第13年，出生：19,死亡：1
第14年，出生：25,死亡：1
第15年，出生：32,死亡：1
第16年，出生：41,死亡：2
第17年，出生：54,死亡：3
第18年，出生：72,死亡：4
第19年，出生：96,死亡：5
20年后农场存活牛的数量为：391

 

咱们通过代码演示，你感觉到这两者的区别了吗？

面向对象编程对于匀我们来说更容易理解业务的逻辑性

就算是自己写的代码，过上一段时间，自己再去看，是不是也是一头雾水，得好好看上一段时间才能理得清楚某块代码的业务逻辑是怎样的

用下面这张图来形容，偶然间看到自己多年前写的代码，我觉得很贴合实际

注释：偶然间看到自己多年前写的代码

结论：面向对象思维可以提升项目的可维护性

最后让我们做下总结：

面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：没有面向对象易维护、易复用、易扩展

 

面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
缺点：性能比面向过程低

 

---

 

正是金九银十跳槽季，为大家收集了2019年最新的面试资料，有文档、有攻略、有视频。有需要的同学可以在公众号【Java知己】，发送【1024】领取30本Java经典开发书籍，发送【面试】领取最新面试资料攻略！

 

转载于:https://www.cnblogs.com/java-friend/p/11541811.html