java学习（6）-继承，多态，抽象类以及接口

曾经终败给现在 2022-07-03 18:28 338阅读 0赞

**java学习（6）**

**声明：由于学习是使用JDK7，所有关于java学习所提供的代码段在JDK7环境下均经过测试，没有问题，如果环境不同，可能会有报错！！！**

之前写过java面向对象三个特性之一的封装，这篇来写继承和多态，以及抽象类，接口的内容。

1.继承

就是把多个有共同点的事物中的共同点抽象出来，写成一个父类，把这些事物抽象成类去继承父类中的那些共同点。  
1.1通过extends关键字可以实现类与类的继承  
格式：  
class 子类名 extends 父类名 \{  
\}

代码示例：

父类代码，水果类：

public class Fruit \{  
//创建成员变量  
private String type;  
private String color;  
private int price;  
  
//有参和无参的构造方法  
public Fruit()\{  
\}  
public Fruit(String type,String color,int price)\{  
this.type = type;  
this.color = color;  
this.price = price;  
\}  
  
//set/get方法  
public String getType() \{  
return type;  
\}  
public void setType(String type) \{  
this.type = type;  
\}  
public String getColor() \{  
return color;  
\}  
public void setColor(String color) \{  
this.color = color;  
\}  
public int getPrice() \{  
return price;  
\}  
public void setPrice(int price) \{  
this.price = price;  
\}  
  
//成员方法  
public void show()\{  
System.out.println("这是一个水果！！");  
\}  
\}

子类苹果类继承于水果类：

public class Apple extends Fruit\{  
//有参和无参的构造方法  
public Apple()\{\}  
public Apple(String type,String color,int price)\{  
setType(type);  
setColor(color);  
setPrice(price);  
\}

//方法重写  
public void show()\{  
System.out.println("这是一个苹果！");  
\}  
  
\}

子类橘子类继承于水果类：

public class Orange extends Fruit \{  
  
  
public Orange()\{\}  
public  Orange(String type,String color,int price)\{  
setType(type);  
setColor(color);  
setPrice(price);  
\}  
public void show()\{  
System.out.println("这是一个橘子！");  
\}  
\}  
这里其实已经给出了一个标准的继承，包括父类水果类以及子类苹果类、橘子类，他们都继承了父类水果类的成员变量，成员方法，并且重写了show方法。  
父类又叫做基类，超类；子类又叫做派生类。

1.2继承的好处：

A:提高了代码的复用性  
多个类相同的成员可以放到同一个类中  
B:提高了代码的维护性  
如果功能的代码需要修改，修改一处即可  
C:让类与类之间产生了关系，是多态的前提

1.3继承的特点：  
A:Java只支持单继承，不支持多继承。  
B:Java支持多层(重)继承(继承体系)。

1.4继承间的成员变量关系：  
A:名字不同，非常简单。  
B:名字相同  
1）首先在子类局部范围找  
2）然后在子类成员范围找  
3)最后在父类成员范围找(肯定不能访问到父类局部范围)  
4)如果还是没有就报错。  
5)就近原则。

1.5java就提供了一个关键字：super  
super:  
super代表父类存储空间的标识(可以理解为父类对象)  
this和super的区别  
A:成员变量  
this.成员变量本类的成员变量  
super.成员变量父类的成员变量  
B:成员方法  
this.成员方法()本类的成员方法  
super.成员方法()父类的成员方法

继承间的成员方法关系：  
A:方法名不同，非常简单  
B:方法名相同  
1）首先在子类中找  
2)然后在父类中找  
3)如果还是没有就报错。  
测试代码示例：

//定义父类  
class Fu\{  
int num = 35;  
public void show1()\{  
System.out.println("Fu中的show1方法");  
\}  
public void show2()\{  
System.out.println("Fu中的show2方法");  
\}  
\}  
//定义子类  
class Zi extends Fu\{  
int num = 15;  
//在这个方法里进行测试子类和父类成员变量调用  
public void show1()\{  
int num2 = 25;  
System.out.println("Zi中的show1方法");  
System.out.println(num2);  
System.out.println(this.num);  
System.out.println(super.num);  
\}  
\}  
//定义测试类  
public class ExtendsTest01 \{  
public static void main(String\[\] args) \{  
Zi zi = new Zi();  
zi.show1();  
zi.show2();  
\}  
\}

运行结果：

![Center][]  
通过这段代码就可以很明显的看出成员变量的调用情况。1）首先在子类中找  
2)然后在父类中找，进行调用。

1.6继承间构造方法的关系：  
子类中所有的构造方法默认都会访问父类中空参数的构造方法(super())。子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。  
每个子类的构造方法的第一行，有一条默认的语句:super();  
注意：仅仅是完成数据的初始化，创建对象目前必须用new申请空间。  
假如父类没有无参构造方法：调用父类的其他构造方法。带参构造：super(...)

注意：  
super(…)或者this(….)必须出现在第一条语句上。  
因为如果可以放后面的话，就会对父类的数据进程多次初始化。所以，只能放在第一条语句上。

2. final关键字  
在实际开发的时候，有些方法的内容一旦写定后，就不允许被改动。java提供了一个关键字：final它可以修饰类,方法,变量。经过了final修饰的变量就是常量了。  
特点：  
1）修饰方法，方法不能被重写。  
2）修饰类，类不能被继承。  
3）修饰变量，变量的值不能再改动。其实这个时候变量已经变成了常量。

示例代码：

class Fu\{  
int num1 = 25;  
final int num2 = 15;  
public void show()\{  
System.out.println("父类的一般方法");  
\}  
public final void show2()\{  
System.out.println("父类的final修饰的方法");  
\}  
\}  
class Zi extends Fu\{  
public void show()\{  
System.out.println("子类的一般方法");  
\}  
/\*public void show2()\{//Cannot override the final method from Fu  
System.out.println("父类的final修饰的方法");  
\}\*/  
\}  
public class FinalTest \{  
  
  
public static void main(String\[\] args) \{  
Zi zi = new Zi();  
zi.num1 = 12;  
//zi.num2 = 14;//The final field Fu.num2 cannot be assigned  
zi.show();  
zi.show2();  
\}  
\}

运行结果：

![Center 1][]

代码测试中，在父类里用final修饰的成员变量和成员方法，在继承的子类里只能进行调用，而不能进行更改，会报错。

3.多态  
3.1多态：同一个对象,在不同时刻表现出来的不同状态。  
水在不同的情况下，会有水(液态)、冰(固态)、水蒸气(气态)的三种状态。这也是一种多态。  
3.2多态的前提：  
A:有继承关系  
B:有方法重写（不是必要条件，但是只有有了方法重写多态才有意义）  
C:有父类引用指向子类对象  
左边：Fu类型的引用  
右边：Fu类型的对象  
Fu f = new Zi();  
3.2成员访问特点  
A:成员变量  
编译看左边,运行看左边  
B:构造方法  
子类构造默认访问父类的无参构造  
C:成员方法（重点理解）  
编译看左边,运行看右边  
D:静态成员方法  
编译看左边,运行看左边  
因为静态的内容是和类相关的，与对象无关。

多态代码示例代码：

class Fu\{  
//定义父类成员变量  
int num = 15;  
//定义父类成员方法  
public void show()\{  
System.out.println("父类Fu的show方法");  
\}  
\}  
class Zi extends Fu\{  
//定义子类成员变量  
int num = 55;  
//定义子类成员方法  
public void show()\{  
System.out.println("子类Zi的show方法");  
\}  
\}  
public class DuoTaiTest \{  
public static void main(String\[\] args) \{  
//父类引用指向子类对象  
Fu fu = new Zi();  
//进行变量和方法的调用

//多态的情况下：成员变量的访问特点是，编译看左边，运行看左边  
System.out.println(fu.num);

//多态的情况下：成员方法的访问特点：编译看左边，运行看右边  
fu.show();  
\}  
\}

运行结果：

![Center 2][]

4.抽象类  
4.1抽象类特点:  
A:抽象类和抽象方法必须用abstract关键字修饰  
B:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类  
C:抽象类不能实例化  
那么，如果实例化并使用呢?  
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。  
D:抽象类的子类  
要么是抽象类  
要么重写抽象类中的所有抽象方法  
4.2抽象类的作用：会强制要求子类必须要重写某些方法，不写就会报错。  
抽象类的成员：  
成员变量：可以是变量，也可以是常量。  
构造方法：有构造方法，不能实例化,用于子类访问父类数据的初始化。  
成员方法：既可以是抽象的，也可以是非抽象的。  
多态：  
具体类多态格式：  
class Fu \{\}  
class Zi extends Fu \{\}  
抽象类多态格式：  
abstract class Fu \{\}  
class Zi extends Fu \{\}  
多态的前提：  
1）继承  
2）方法重写  
因为抽象类中的方法是抽象方法。  
3）父类引用指向子类对象

示例代码：

//定义抽象父类  
abstract class Person\{  
public void show()\{  
System.out.println("抽象父类的一般方法");  
\}  
public abstract void eat();  
\}  
//定义子类  
class Teacher extends Person\{   
//实现抽象方法  
@Override  
public void eat() \{  
System.out.println("老师喜欢吃零食！");  
\}  
\}  
public class AbstractTest01 \{  
  
  
public static void main(String\[\] args) \{  
//创建老师类对象  
Teacher t = new Teacher();  
t.show();  
t.eat();  
\}

运行结果：  
![Center 3][]

5.接口  
5.1认识接口：不是我们现实生活中的usb接口等等实物的接口，类实现接口代表着这个类自身功能的一种扩展， 所以接口代表着一种扩展的能力。  
5.2接口的特点：  
A:定义接口要用关键字interface表示  
格式：interface 接口名 \{\}  
B:类实现接口用implements表示  
格式：class 类名 implements 接口名 \{\}  
C:接口不能实例化  
那么，接口如何实例化呢?  
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。  
D:接口的实现类  
要么是抽象类  
要么重写接口中的所有抽象方法  
多态的前提：  
A:有继承或者实现关系  
B:有方法重写  
C:有父类引用或者父接口引用指向子类或者实现类对象  
多态分类：  
A:具体类多态  
B:抽象类多态  
C:接口多态   
5.3接口的成员特点：  
A:成员变量  
只能是常量。  
默认修饰符：public static final  
B:构造方法  
没有构造方法  
C:成员方法  
只能是抽象方法。  
默认修饰符：public abstract  
5.4类与类：  
继承关系。只能单继承，可以多层(重)继承。  
类与接口：  
实现关系。可以单实现，也可以多实现。  
还可以在继承一个类的同时实现多个接口。  
接口与接口：  
继承关系。可以单继承，也可以多继承。  
5.5接口和抽象类的关系最后分析：  
抽象类和接口的区别  
A:成员区别  
抽象类：  
成员变量：可以是变量，也可以是常量  
构造方法：有构造方法  
成员方法：可以是抽象方法，也可以是非抽象方法  
接口：  
成员变量：只能是常量。默认修饰符 public static final  
成员方法：只能是抽象方法。默认修饰符 public abstract  
B:关系区别  
类与类：  
继承关系。只能单继承，可以多层(重)继承。  
类与接口：  
实现关系。可以单实现，也可以多实现。  
还可以在继承一个类的同时实现多个接口。  
接口与接口：  
继承关系。可以单继承，也可以多继承。  
C:设计理念区别  
抽象类被继承体现的是："is a"的关系。抽象类定义的是共性功能。  
接口被实现体现的是："like a"的关系。接口定义的是扩展功能。  
5.6继承，抽象类，接口分析：  
分析：从具体到抽象  
实现：从抽象到具体  
使用：使用具体类

由于涉及到了大量的代码，这里不进行全部示例，最近整理完代码会上传，这里示例接口的部分代码：

这里写一个接口类：

接口类：

public interface inter \{  
  
public abstract void show();  
\}

一个实现接口的类：

public class ClassTest implements inter\{  
  
//定义构造方法  
public ClassTest()\{\}  
  
//重写接口  
@Override  
public void show() \{  
// TODO Auto-generated method stub  
System.out.println("类的show方法");  
\}  
\}

一个测试类：

public class Test \{  
  
  
public static void main(String\[\] args) \{   
ClassTest ct = new ClassTest();  
ct.show();  
\}  
\}

运行结果：

![Center 4][]

这里的代码是ClassTest 类实现了inter接口。

[Center]: /images/20220618/e7929068b5634cde97621d7e81eb49b4.png
[Center 1]: /images/20220618/68947cc3cca9433a923f4c01508453a9.png
[Center 2]: /images/20220618/9205a67658a84fa0b463383980cd4d98.png
[Center 3]: /images/20220618/111866d6c70f4b47bafe959cbfa700e9.png
[Center 4]: /images/20220618/6a2b7a6026e941018ca67093ee2489c1.png