黑马程序员--继承和抽象类

黑马程序员--继承和抽象类

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

继承和抽象类

一、概述

继承（extends）：是一种通过建立隶属关系而共享功能的方式。它将多个类中的相同属性和行为进行抽取，独立封装，以便于其他同类使用。被共享的类叫父类、超类；获取类为子类。

二、优缺点

优点：提高代码的复用性；使类与类产生了关系，是多态的前提；
缺点：打破封装性。

注意：

a、存在所属关系时才可以继承。所属关系 is a。判断是否存在关系的标准：继承后子类是否具备全部父类的内容。
b、java中，只支持单继承（一个孩子只有一个父亲），不支持多继承。因为多继承存在安全隐患：
但java保留这种机制，并用另一种体现形式来完成表示：多实现。
c、java支持多层继承：爷<--父<--子。通过查阅父类功能，创建子类对象使用功能。
在具体调用时，要创建最子类的对象。
原因：1 因为有可能父类不能创建对象；2 创建子类对象可以使用更多的功能，包括基本的也包括特有的。
d、描述事物根据相互关系，不一定全是继承。谁是谁的一种是继承，谁里面有谁就是聚集。
聚集（聚合）：has a 。如：球队有球员。
组合：is a。手是人的一部分，紧密度更高。

三、特点

子父类中类成员（变量、函数、构造函数）的特点：
1、成员变量：

如果子父类中出现非私有的同名成员变量时，可通过this和super区别调用。

this代表本类对象的引用；super代表父类对象的引用。this和super的用法相似：

子类访问本类的成员变量-->this；
子类访问父类中的同名成员变量时-->super；

class Fu
{
	//成员变量：作用于整个类的变量
	int num = 1;
}
//extends 继承
class Zi extends Fu  
{
	int num = 4;
	void show()
	{
		System.out.println("Zi: "+this.num+"...."+"Fu: "+super.num);
	}
}
class ExtendsDemo
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		z.show();
	}
}

输出结果：

2、成员函数
覆盖/重写（Override）：当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类函数的内容。

当想使用父类函数时，可通过：super.函数名 获取。
当子类继承父类，就沿袭了父类的功能，但当子类功能内容和父类存在不一致时，子类可以通过覆盖扩展父类功能。

注意：
a、重载（Overload）：只看同名函数的参数列表；重写/覆盖（Override）：子父类函数要一模一样。

b、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

c、 静态只能覆盖静态。 因为静态先初始化。


3、构造函数 

函数名和类名相同的函数，不用定义返回值类型，不可以写return语句。作用：给对象进行初始化。

特点：在对子类对象进行初始化时，父类的构造函数也会运行。因为子类的构造函数在第一行存在隐式语句 :super();

问题：

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

答：因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先参考父类进行数据初始化的信息。

注意：

a、super():会访问父类中空参数的构造函数。如果要访问父类中指定的构造函数（非空参数构造函数），可以通过手动定义super语句进行。

b、构造函数中没有覆盖，因为覆盖要求子父类函数一模一样，但是构造函数要求函数名和类名相同，若存在覆盖，子父类就会重名，造成class Fu extends Fu这样的怪现象。

c、构造函数中针对父类已经定义好的功能，子类可直接调用 格式：super(name); 一般函数中子类调用父类方法格式：super.show();

class Fu
{
	Fu()
	{
		System.out.println("fu run");
	}	
	Fu(int x) 
	{
		System.out.println("fu..."+x);
	}
}
class Zi extends Fu 
{
	Zi()
	{
		//子类的构造函数在第一行存在隐式语句:super(); 
		System.out.println("zi run");
	}
	Zi(int x)
	{
		//访问非默认构造函数，需手动调用
		super(x);
		System.out.println("zi..."+x);
	}
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		Zi z1 = new Zi(3);		
	}
}

输出结果：


PS:

子类的实例化过程：
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。因为第一行隐式super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
同时，子类的构造函数第一行也可手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。

总结：

一个对象实例化过程，以Person p = new Person()为例：
a，JVM会读取指定的路径下的Person.class文件，并加载进内存，并会先加载Person的父类。
b，在内存开辟空间，分配地址；
c，在对象空间中，对对象的属性进行默认初始化；
d，调用对应的构造函数进行初始化；
e，在构造函数中，第一行会先到被调用的父类的构造函数中进行初始化；
f，父类初始化完毕后，再对子类的属性进行显示初始化，即给成员变量赋值；
g，再进行子类构造函数的特定初始化；
h，初始化完毕后，将地址赋值给引用变量。

四、final关键字

final：最终。 功能：保障类或数据的封装性。

特点：
1 作为一个修饰符，修饰类、方法（函数）、变量（成员、静态、局部）。 
2 被final修饰的类不能被继承。
3 被final修饰的方法不可被复写。
4 被final修饰的变量将变为常量，它只能赋值一次。

5 内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。
注：

a、一般类的修饰符：public、final；内部类还可以被private修饰。

b、当一些数据固定不变时，可加上final修饰，变成常量。常量的书写规范所有字母都大写；如果由多个单词组成，单词用_连接。如：final PI = 3.14;

抽象类

一、定义

抽象（abstract ）：将多个事物中共性的、本质的内容抽取出来。如：爷们儿、娘炮、妹子都是人，人就是抽取的概念。

抽象类：包含抽象方法（没有方法体的方法）的类。

二、原理

函数包括两部分：功能定义和功能主体。
抽象类中只有功能定义，功能主体由子类实现。这样有利于功能的拓展。

三、特点

1、抽象类和抽象方法都必须被abstract关键字修饰；
2、抽象方法只有方法声明，没有方法体，定义在抽象类中；

格式：修饰符 abstract 返回值类型 函数名(参数列表);
3、抽象类不可以用new创建对象，因为抽象类只有功能定义，没有功能主体，调用无意义。
4、通过子类复写抽象方法的方式，建立子类对象调用抽象方法。
如果子类只覆盖类部分抽象方法，那么该子类也会变为一个抽象类，因为继承了抽象类的全部。

abstract class Demo
{
	abstract void show();
}
class DemoA extends Demo
{
	void show()
	{
		System.out.println("DemoA show");
	}
}
class AbstractDemo
{
	public static void main(String[] args)
	{
		DemoA a = new DemoA();
		a.show();
	}
}

输出结果：

四、抽象类与一般类的区别

相同点：都用来描述事物，都在内部定义了成员。

不同点：

1、一般类有足够的信息描述事物；

抽象类描述事物的信息有可能不足。

2、一般类中不能定义抽象方法，只能定义非抽象方法；

抽象类即可定义抽象方法，也可定义非抽象方法。

3、一般类可以被实例化；

抽象类不可以被实例化。