抽象类

抽象类的基本概念

(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修饰不让子类访问,所以矛盾
原文地址:https://www.cnblogs.com/happystudyhuan/p/10698495.html