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

java学习（6）

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

之前写过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.5 java就提供了一个关键字：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();
}

}

运行结果：



通过这段代码就可以很明显的看出成员变量的调用情况。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();
}

}

运行结果：



代码测试中，在父类里用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();
}

}

运行结果：



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();
}

}

运行结果：



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();

}

}

运行结果：



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