抽象类

抽象类的基本概念

（1）很多具有相同特征和行为的对象可以抽象为一个类，很多具有相同特性和行为的类可以抽象为一个抽象类。

（2）使用abstract关键字声明的类为抽象类。

 

定义一个抽象类　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

用abstract关键字声明的类为抽象类，　　　　　　　　　　　　

很多具有相同特征和行为的对象可以抽象为一个类，　　　　　　　

很多具有相同特性和行为的类可以抽象为一个类　　　　　　　　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

abstract class Animal{　　　　　　　　　　　　　　　　　　　　　　　

　　public abstract void move(); 　　　　　　　　　　　　　　

}　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

abstract class Person extends Animal{　　　　　　　　　　　　

　　private String name;　　　　　　　　　　　　　　　　　　　　　

//...　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

public abstract void eat();//抽象方法　　　　　　　　　　　　　　　　

}　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

 

具体类　　　　　　

class Man extends Person{

　public void eat(){

　　System.out.println("我爱吃肉")

　　}　　　　　　　　　　　　　

  public void move(){　　　　　　

　　System.out.println("我爱跑步”）；

　　}

}

class Woman extends Person{　　　　

　public void eat(){

　System.out.println("我爱吃香蕉”）；　　　

}　　

　public void move(){　　

　　System.out.println("我喜欢逛街 "）；　　　　

　　}

}

1.抽象类可以没有抽象方法，有抽象方法的类必须是抽象类

2.非抽象类继承抽象类必须实现所有抽象方法

3.抽象类可以继承抽象类，可以不实现父类抽象方法

4.抽象类可以有方法实现和属性

5.抽象类不能被实例化

6.抽象类不能声明为final

7.抽象类可以有构造方法

//抽象类是类的模板
//因为多态而存在
public abstract class TestAbstract {
    //声明抽象方法，当子类继承，如果子类不是抽象类，必须实现
    public abstract void fn();
    //定义方法
    public void fn1() {
        
    }
}
//抽象类可以继承抽象类
abstract class TestA extends TestAbstract{
    
}
//非抽象类继承抽象类必须实现所有抽象方法
class TestSB extends TestAbstract{

    @Override
    public void fn() {
        // TODO Auto-generated method stub
        
    }
    
    public void fn2() {
        
    }
    
}

测试

public class Test09 {
    public static void main(String[] args) {
        TestAbstract ta = new TestSB();
        ta.fn();
        ta.fn1();
        
        TestSB ta22 = (TestSB)ta;
        ta22.fn2();
        
    }
}

 抽象类不能实例化，那么抽象类如何实例化呢？

• 按照多态的方式，由具体的子类实例化，这也是多态的一种，抽象类多态。

抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口。抽象类的子类，要么是抽象类，要么重写抽象类的所有抽象方法。

 

抽象类的成员特点

• 成员变量：既可以是变量，也可以是常量。abstract不能修饰成员变量
• 构造方法：有，用于子类访问父类数据的初始化
• 成员方法：既可以是抽象的，也可以是非抽象的

抽象类的成员方法特性：

• 抽象方法：强制要求子类做的事情
• 非抽象方法：子类继承的事情，提高代码的复用性。

abstract不能和static共存：

• 被abstract修饰的方法没有方法体
• 被static修饰的可以用类名.调用抽象方法是没有意义的

abstract不能和final共存：

• 被abstract修饰的方法强制子类重写
• 被final修饰的不让子类重写，所以矛盾

abstract不能和private共存：

• 被abstract修饰的是为了让子类看到并强制重写
• 被private修饰不让子类访问，所以矛盾