面向对象知识点总结

面向对象知识点总结

 

面向对象与面向过程有什么区别？

答：面向过程：强调的是每一个功能实现的具体步骤。

面向对象：基于面向过程，强调的是对象，然后由对象去调用功能。

举例：洗衣服

面向过程：把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来

面向对象：把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来

 

（毕向东）面向对象其实是一种思考问题的思想，早期的思想是面向过程，通过不断的演化，到了现在的面向对象。

我们举一个例子，把什么是面向过程，什么是面向对象说一下：

把大象放进冰箱里，分几步？三步！

第一步：把冰箱门打开。

第二步：把大象放里面去。

第三步：把冰箱门关上。

注意：我们把冰箱门打开，把大象放进去，把冰箱门关上，我们在强调什么？我们在强调过程。打开的动作，存储的动作，关闭的动作。这就是一个标准的面向过程的思想，我们注重的是过程，注重的是过程当中所涉及到的行为，也就是功能。打开功能，存储功能和关闭功能。过程强调的是行为、动作或者功能。

那么将它转换成面向对象又是什么样的呢？

大家分析一下，我们发现，无论是打开、存储还是关闭。它们都是冰箱这类事物所具备的行为，因为你操作的始终都是冰箱。这个时候就把这个思想给转变了。既然打开、存储和关闭都是冰箱的一个行为，我们只要操作冰箱中所具备的功能就可以的话，我们就把这些行为全部定义到冰箱当中，那么冰箱是不是一个实实在在存在的东西啊？这个我们把它称之为对象。而现在我再看到的东西就不是打开、存储和关闭了。我看到的就只有一个事物，就是冰箱。而冰箱里面有打开、存储和关闭的动作。

来画个图看一下：

 

总结：

面向对象到底是什么呢？

第一  面向对象是一种思考问题的方式，是一种思想。

第二  面向对象将复杂的事情变简单了。面向过程需要面向好多的动作，而面向对象只需要   

      面向一个事物就可以了。

第三  面向对象让我们的角色做了转变，从原来的执行者过渡到了指挥者。

第四  面向对象基于面向过程。

 

面向对象（生活举例）

例1：

你去电脑城买电脑，买电脑的时候，按照一般正常的思路是这样的：无论是买笔记本还是台式机，首先我们要去查阅一下资料，比如说CPU的型号、缓存、参数、硬盘、显卡、内存等等，还要查一下价格，为什么查啊？是怕被人骗！前期，你就做了一个查阅资料的动作。查完之后，你去电脑城，然后挨个商家去问价格啊，硬件啊等等，你就做了一个咨询的动作。最后买的时候，你还要砍价，还没砍过人家，最后还被骗了！你做了这么多准备工作，为什么还会被骗呢？就是因为你不懂！就靠花两天查阅了一下资料，就懂了？那不太现实！那么在你不懂的情况下，你为了不上当受骗，你该怎么做呢？找个懂行的！假如我特别懂电脑，我跟着你去，那么，咨询，砍价，监督装机这些动作是不是都是我来完成，而你只需要做的就是付钱。

咱们来看看，刚开始你去买电脑，你很痛苦，因为你要走整个过程，而这个过程你不熟。而后期你为了避免一些麻烦，你找了懂行的我，那你是不是使用了我的专业识别硬件的功能，专业砍价的功能，你为什么要找我啊？是因为我具备这些功能，这就叫找对人了！而我对于你来讲，我就是那对象，你就是在面向我这个对象。

那么，第一，你买电脑这件事是不是从复杂变得简单了？第二，你是不是从执行者变成指挥者了？你只要指挥我的专业识别硬件的功能，指挥我的专业砍价的功能就可以了！

例2：

一个老板，接了一个活，一个300万的软件开发的项目，但是呢？这位老板本身并不具备软件开发的能力，他要怎么做呢？他可不可以自己做？现学？可以，因为项目就是人做出来的嘛！于是乎，这个老板现学软件开发，终于，5年时间，他把那个项目做出来了，可事实是那个给钱的公司早就黄了！这是不是不靠谱啊？那这个老板该怎么做？他聘请了一批程序员，说这有个项目，你们给我做出来，程序员是不是专业啊？那这没那个老板什么事了，他就去喝茶，玩去了！对这个老板来说，开发软件这个事情是不是从复杂变得简单了？他是不是从一个执行者转换成了指挥者？这写专业程序员对老板来说就是对象，老板面向这些对象，调用这些对象本身具有的功能来实现了自己的目的！这就是面向对象！

例3：（面试的时候用）

什么是面向对象？

面向对象是一种思考问题的方式，是一种思想；面向对象能让复杂的问题简单化；面向对象让我们的角色做了转变，从原来的执行者过渡到了指挥者；面向对象基于面向过程。面向对象有三大特征：封装、继承、多态。举个具体的例子：

其实，面试官，你现在就是用面向对象的思想思考问题，公司有招人的需求，是因为公司的业务量比较大，代表着公司正在蒸蒸日上的发展。你在用面向对象的思想在思考问题，你需要找一些有专业编程经验的人来帮你完成公司的工作，而我就是那个对象，我就具备那个专业编程的功能，你找我就对了！你就是在指挥我做事情，你就是在使用我的专业编程功能为公司创造价值。当然，我不仅具备专业编程的功能这个基本的需求，我还具备比如说表达能力啊，管理能力等功能，你日后还可以让我当个小组长什么的，这完全没有问题！

 

面向对象的基本思想，给大家举这几个基本的例子解释一下！

注意：对象不仅仅指人，万事万物皆对象！这就是说你所看到的，你所想到的概念都可以看作是一个对象！

那么，落实到程序上是怎么样的呢？

我们写程序的时候，我们其实不是先要定义功能，而是先要面向对象。我要面向谁啊？我要面向这个对象，这个对象里面需要什么功能，我就把功能写到这个对象里面去，封装起来。下次我要用到这个功能的时候，我先去找这个对象，对象一找到，功能就找到了。在解决问题的时候，你们要做的是，不是先自己写，而是去找java当中是不是已经提供好了相对应的对象？如果有，不多说，直接拿过来用，这样是不是就简单化了？它里面的功能是怎么实现的，和我没关系，我只要拿到相对应的需求结果就行了！如果java当中没有我们需要的对象的话，那我们就自己造一个对象，把功能定义到里面去。因为你造完之后，这个对象，你能用，别人是不是也能用？就是这个道理！

 

面向对象有哪些特征？

答：封装、继承、多态。

 

什么是继承？

答：继承是面向对象中的一个非常重要的特性。通过继承，子类可以使用父类中的一些成员变量与方法，从而能够提高代码的复用性，提高开发效率。在Java语言中，被继承的类叫基类或父类，继承基类或父类的类叫派生类或子类。继承是通过extends关键字来实现的，使用格式为：class 子类名 extends 父类名。

继承主要有如下几个特性：

1）Java语言不支持多重继承，也就是说，子类至多只能有一个父类，但是可以通过实现多个接口来达到多重继承的目的。

2）子类只能继承父类的非私有（public与protected）成员变量与方法。

3）当子类中定义的成员变量和父类中定义的成员变量同名时，子类中的成员变量会覆盖父类的成员变量，而不会继承。

4）当子类中的方法与父类中的方法有相同的函数签名（相同的方法名，相同的参数个数与类型）时，子类将会覆盖父类的方法，而不会继承。

 

常见笔试题：

下列有关继承的说法中，正确的是（B）

A.子类能继承父类的所有方法和状态         B.子类能继承父类的非私有方法和状态

C.子类只能继承父类public方法和状态       D.子类能继承父类的方法，而不是状态

 

什么是多态？

答：多态性在面向对象中是一个非常重要的概念，在Java中主要有以下两种体现形式：

（1）方法的重载和重写。方法的重载又叫编译时多态，方法的重写又叫运行时多态。这时的多态表示当同一操作作用在不同对象时，会有不同的语义，从而会产生不同的结果，例如，同样是执行“+”操作，“3+4”用来实现整数相加，而“3”+“4”却实现了字符串的连接。

 

（2）对象的多态性。同一个对象(事物)，在不同时刻体现出来的不同状态。

向上转型（子类对象→父类对象）

向下转型（父类对象→子类对象）。

对于向上转型，程序会自动完成，而对于向下转型时，必须明确地指明要转型的子类类型。

 

方法重写和方法重载的区别?方法重载能改变返回值类型吗?

方法重写：在子类中，出现和父类中一模一样的方法声明的现象。

方法重载：同一个类中，出现的方法名相同，参数列表不同的现象。

方法重载能改变返回值类型，因为它和返回值类型无关。

Override：方法重写

Overload：方法重载

 

抽象类和接口的区别？

答：

接口的关键字是interface；抽象类的关键字是abstract。

接口中的方法全是抽象方法，没有实现；抽象类中的方法可以有部分非抽象方法。

接口需要被实现（用implements），一个类可以实现多个接口；抽象类只能被继承（用extends），一个类只能继承一个抽象类。

接口中定义的成员变量默认为public static final，其所有方法都是public、abstract的；抽象类中定义的成员变量默认为default，当然也可以被定义为private、protected和public，抽象类中的抽象方法（其前有abstract修饰）不能用private、static、sychronized、native等访问修饰符修饰。

 

常见笔试题：

1. 下列关于接口的定义中，正确的是（）

A.void methoda();  B.public double methoda()

C.public final double methoda()   D.static void methoda(double d1);

E.protected void methoda(double d1)   F.int a

G.int b=1

答案：A、B、G。接口中的方法只能用关键字public和abstract来修饰，因此CDE都是错误的。接口中的属性默认都为public static final，由于属性被final修饰，因此它是常量，常量在定义时就必须初始化，因此F是错误的。

 

2. 下列说法中，正确的是（B）

A.声明抽象方法大括号可有可无  B.声明抽象方法不可写出大括号

C.抽象方法有方法体   D.abstract可修饰属性、方法和类

 

答案：B。抽象方法不能有方法体，同理也就不能有大括号。abstract只能用来修饰类与方法，不能用来修饰属性。

 

如何获取父类的类名？

答：this.getClass().getSuperclass().getName()。

 

注意：this.getClass().getName()和super.getClass().getName()获取到的是当前运行时类的名称。

为什么？

因为Java语言总任何类都继承自Object类，getClass()方法在Object类中被定义为final与native，子类不能覆盖该方法。因此this.getClass和super.getClass()最终都调用的是Object中的getClass()方法。而Object的getClass()方法的释义是：返回此Object的运行时类。

 

this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

this:代表当前类的对象引用

super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)

场景：

成员变量：

this.成员变量

super.成员变量

构造方法：

this(...)

super(...)

成员方法：

this.成员方法

super.成员方法

 

 

常见笔试题：

class Base{

public Base(){

System.out.println("Base");

}

}

 

class Sub extends Base{

public Sub(){

System.out.println("Sub");

super();

}

}

 

public class Test{

public static void main(String[] args){

Base s = new Sub();

}

}

答案：编译错误。当子类构造函数需要显示调用父类构造函数时，super()必须为构造函数中的第一条语句，因此正确的写法如下：

public Sub(){

    super();

System.out.println("Sub");

}

                                                        

this指向

---

今天就和大家来探讨一下在js面向对象中的这个this的指向问题，

一般来讲在函数中this的指向是当前函数的拥有者，也就是说当前谁这个函数，那么这个this就指向谁.

例：这里有一按钮 btn

<input type ="button" id ="btn">

document.getElementById('btn').onclick = function(){

       alert(this)//input

}

此时this是指向按钮 btn

第一种情况：

在面向对象中用了定时器

这里有一个对象；

function fn(){

    this.a= 1;//fn中的一个属性

}

fn.prototype.show = function(){

   alert(this.a)//fn原型链上的一个方法

}

var obj = new fn();//实例化的时候

obj.show();//执行以下show()方法,弹出值为1

现在我们给这个对象加一个定时器看会怎么样

function fn(){

this.a= 1;//fn中的一个属性

    setInterval(this.show,1000)//定时器

}

fn.prototype.show = function(){

    alert(this.a)//fn原型链上的一个方法 弹出a的值

}

var obj = new fn();//实例化

这个时候函数在执行的时候 弹出值为undefined

为什么那？

现在我们来看一下这个this 是指向谁的

function fn(){

     this.a= 1;//fn中的一个属性

      setInterval(this.show,1000)//定时器 弹出值是window

}

fn.prototype.show = function(){

      alert(this)

}

var obj = new fn();//实例化

原因就是定时器调用的函数都是指向`window`,所以我们这里弹出的都是`undefined` 因为window上没有`show()`这个方法；

现在原因找到了怎么解决那，其实很简单；

我们不要改变他的所属关系就好，就像这样：

function fn(){

    var _this = this //将我们原来的this赋给_this

    this.a= 1;//fn中的一个属性

   //将原来的方法包一下目的就是不改变他们的所属关系

  setInterval(function(){

       _this.show();

   },1000)//定时器

}

fn.prototype.show = function(){

    alert(this.a)//fn原型链上的一个方法  弹出的就是：1

    //因为上面我们已经将this赋给_this了,所以此时this的指向就不在是window了,而是指向了obj

}

var obj = new fn();//实例化

好~~第一种情况我们已经接解决了，下面我们来看第二种情况，，，

第二种情况：

面向对象添加了事件的，

例：这里有一个按钮

<input id="btn" type="button" value="按钮"/>

function fn(){

      this.a = 1;

      document.getElmentById('btn').onclick = this.show;

   //弹出值为undefined 此时的this指向是input，而input是没有    show()方法，所以undefined

}

fn.prototype.show = function(){

    alert(this.a)

}

new fn()

怎么解决那？

方法和含有定时器的一样都是在原来的方法外面在套一层 并未把this重新附一下值；

function fn(){

   var _this = this

   this.a = 1;

   document.getElmentById('btn').onclick = function(){

       _this.show();//弹出值为1

   }

}

fn.prototype.show = function(){

   alert(this.a)

}

new fn()

其实这两种情况的解决方式都用到了闭包,

将函数外面的this给存一下，然后通过闭包传递this

function fn(){

    var _this = this //存一下this

    this.a= 1;

    setInterval(function(){

        _this.show();//里面调用  

 },1000)