2.2 面向对象（二）

封装、继承、构造函数、抽象类、final关键字、接口、多态

 

面向对象的特征：

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

    好处：将变化隔离，便于使用，提高重用性，提高安全性。

private: 私有，是一个权限修饰符。用于修饰对象成员。私有的内容只在本类中有用。私有只是封装的一种体现。

            常用于将成员变量私有化，对外提供对应的set, get方法对其进行访问。提高对数据访问的安全性。

 

继承

继承的好处：

1、提高了代码的复用性。

2、让类与类之间产生了关系，给第三个特征多态提供了前提。

继承弊端：

打破了封装性。

 

Java中支持单继承，不直接支持多继承，对C++中的多继承机制进行改良。

单继承：就是一个子类只能有一个直接父类。

多继承：一个子类可以有多个直接父类（Java中不允许，进行改良）

            不直接支持，因为多个父类中有相同成员，会产生 调用不确定性。在Java中通过“多实现”的方式来体现。

 

Java支持多层（多重）继承

C继承B，B继承A，就会出现继承体系。

当使用一个继承体系时：

1、查看该体系中的顶层类，了解该体系的基本功能。

2、创建体系中的最子类对象，完成功能的使用。

 

什么时候定义继承：

当类与类之间存在所属关系时，就定义继承。xxx是yyy中的一种，则xxx   extends  yyy.

 

在子父类中，成员特点的体现：

1、成员变量

    当本类中的成员变量和局部变量同名用this区分，this代表一个本类对象的引用；

    当子父类中的成员变量同名用super区分父类，super代表一个父类空间。

    子类不能直接访问父类中私有的内容。

2、成员函数

当子父类中出现成员函数一模一样的情况，会运行子类的函数。这种现象，称为覆盖操作。

 

函数的两个特性：

1、重载。同一个类中。overload

2、覆盖。出现在子类中。覆盖也称为重写，覆写。override

覆盖注意事项：

1、子类方法覆盖父类方法时，子类方法权限必须大于等于父类方法权限。

2、静态只能覆盖静态，或被静态覆盖。

什么时候使用覆盖操作：

当对一个类进行子类的扩展时，子类需要保留父类的功能声明，但是要定义子类中该功能的特有内容时，就使用覆盖操作完成。

 

3、构造函数

在子类构造对象时，发现，访问子类构造函数时，父类也运行了。

原因是在子类的构造函数中第一行有一个默认的隐式语句。super();

子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数构造函数。

 

子类实例化时访问父类构造函数的原因：

    因为子类继承了父类，获取到了父类中内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化

的。所以子类在构造对象时，必须访问父类中的构造函数。为了完成这个必须动作，在子类的构造函数中加入了super()语句。

    如果父类中没有定义空参数的构造函数，而存在有参数的构造函数，那么子类的构造函数必须用super明确要调用的是父类中

那个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，super就没有了，因为super和this都只能定义在第一

行，所以只能有一个。但可以保证的是子类中肯定会有其它的构造函数访问父类的构造函数。

注意：super语句必须要定义在子类构造函数的第一句。因为父类的初始化动作要先完成。

 

一个对象实例化过程：

如Person p = new Person();
1、JVM会读取指定的路径下的Person.class文件，并加载进内存，并会先加载Person的父类（如果有直接的父类的情况下）。
2、在堆内存中开辟开年，分配地址。
3、并在对象空间中，对对象中的属性进行默认初始化。
4、调用对应的构造函数进行初始化。
5、在构造函数中，第一行会先调用父类中构造函数进行初始化。
6、父类初始化完毕后，再对子类的属性进行显示初始化。
7、再进行子类构造函数的特定初始化。
8、初始化完毕后，将地址赋值给引用变量。

 

抽象类

抽象类的特点：

1、方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰，
    抽象方法必须定义在抽象类中，该类必须也被abstract修饰。
2、抽象类不可以被实例化，因为调用抽象方法没意义。
3、抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化，否则，这个子类还是抽象类。

 

关于抽象类的细节问题：

1、抽象类中有构造函数，用于给子类对象进行初始化。

2、抽象类可以不定义抽象方法，但是很少见目的就是不让该类创建对象。AWT的适配器对象就是这种类。

     通常这个类中的方法有方法体，但是却没有内容。

3、抽象类关键字abstract不可以和以下关键字共存。

     private，static，final

4、抽象类和一般类的异同点。

    相同点：抽象类和一般类都是用来描述事物的，都在内部定义了成员。

    不同点：
        1）一般类有足够的信息描述事物；
            抽象类描述事物的信息有可能不足。
        2）一般类中不能定义抽象方法，只能定义非抽象方法；
            抽象类中既可以定义抽象方法，同时也可以定义非抽象方法。
        3）一般类可以被实例化；
            抽象类不可以被实例化。

5、抽象类一定是个父类。因为需要其子类覆盖其抽象方法后才可以对子类实例化。

 

final关键字

1、final是一个修饰符，可以修饰类，方法，变量。
2、final修饰的类不可以被继承。
3、final修饰的方法不可以被覆盖。
4、final修饰的变量是一个常量，只能赋值一次。

 

用final修饰变量的原因：

在程序中如果一个数据是固定的，那么直接使用这个数据就可以了，但直接使用阅读性差，所以给该数据起个名称，而且这个变量名称的值不能改变，所以加上final固定。

写法规范：常量所有字母都大写，多个单词之间用下划线连接。

 

接口

当一个抽象类中的方法都是抽象方法时，可以将该抽象类用另一种形式定义和表示，就是接口 ，关键字interface。

接口中常见的成员：这些成员都有固定的修饰符。
1、全局变量：public  static  final
2、抽象方法：public  abstract
由此得出结论，接口中的成员都是公共的权限

 

类与类之间是继承关系；

类与接口之间是实现关系。implements

接口与接口之间是继承关系，而且接口之间可以多继承。

一个类在继承另一个类的同时，还可以实现多个接口

 

接口不可以实例化。只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化；否则，这个子类就是一个抽象类。

在Java中不直接支持多继承，因为会出现调用的不确定性。
所有Java将多继承机制进行改良，在Java中变成了多实现。即一个类可以实现多个接口。
class A implements B，C{}

 

接口的特点：
接口是对外暴露的规则；
接口是程序的功能扩展；
接口的出现降低耦合性。

 

抽象类和接口的异同点：

相同点：

    都是不断向上抽取而来的。

不同点：
    1、抽象类需要被继承，而且只能单继承。
         接口需要被实现，而且可以多实现。
    2、抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
         接口中只可以定义抽象方法，必须由子类去实现。
    3、抽象类的继承，是 is a 关系，在定义该体系的基本共性内容。
         接口的实现是 like a 关系，在定义体系额外功能。

 

多态

多态：一个对象对应着不同类型。

多态在代码中的体现：父类或者接口的引用指向其子类的对象。

多态的好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：前期定义的内容不能（调用）使用后期子类的特有内容。

多态的前提：
    1、必须有关系：继承或实现
    2、要有覆盖。

向上转型：子类对象提升到父类类型，但是子类的特有功能无法访问。作用就是限制对特有功能的访问。
    如：Person p = new Staff();
向下转型：目的是为了使用子类中的特有方法。
    如：Staff s = (Staff)p;

 

instanceof：用于判断对象的具体类型。只能用于引用数据类型判断
if(p instanceof staff)     //如果p是Staff类型

 

多态时，成员的特点
1、成员变量
    编译时：参考引用型变量所属的类中是否有调用的成员变量，有，编译通过，没有，编译失败。
    运行时：参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。
    简单说：编译和运行都参考等号的左边。也就是父类。
2、成员函数（非静态）
    编译时：参考引用型变量所属的类中是否有调用的成员函数，有，编译通过，没有，编译失败。
    运行时：参考的是对象所属的类中是否有调用的成员函数。
    简单说：编译看左边，运行看右边。
3、静态函数
    编译时：参考引用型变量所属的类中是否有调用的静态方法
    运行时：参考引用型变量所属的类中是否有调用的静态方法
    简单说：编译和运行都参考等号的左边
    对于静态方法，是不需要对象的，直接用类名调用即可。