黑马程序员——基础学习（五）继承、多态、抽象类和接口

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

继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

多个类可以称为子类，单独这个类称为父类或者超类。

子类可以直接访问父类中的非私有的属性和行为。

通过 extends 关键字让类与类之间产生继承关系。

class SubDemo extends Demo{}

优点：继承的出现提高了代码的复用性。

继承的出现让类与类之间产生了关系，提供了多态的前提。

特点

Java只支持单继承，不支持多继承。

一个类只能有一个直接父类，不可以有多个父类。

class SubDemo extends Demo{} //ok

class SubDemo extends Demo1,Demo2...//error

Java支持多层继承(继承体系)

class A{}

class B extends A{}

class C extends B{}

注意：

不要仅为了获取其他类中某个功能而去继承

类与类之间要有所属( " is a " )关系，xx1是xx2的一种。

子类的实例化过程

子类中所有的构造函数默认都会访问父类中空参数的构造函数

因为每一个构造函数的第一行都有一条默认的语句super();

子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。

当父类中没有空参数的构造函数时，子类的构造函数必须通过super语句指定要访问的构造函数。

我的想法

当两个事物之间存在一定的所属关系，即就像孩子从父母那里得到遗传基因一样，当然，java要遗传的更完美，这两个类中，一个继承的类（为子类或者基础类）可以从被继承的类（为父类或者超类）中获得一些属性和方法，而不必再自己创建新方法（在不需要复写的情况等）。

super关键字

super和this的用法相像

this代表本类对象的引用

super代表父类的内存空间的标识。

当子父类出现同名成员时，可以用super进行区分

子类要调用父类构造函数时，可以使用super语句。super同this一样，也要放在第一句话中。

如果一个子类的构造函数，既需要调用自己其它的构造函数，同时又需要调用父类的构造函数，那么需要同时使用this和super关键字，这种情况是不允许的。

函数覆盖(Override重写)

子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

父类中的私有方法不可以被覆盖。

在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

覆盖注意事项：

覆盖时，子类方法访问权限一定要大于等于父类方法访问权限

静态只能覆盖静态。

覆盖的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

我的代码

class A{
	public int num = 10;
}
class B extends A{
	int num = 20;

	public void show(){
		int num = 30;
		System.out.println("num = " + num);//30
		System.out.println("this.num = " + this.num);//20;
		System.out.println("super.num = " + super.num);//10;
	}
}

class C
{
	C(){
		System.out.println("构造了C");
	}
}
class D extends C
{
	D(){
		this(1);
		System.out.println("D的默认构造函数");
	}
	D(int a){
		System.out.println("D的带参构造函数");
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		B b = new B();
		b.show();

		System.out.println("***********");
		D d = new D();
	}
}

final关键字

final可以修饰类，方法，变量。

final修饰的类不可以被继承。

final修饰的方法不可以被覆盖。

final修饰的变量是一个常量。只能被赋值一次。

局部内部类只能访问被final修饰的局部变量。

多态

定义：某一类事物的多种存在形态。

例：动物中猫，狗。

猫这个对象对应的类型是猫类型

猫 x = new 猫();

同时猫也是动物中的一种，也可以把猫称为动物。

动物  y = new 猫();

动物是猫和狗具体事物中抽取出来的父类型。

父类型引用指向了子类对象。

程序中体现：

父类或者接口的引用指向或者接收自己的子类对象。

好处和作用：

多态的存在提高了程序的扩展性和后期可维护性

前提：

需要存在继承或者实现关系

要有覆盖操作

多态的特点

成员函数：

编译时：要查看引用变量所属的类中是否有所调用的成员。

在运行时：要查看对象所属的类中是否有所调用的成员。

成员变量：

只看引用变量所属的类。

我的想法

多态是在运行期间，判断引用实际类型，根据实际类型调用相应的方法。

抽象类

抽象定义：

抽象就是从多个事物中将共性的，本质的内容抽取出来。

例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

抽象类定义：

Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象方法的由来：

多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

例如：狼和狗都有吼叫的方法，可是。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节吼叫内容是不一样的。

抽象类的特点

抽象类和抽象方法必须用abstract关键字来修饰。

抽象方法只有方法声明，没有方法体，定义在抽象类中。

格式：修饰符 abstract 返回值类型   函数名(参数列表) ;

抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：

抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。

而且抽象类即使创建了对象，调用抽象方法也没有意义。

抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

代码体现

abstract class Teacher
{
	public String name;
	private int age;
	public abstract void teach();
}
class BasicTeacher extends Teacher
{
	//必须要实现抽象类中的抽象方法
	public void teach(){
		System.out.println("基础班老师，将Java基础");
	}
}
class WorkTeacher extends Teacher
{
	//必须要实现抽象类中的抽象方法
	public void teach(){
		System.out.println("就业班老师，将JavaEE");
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		Teacher tea = new BasicTeacher();
		tea.teach();
	}
}

接口

格式：

    interface {}

接口中的成员修饰符是固定的。

成员常量：public static final

成员函数：public abstract

发现接口中的成员都是public的。

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

接口的特点

接口是对外暴露的规则。

接口是程序的功能扩展。

接口的出现降低耦合性。

接口可以用来多实现。

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

接口与接口之间可以有继承关系。

接口与抽象类

相同点：

1.接口和抽象类都不能实例化。它们都是被其它类继承或实现的。一般都是作为一种"规范"、"规则"出现；

 

不同点：

1.抽象类定义：使用abstract class定义。

  接口      : 使用interface

2.抽象类继承：子类使用extends 关键字

  接口      : 子类使用implements实现

3.抽象类中包含： 普通的成员变量和已实现的成员方法，抽象方法

  接口中      ： 只能包含成员变量和抽象方法。

4.抽象类中可以包含构造函数；

  接口中不能包含构造函数；

5.抽象类子类继承时：只能单继承；

  接口，子类实现是：可以实现多个接口

6.抽象类和抽象类：继承，使用extends关键字，但只能单继承

  接口和接口：继承，使用extends关键字，可以多继承

7.抽象类是继承，是 "is a "关系

  接口是实现，是 ""like a关系

模板模式

 

/*
	模板模式：
	
	1.抽象类利用已经实现的方法和抽象方法对子类进行了更严格的要求；
	2.已经实现的方法：模板方法
	  需要子类实现的方法：实例方法

	  模板方法需要调用实例方法；

*/
abstract class Personnel
{
	//父类的已经实现的方法，子类自动继承
	public  void say(){
		System.out.println("我是传智播客的一名" + getType());
	}
	//子类必须实现的方法，返回各自的类型
	public  abstract String getType();
}
class Student extends Personnel
{
	public String getType(){
		return "学生";
	}
}
class Employee extends Personnel
{
	public String getType(){
		return "员工";
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		Student stu = new Student();
		stu.say();
		Employee emp = new Employee();
		emp.say();
	}
}