一、抽象类的概念

C extends B, B extends A 在继承过程中，形成了一个继承金字塔。位于金字塔底部的类越来越具体(强大)，位于金字塔顶部的类越来越抽象(简单)。

例如：人类继承于(属于)动物类，鱼类继承于(属于)动物类。人类有睡觉(闭眼睡)的方法，鱼类有睡觉(睁眼睡)的方法。动物类也有睡觉的方法，但动物类是人类和鱼类的父类，因此形容动物类睡觉的方法过于抽象，不确定如何去形容，此时可以将动物类睡觉方法定义为抽象方法。

即，当一个类中的方法过于抽象时，不确定如何去实现，此时可以把该方法定义为抽象方法。

抽象方法所在的类过于抽象，称为抽象类(abstract class)。写法如下

public abstract class 类名{

}

二、抽象类的特性

[1]抽象类过于抽象，不能实例化(实例化后无语义)。

public abstract class Animal{

private String name;

public void setName(String name){

this.name = name;

}

public String getName(){

return this.name;

}

public Animal(){

}

public Animal(String name){

this.name = name;

}

public void sleep(){

}

}

[2]如果一个方法过于抽象，无法实现，则需要把该方法定义为抽象方法。写法如下

public abstract void sleep();

抽象方法一定位于抽象类中。

抽象方法没有方法体。

抽象类中的方法不一定都是抽象方法。

package cn.exercises01;

public abstract class Moto {

//定义子类中共有的属性

private String no;

private String brand;

//设置属性访问

public String getNo() {

return no;

}

public void setNo(String no) {

this.no = no;

}

public String getBrand() {

return brand;

}

public void setBrand(String brand) {

this.brand = brand;

}

//无参构造

public Moto() {

super();

}

//有参构造

public Moto(String no, String brand) {

super();

this.no = no;

this.brand = brand;

}

//抽象方法

public abstract int eachRates(int days);

}

[3]子类继承抽象类，一定要根据自身情况重写抽象类的抽象方法，除非子类也是抽象类。

package cn.exercises01;

import static cn.exercises01.CarType.*;

//定义子类Car继承于父类

public class Car extends Moto {

// 设置子类Car自己的属性

private String type;

// 设置访问属性

public String getType() {

return type;

}

public void setType(String type) {

this.type = type;

}

// 无参构造

public Car() {

super();

}

// 有参构造

public Car(String no, String brand, String type) {

super(no, brand);

this.type = type;

}

//继承抽象类，抽象方法重写

public int eachRates(int days) {

int money = 0;

String info = super.getBrand() + this.type;

if (info.equals(BUCK_GL8)) {

money = days * 600;

} else if (info.equals(BMW_550I)) {

money = days * 500;

} else if (info.equals(BUCK_ROAD)) {

money = days * 300;

}

return money;

}

}

三、重写和实现

重写(override)：当子类继承父类的方法不能满足其自身的需要时，子类重写父类的同名方法。

实现(implement)：子类继承抽象父类时，一定要重写父类的抽象方法，此时父类的抽象方法没有方法体，也即没有实现；子类一定重写父类的抽象方法也即实现了父类的抽象方法。

实现是一种特殊的重写。实现建立在重写的继承上

四、Final关键字

final 是一个java的关键字，用于修饰局部变量、属性、方法、类，表示最终的意思。

[1] final修饰类表示最终类，无法被继承。

[2] final修饰符方法，方法就不能被重写。

[3] final 修饰属性，经常和static搭配使用，形成静态常量。

[4] final修饰变量

final 修饰基本数据类型 ，表示a中的内容(值)不能被改变，

final int a = 10;

final 修饰引用数据类型，表示person中的内容(地址)不能被改变。