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

面向对象编程?你说的是看着女朋友进行编程吗?注释:没有对象怎办? 前几天网上看到一个有趣的面试问题: 农场有头大母牛,每年生头小母牛,小母牛五年后生小母牛

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

注释:没有对象怎办?

 

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

农场有头大母牛,每年生头小母牛,小母牛五年后生小母牛,年龄大于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经典开发书籍,发送【面试】领取最新面试资料攻略!