抽象类引入：

回想前面我们在讲多态时所说的的宝马车，奔驰车的案例，我们提取出了一个汽车类。并且我们在前面也创建过了汽车对象，其实这是不对的。为什么呢?因为，我说汽车，你知道我说的是什么汽车吗?只有看到了具体的车，你才知道，这是什么车。 所以说，汽车本身并不是一个具体的事物，而是一个抽象的事物。只有真正的宝马，奔驰才是具体的车。同理，我们也可以推想，不同的车的价格和速度应该是不一样的，所以，我们不应该在汽车类中给出具体体现，而是应该给出一个声明即可。

所以当编写一个类时，常常会为该类定义一些方法，这些方法用于描述这个类的行为。但在某些情况下只需要定义出一些方法，而不需要具体的去实现这些行为。也就是说这些方法没有方法体，只是一些签名而已，这样的方法被称为抽象方法，包含抽象方法的类被称为抽象类。

6.5.1 抽象方法与抽象类

抽象方法与抽象类必须使用abstract关键字进行修饰，有抽象方法的类必须被定义成抽象类，抽象类里面可以没有抽象方法。

抽象类与抽象方法的规则如下：

1、 抽象类与抽象方法必须使用abstract关键字进行修饰，抽象方法不能有方法体（没有方法体不是空方法）。

2、 抽象类不能被实例化。即使抽象类不包含抽象方法，也不能被实例化。

3、 抽象类可以包含field、方法、构造器、初始化块、内部类5种成分。

4、 包含抽象方法的类，只能被定义成抽象类。

举例1：

package com.langsin.test;
public abstract class Test {
public String name = "zhangsan";
public abstract void setName();
public abstract String getName();
public void run(){
System.out.println("让类跑起来");
}
}

举例2：创建一个类继承Test类

package com.langsin.test;
public class TestAbstract extends Test {
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public static void main(String[] args) {
TestAbstract test = new TestAbstract();
System.out.println(test.getName()); //打印的是zhangsan
}
}

举例3：在上面这个类中重写name属性

package com.langsin.test;
public class TestAbstract extends Test {
public String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public void test(){
super.name = "李四";
this.name = "张三";
super.run();
System.out.println(this.name);
}
public static void main(String[] args) {
TestAbstract ta = new TestAbstract();
ta.test();
}
}

利用抽象类和抽象方法的优势，可以更好的发挥多态的优势，使得程序更加灵活。

使用abstract修饰类时，表明这个类只能被继承，当使用abstract修饰方法时，表明这个方法必须由子类实现。而final修饰的类不能被继承，final修饰的方法不能被重写。因此final和abstract永远不能同时使用。除此之外，使用static修饰一个方法时，表示此方法属于该类本身，即通过类就可以调用该方法，但是如果此方法被定义成抽象方法了，则将导致通过该类来调用该方法时出现错误，因此static和abstract也不能同时修饰某个方法，也就是没有类抽象方法。

6.5.1.1抽象类的成员特点：

成员变量：变量，自定义变量都可以。

构造方法：可以有。是用来子类访问父类数据的初始化。

成员方法：抽象和非抽象都可以。

抽象类的成员方法特性：

A：抽象方法，强制要求子类做的事情，必须做的事情。

B：普通方法，子类继承的事情，提高代码的利用性。

6.5.2 抽象类的作用

抽象类不能创建实例，只能当成父类来被继承。抽象类可以看成是从多个具体类中抽象出来的父类，它具有更高层次的抽象。从多个具有相同特征的类中抽象出来的一个抽象类，以这个抽象类作为其子类的模板，从而避免子类设计的随意性。

抽象类的体现就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，这就是一种模板模式，模板模式也是十分常见的设计模式。

举例1：

package com.langsin.test;
public abstract class Test {
public abstract String getColor();
}

package com.langsin.test;
public class TestOne extends Test {
public String getColor() {
return "red";
}
}

package com.langsin.test;
public class TestTwo extends Test {
public String getColor() {
return "green";
}
public static void main(String[] args) {
TestOne one = new TestOne();
System.out.println("one的颜色是："+one.getColor());
TestTwo two = new TestTwo();
System.out.println("two的颜色是："+two.getColor());
}
}

例2：

在写程序之前我们要分析一下。我说过了，现在写个题目或者是一个项目。不要拿过来就打开myeclipse就新一个类就开始写了，要学会分析，你完成一个操作需要什么，都需要几个类，每个类中需要哪些变量，哪些具体的操作，类与类之间有哪些关联，然后再具体实现。

分析是从具体到抽象，实现是从抽象到具体。

汽车案例:

具体事物：宝马，奔驰。

共性：型号，车型，速度

分析：

宝马：

成员变量：型号，车型

构造方法：有参，无参

成员方法：速度（150Km/h）

奔驰：

成员变量：型号，车型

构造方法：有参，无参

成员方法：速度（160Km/h）

我们会发现，它们之间有一些共性的部分，我们可以把这部分内容提取出来，作一个父类：车。但由于速度等不一样，我们可以把速度这个方法写成抽象方法。所以车类需要定义成一个抽象类。

抽象车类：

成员变量：型号，车型

构造方法：有参，无参

成员方法：速度（）

public abstract class Car{
private String type;
private String name;
public Car(){
}
public Car(String type,String name){
this.type = type;
this.name = nam;
}
get,set方法。
public abstract void speed();
}

public class BmwCar extends Car{
public BmwCar(){
}
public BmwCar(String type,String name){
super(name,age);
}
public void speed(){
System.out.println(“150Km/h”);
}
}

public class BenzCar extends Car{
public BenzCar (){
}
public BenzCar(String type,String name){
super(name,age);
}
public void speed(){
System.out.println(“160Km/h”);
}
}

class AbstractTest{
public static void main(String[] args){
测试：
1.可以用直接类。
2.可以用多态形式。
}
}

模板模式在面向对象的软件中很常用，其原理简单，实现也很简单。使用模板模式有如下规则：

抽象父类可以只定义需要使用的方法，把不能实现的部分抽象成抽象方法留给子类去实现。