黑马程序员（三）面向对象的三大特征封装、继承、多态

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

封装

  (1)定义：隐藏实现的细节，提供公共的访问方式，类，方法等其实都是封装的具体体现。

  (2)private关键字

A:用于修饰成员变量和成员方法。
B:被修饰的内容在其他类中是不可以被访问的。

       (3)private常见的应用：

A:类中的所有成员变量私有，给出对应的get/set方法。

B:用于修饰构造函数，让其不能new 该类的的实例对象

代码体现：

访问修饰符

private :类访问权限:本类内部可以访问,不能继承到子类;

default :什么都不写,包访问权限:本类内部可以访问，同包其他类也可以访问,同包可继承;

protected:子类访问权限:本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问,能继承到子类;

public :公共访问权限:任何地方都可以访问,能继承到子类;

 

我的总结：

继承

1定义：
(1)把多个类中的相同的属性和行为进行抽取，封装到一个类中，
  然后再建立新类的时候，不需要从头做起，继承刚才定义的那个类即可。
(2)好处：
A:提高代码的复用性。
B:让类与类之间产生了一个关系，是多态的前提。
(3)什么时候使用继承?
A:如果类之间存在着:
is a 的关系，就可以考虑使用继承。
B:不要为了继承部分功能，而去使用继承。
(4)继承的特点：
A:Java只支持单继承，不支持多继承。
为什么?如果支持多继承，就会有调用不明确的问题。
B:Java支持多层(重)继承。
(5)super和this的区别?
A:super是一个关键字，代表父类的存储空间标识。(可以理解为父亲的引用)
B:它和this的用法相似
a:成员变量
this.变量 -- 本类的
super.变量 -- 父类的
b:构造方法
this(...) -- 本类的
super(...) -- 父类的
c:成员方法
this.方法名() -- 本类的
super.方法名() -- 父类的
(6)子父类中成员变量的用法：
A:名称不同，这个太简单了。
B:名称相同，子类对象的在使用的时候：

先找子类局部范围
再找子类成员范围
最后找父类成员范围
(7)子父类中成员方法的用法：
A:名称不同，这个太简单了。
B:名称相同，子类对象的在使用的时候：
先找子类的
再找父类的
C:方法重写
在子类中，方法声明(修饰符,返回值,方法名,参数列表)相同的情况。

注意事项：
a:父类中私有方法是不能被重写
b:子类方法的访问权限一定要大于等于父类的访问权限
c:静态只能重写静态。(这个不能算，因为静态跟类相关)
(8)子父类中构造方法的用法：
A:子类的初始化过程中，首先回去执行父类的初始化动作。
  因为子类的构造方法中默认有一个super()。
为什么?子类要使用父类的成员变量，这个初始化，必须在子类初始化之前完成。
所以，子类的初始化过程中，会先执行父类的初始化。
B:如果父类没有无参构造方法
A:使用super调用父类的带参构造。推荐方式。
B:使用this调用本身的其他构造。

(9)子类的实例化过程：

代码如下：

在继承操作中，对于子类对象的实例化：子类对象在实例化之前必须首先调用父类中的无参构造方法之后再调用自身的构造方法

我的总结：在创建子类对象调用子类构造函数里面第一行默认是Super();会调用父类的无参构造函数；也可以动调用本类的其他构造函数，但最终肯定有一个会去访问父类中的无参构造函数

 

2：代码块(面试题)
(1)执行顺序：
静态代码块 --> 构造代码块 --> 构造方法
(2)注意事项：
静态代码块只执行一次

我的总结：继承是多态的前提，类只支持单继承不支持多继承，接口可以多继承

多态

(1)定义：
对象在不同时刻表现出来的不同状态。
举例：狗（狗、宠物、动物）
(2)前提：
A:要有继承或者实现关系。
B:要有方法的重写/实现。
C:要有父类引用或者父接口引用指向子类对象。


注意：多态有三种体现形式
类多态
抽象类多态
接口多态
(3)多态中的成员特点：
A:成员变量
编译看左边，运行看左边。
B:成员方法
编译看左边，运行看右边。

为什么?因为方法存在重写，而变量没有。


(4)多态的弊端：
父类(接口)引用不能使用子类特有功能。
为了解决这个弊端，我们需要向下转型。

Fu f = new Zi(); //向上转型
Zi z = (Zi)f; //向下转型

(5)多态的好处：
可以提高代码的扩展性和可维护性。

final关键字

(1)特点：

1　final可以修饰类,方法,变量。

2　final修饰类不可以被继承，但是可以继承其他类。 

3　final修饰的方法不可以被覆写,但可以覆写父类方法。

4　final修饰的变量称为常量，这些变量只能赋值一次。

5　内部类在局部时，只可以访问被final修饰的局部变量。

6　final修饰的引用类型变量,表示该变量的引用不能变,而不是该变量的值不能变;

抽象类
(1)定义：如果多个类中存在相同的方法声明，而方法体不一样，我们就可以只提取方法声明。
 如果一个方法只有方法声明，没有方法体，那么这个方法必须用抽象修饰。
 而一个类中如果有抽象方法，这个类必须定义为抽象类。
(2)抽象类的特点
A:抽象类和抽象方法必须使用abstract修饰
B:抽象类不能被实例化
C:抽象类有构造方法，用于子类实例化使用
D:如果一个类是抽象类，那么，继承它的子类
要么是抽象类。
要么重写所有抽象方法。
(3)抽象类的成员特点
A:成员变量 可以变量，也可以是常量
B:构造方法 有构造方法
C:成员方法 可以有抽象方法，也可以有非抽象方法（全是抽象方法或者非抽象方法都是可以的）
(4)抽象类的几个小问题
A:抽象类不能被实例化，为什么有构造?
用于子类实例化使用。
B:一个类没有抽象方法，为什么定义为抽象类?
不想被实例化，或者是抽取出来的一个规则类
C:abstract不能和哪些关键字共存。
final
private
static

我的总结：抽象类用abstract修饰，里面可以有用abstract修饰的方法（没有方法体），强制子类进行重写

抽象类的作用一般是强制某个类必须具有某种方法时，我们就让他们的父类是抽象类，必须对父类中的方法进行重写

接口
(1)定义：如果一个抽象类中的方法都是抽象的，这个时候，java就提供了一种
 更抽象的表示形式：接口。

例子：

生活中听说过的USB接口其实并不是我们所看到的那些插槽,而是那些插槽所遵循的一种规范;而我们看到的那些插槽是根据USB规范设计出来的实例而已,也就说插槽是USB的实例;

对应不同型号的USB设备而言,他们各自的USB插槽都需要遵循一个规范,遵守这个规范就可以保证插入插槽的设备能与主板正常通信；

对于同一种型号的主板上的多个USB插槽,他们有相同的数据交换方式,相同的实现细节,可认为他们都是同一个类的不同实例

  接口：interface
 实现：implements


 格式：
interface 接口名{}


class 类名 implements 接口名 {}
(2)接口的特点：
A:接口不能被实例化。
B:一个类如果实现了接口：
要么是抽象类。
要么实现接口中的所有方法。
(3)接口的成员特点：
A:成员变量 只能是常量。默认修饰符 public static final
B:成员方法 只能是抽象方法。默认修饰符 public abstract


(4)接口的思想特点：
A:对外暴露的规则
B:是功能的扩展
C:降低耦合度
耦合：类与类的关系
内聚：类自己完成某件事情的能力
高内聚，低耦合。
D:接口可以多实现。
(5)类，接口的关系
A:类与类
继承关系,只能单继承，可以多层继承。
B:类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时实现多个接口。
C:接口与接口
继承关系，可以单继承，也可以多继承。

我的总结：

接口只定义了类应当遵循的规范,却不关心这些类的内部数据和其方法内的实现细节.

接口只规定了这些类里必须提供的方法;从而分离了规范和实现.增强了系统的可拓展性和维护性;

抽象类和接口的比较

相同点:

都位于继承的顶端,用于被其他实现或继承;

都不能实例化;

都包含抽象方法,其子类都必须覆写这些抽象方法;

区别:

抽象类为部分方法提供实现,避免子类重复实现这些方法,提供代码重用性;接口只能包含抽象方法;

用法：当需要子类必须具备某种功能是就定义其父类是抽象类，

接口是功能的扩展，要实际某种功能时就实现接口，接口中的方法不是没个类都必须具备的；

举例：定义一个person类 ，Student 和讲英语的接口类