黑马程序员-面向对象

---------------------- android培训、java培训、期待与您交流！ ----------------------

 

面向对象:

在面向对象出现之前,写程序的是使用面向过程的思想,它强调做一件事从头到尾的过程,显然,这样用这样的思想去思考问题会十分复杂和繁琐. 后来出现的面向对象的思想不用再考虑每一个动作,而是把一个事物应该具有的动作全部封装到事物里面,然后得到这个事物就等于得到这个事物所有的动作了,用这种思想思考问题可以让复杂的事物简单化, 并且让人从操作者变成了指挥者. 举一个简单的例子:做菜

用面向过程的思想考虑:

              做菜所有的过程都要亲力亲为,首先买菜,然后洗菜,切菜,炒菜,每一个过程都是自己在做,自己就是一个操作者.

用面向对象的思想考虑:

              使用一个用做菜功能的对象,请一个保姆. 保姆买菜, 保姆洗菜,保姆切菜, 保姆炒菜,,这里面的过程都不需要自己做,而是自己使用了一个封装了买菜,洗菜,切菜,炒菜等功能的对象,这么一来,做菜这件事对自己来说就显得十分简单了,并且自己的角色从一个操作者变成了一个指挥者.

 

类和对象:

       在使用面向对象的时候,首先要明白什么是类? 什么是对象? 类和对象是什么关系?

类:

类是对一种事物的概述,它描述了这种事物的属性和方法,但是这只是描述,并没有明确到某个事物,比如描述人这一类事物:人有身高,体重,姓名,性别,年龄等; 描述汽车这一类事物:汽车有轮子,发动机 ,方向盘等.这样描述出一类事物,可以大概对这类事物有抽象的概念,这就是类.

对象:

对象是每一类事物的具体的,实实在在的一个个体,比如具体的某一个人,具体的某一辆车等待,对象是把类的属性和方法都具体化了.

类和对象的关系:类是对象抽象出来的共性,是对某一种事物的描述(比如汽车这一类事物);对象是类的具体,是某一类事物中实实在在的个体(比如具体的某一辆汽车).

面向对象有三个重要的特征: 封装 ,继承 ,多态

 

一:     封装

封装:隐藏对象的属性和实现细节,仅对外提供公共访问方式

简单的说,封装就是把不需要让别人知道的东西隐藏起来,再提供一些对外的方法来给别人访问就行了. 比如我们的电脑,电脑的主板是封装在机箱里面的,至于机箱里面的主板是怎么插的,每个零件是什么安装的,外界没有必要知道, 机箱只需要提供几个插口和按钮给外界使用就行了.这就是封装.

封装的好处:1.将变化隔离   2.便于使用   3.提高重用性   4.提高安全性

封装原则:1.把不需要对外提供的内容隐藏起来

               2.把属性都隐藏,提供公共方法对其访问

 

构造函数:

特点:1.函数名与类名相同   2.不需要返回值类型          3.不能写return语句

作用:给对象进行初始化

注意:1.对象只要已建立,就会调用其构造函数,并且构造函数只运行一次

       2.如果没有定义一个类的构造函数,系统会自动添加一个空参数的构造函数,如果自己定义了构造函数,系统就不再添加空的构造函数

 

格式:   类名(参数1,…)

              {

}

什么时候定义构造函数?

当分析事物时,该事物存在一些特性或者行为,那么这些内容定义在构造函数中

 

       构造代码块:

作用:给对象初始化,对象一建立就运行,而且优先于构造函数运行

和构造函数的区别:

构造代码快是给所有对象进行统一的初始化,而构造函数是个对应的对象初始化

构造代码块中定义的是不同对象共性的初始化内容

格式:     在类与方法之间  直接       {  内容 }

 

       This:

this关键字是用于区分局部变量和成员变量的同名情况,哪个对象引用带有this的方法,this就代表这个对象的引用,其实所有对象调用是都有this,只是如果局部变量和成员变量没有同名的时候,this可以省略. 调用构造函数不能像常规函数一样调用,调用方法是this(参数)

this调用构造函数的语句要放在构造函数的第一行,因为初始化动作要执行

 

Static:

用法:是一个修饰符,用于修饰成员变量或成员函数,静态修饰的内容被对象共享,当成员被静态修饰后,就多了一个调用方式,除了可以被对象调外,还可以直接被类名调用,格式是:类名.静态成员

当一个属性或方法被静态修饰后,它就从堆内存中取出来,放进方法区,方法区里面放的都是共享内容

 

特点:1.随着类的加载而加载,随着类的消失而消失,它的生命周期最长

       2.优先于对象存在

       3.被所有对象共享

       4.可以直接被类名调用

实例变量和类变量的区别:

1.       存放位置:类变量随着类的加载而存在于方法区中;

实例变量随着对象的加载而存在与堆内存中.

2.       生命周期:类变量生命周期最长,随着类的消失而消失;

实例变量随着对象的消失而消失.

 

注意:

1.       静态方法不能访问非静态方法,因为静态方法定义时,还没有对象,所以没有非静态方法

2.       静态方法中不可以定义this

 

静态的利弊:

       利:对对象的共享数据进行单独空间的存储,节省空间;可以直接被类名调用

弊:生命周期太长,访问有局限性.

 

二:继承

继承是面向对象的另一个特征. 让A类继承B类,那么A类就拥有了B类所有的非私有方法,比如:猫是哺乳动物,猫继承自哺乳动物,所以猫具有哺乳动物的特性.

继承的特点:1.提高代码的复用性

       2.让类和类之间产生关系,有了关系,才有多态的特性

被继承的类叫父类,需要继承的类叫子类,比如人是父类,学生是子类

 

继承格式:

Class 子类名 extends 父类名

{

}

 

Java语言中,只支持单继承,不支持多继承,因为多继承容易带来安全隐患:当父类中定义了相同功能,但是功能内容不同,此时子类不知道运行哪一个.

也就是说一个子类不能继承多个父类,但是java支持多层继承

 

如何使用一个继承体系的功能:

1.       先查阅体系父类的描述,因为父类定义了该体系的共性功能,通过了解这些共性功能就可以知道该体系的基本功能

 

在具体使用时,要创建最子类的对象,因为:

1.有可能父类不能创建对象

2.创建子类对象,可以即使用子父类的功能.又使用子类的功能

简单一句话,查阅父类功能,创建子类对象使用功能

 

子父类出现后,成员变量的特点:

   如果子类中的成员变量和父类中的成员变量同名,要访问父类的成员变量要super.变量名

Super代表父类对象的引用

 

子父类中的函数的特点:

 

 当子类出现和父类一样的函数时,调用此函数时,执行子类函数的内容,如同把父类的函数覆盖了,这是函数的一种新特性,叫做重写(覆盖)

 

当子类继承父类,子类具备父类的功能,但是功能的内容不同,这时没有必要定义新功能,只需要使用覆盖,保留父类的功能,并重写功能内容

 

注意:

1.       需要覆盖时,子类中函数的权限要>=父类的函数权限

2.       子类中要覆盖父类的方法,必须要和父类方法定义格式一样,包括返回类型,参数,和方法名

 

子父类中的构造函数

 在对子类对象初始化的时候,父类的构造函数也会运行,那是因为子类的构造函数默认第一行有一条隐式的语句super(),super()会访问父类中空参数的构造函数,而且子类中所以构造函数默认第一行都是super()

 

为什么子类一定要访问父类的构造函数:

因为父类中的数据子类可以直接获取,所以子类对象在建立时,需要先查看父类是如何对这些数据初始化的,所以子类在对象初始化的时候,要先访问父类中的构造函数

如果要访问父类中指定的构造函数,可以通过super()语句来指定

 

子类的实例化过程:

子类的所以构造函数都会默认访问父类中的空参数构造函数,因为子类每一个构造函数的第一行都是隐式的super()

当父类么有空参数构造函数时,在子类中必须手动通过super()来指定访问父类中的构造函数

 

final:

特点:

1.       可以修饰类,方法,变量

2.       被final修饰的类不能被继承

3.       被final修饰的方法不能被复写

4.       变量被final修饰后,就变成了常量,不能再改变了

 

抽象:

当多个类中出现相同功能,但是功能主体不同,这时可以进行向上抽取,至抽取方法定义,不抽取方法主体

 

抽象类特点:

1.       抽象方法一定在抽象类中

2.       抽象方法和抽象类都必须用abstract关键字修饰

3.       抽象类不可以用new创建对象,因为调用抽象方法没意义

4.       抽象类中的抽象方法要被调用,必须由子类复写所有抽象类中的方法后,创建子类对象调用,如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类

 

接口:

接口在理解上可以理解为一个特殊的抽象类,这个抽象类的方法全部都是抽象的.

接口中所有的方法都是抽象的,所有的属性都是常量

接口定义格式:  interface{   语句 },相当于一个特殊的类

接口中的方法定义格式:public abstract void Show();         //方法是抽象的

接口中的常量定义格式:public static final int num=3;               //常量

接口不可以创建对象,只能由子类来把所有的方法全部实现

子类实现格式: class 子类名implements接口名 { }

 

接口和抽象类的异同:

异:  1.抽象类是一个类,用abstract class 修饰;接口相当于一个特殊类,但是不是类,用interface修饰

        2.抽象类里面可以有非抽象方法,但是接口里面不能有非抽象方法;抽象类里面可以有变量,但是接口里面只能有常量

        3.抽象类里面的成员可以自定义访问修饰符,但是接口里面的访问修饰符只能是public

同:  1.抽象类和接口里面都有抽象方法

        2. 子类必须复写全部抽象方法才能创建对象

        3. 抽象类和接口都不能创建对象

 

接口的特点:

1.       接口是对外暴露的规则

2.       接口是程序的功能扩展

3.       接口可以用来多实现

4.       类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口

5.       接口与接口之间有继承关心

 

 

Java中类与类之间不支持多继承,但是支持多实现;接口与接口之间支持多继承

如: class A implements B,C{} //类的多实现

   Interface A extends C,D{} //接口的多继承

类可以在继承类的同时进行多实现

如: class A extends B implements C,D{} //继承类的同时进行多实现

 

 

三:多态

多态,简单的理解就是一种事物的不同的表现形态,比如人这个事物,它有男人和女人这两种不同的表现形态,再比如动物,它有猫,狗,牛,羊等不同的表现形态.

1.       多态的体现:父类的引用指向自己的子类对象

2.       多态的前提:类与类之间必须有继承或者实现的关系

3.       多态的好处:提高程序的扩展性

4.       多态的弊端:提高了扩展性,但是只能使用父类的引用访问父类中的成员

 

多态转型:

当父类的引用指向子类对象的时候,此时的子类会自动转型成父类类型

比如:Animal a=new Car()      //此时Car就自动向上转型

如果要使用子类中特有的方法时,可以把向上转型后的子类强制向下转型成子类类型

比如:Car c=(Car) a;       //向下转型,然后再用c.方法名类调用子类特有的方法

 

判断变量是否属于某种类型:

格式: 要判断的类型 instanceof 数据类型    比如: a instanceof Car   判断a是否属于Car类型

 

多态中成员函数的特点:

在编译时,参阅引用型变量所属的类中是否有调用的方法,如果有,编译通过,如果没有则失败.

在运行时,参阅对象所属的类中是否有调用的方法,如果有,编译通过,如果没有则失败.

简单总结就是:成员函数的多态调用时,编译看左边,运行看右边.

 

在多态中,成员变量的特点:

无论编译和运行,都参考左边(引用型变量所属的类)

在多态中,静态成员函数的特点:

无论编译和运行,都参考左边

 

 

 

 

 

 

---------------------- android培训.java培训、期待与您交流！ ----------------------

详细请查看：http://edu.csdn.net/heima