【java】抽象类

➢在 java 中采用 abstract 关键字定义的类就是抽象类，采用 abstract 关键字定义的方法就是抽象方法；

➢抽象的方法只需在抽象类中，提供声明，不需要实现；

➢如果一个类中含有抽象方法，那么这个类必须定义成抽象类；

➢如果这个类是抽象的，那么这个类被子类继承，抽象方法必须被复写。如果在子类中不复写该抽象方法，那么必须将此方法再次声明为抽象方法；

➢抽象的类是不能实例化的，就像现实世界中人其实是抽象的，张三、李四才是具体的；

➢抽象类不能被 final 修饰；

➢抽象方法不能被 final 修饰，因为抽象方法就是被子类实现的。

抽象类中可以包含方法实现，可以将一些公共的代码放到抽象类中，另外在抽象类中可以定义一些抽象的方法，这样就会存在一个约束，而子类必须实现我们定义的方法，如：teacher 必须实现 printInfo 方法，Student 也必须实现 printInfo 方法，方法名称不能修改，必须为 printInfo，这样就能实现多态的机制，有了多态的机制，我们在运行期就可以动态的调用子类的方法。所以在运行期可以灵活的互换实现。 

1、采用 abstract 声明抽象类 

public class AbstractTest01 {    
    public static void main(String[] args) {         
        //不能实例化抽象类   
        //抽象类是不存在，抽象类必须有子类继承     
        Person p = new Person();      
    
        //以下使用是正确的，因为我们 new 的是具体类        
        Person p1 = new Employee();   
        p1.setName("张三");   
        System.out.println(p1.getName());     
    }  
} 
 
    //采用 abstract 定义抽象类 
    //在抽象类中可以定义一些子类公共的方法或属性 
    //这样子类就可以直接继承下来使用了，而不需要每个子类重复定义 
    abstract class Person {    
        private String name;    
        public void setName(String name) {   
            this.name = name; 
     }     
    public String getName() {   
        return name;   
    }    
    //此方法各个子类都可以使用   
    public void commonMethod1() {   
        System.out.println("---------commonMethod1-------");  
    } 
} 
 
class Employee extends Person {   

} 
 
class Student extends Person {   

} 

2、抽象的方法只需在抽象类中提供声明，不需要实现，起到了一个强制的约束作用，要求子类必须实现

public class AbstractTest02 {    
    public static void main(String[] args) {   
        //Person p = new Employee();   
        //Person p = new Student();   
        //Person p = new Person();   
        p.setName("张三");   
        p.printInfo();  
    }  
} 
 
abstract class Person { 
    private String name;    
    public void setName(String name) {   
        this.name = name;  
    }     
    public String getName() {   
        return name;   
    }    
    //此方法各个子类都可以使用   
    public void commonMethod1() {   
        System.out.println("---------commonMethod1-------");  
    }    
    //public void printInfo() {  
        // System.out.println("------Person.printInfo()--------");   
    //}    
    
    //采用 abstract 定义抽象方法  //如果有一个方法为抽象的，那么此类必须为抽象的  
    //如果一个类是抽象的，并不要求具有抽象的方法  
    public abstract void printInfo(); 
} 
 
class Employee extends Person {    
    //必须实现抽象的方法  
    public void printInfo() {   
    System.out.println("Employee.printInfo()");   
    } 
} 
 
class Student extends Person {    
    //必须实现抽象的方法  
    public void printInfo() {   
        System.out.println("Student.printInfo()");   
    } 
}

3、如果这个类是抽象的，那么这个类被子类继承，抽象方法必须被覆盖。如果在子类中不覆盖该抽象方法，那么必须将此方法再次声明为抽象方法

public class AbstractTest03 {    
    public static void main(String[] args) {   
    //此时不能再 new Employee 了   
    Person p = new Employee();  
    }  
} 
 
abstract class Person {    
    private String name;    
    public void setName(String name) {   
        this.name = name;  
    }     
    public String getName() {   
        return name;   
    }    
    //此方法各个子类都可以使用   
    public void commonMethod1() {   
        System.out.println("---------commonMethod1-------");  
    } 
 
    //采用 abstract 定义抽象方法  
    public abstract void printInfo(); 
} 
 
abstract class Employee extends Person {    
    //再次声明该方法为抽象的  
    public abstract void printInfo(); 
} 
 
class Student extends Person { 
    //实现抽象的方法  
    public void printInfo() {   
        System.out.println("Student.printInfo()");   
    } 
} 

4、抽象类不能被 final 修饰 

public class AbstractTest04 {    
    public static void main(String[] args) {  
    
    }  
} 
 
//不能采用 final 修改抽象类 
//两个关键字是矛盾的 
final abstract class Person {    
    private String name;    
    public void setName(String name) {   
        this.name = name;  
    }     
    public String getName() {   
        return name;   
    }    
    //此方法各个子类都可以使用   
    public void commonMethod1() {   
        System.out.println("---------commonMethod1-------");  
    } 
 
    //采用 abstract 定义抽象方法  
    public abstract void printInfo(); 
} 
 
class Employee extends Person {    
    //实现抽象的方法 
     public void printInfo() {   
        System.out.println("Student.printInfo()");   
    } 
} 
 
class Student extends Person {    
    //实现抽象的方法  
    public void printInfo() {   
        System.out.println("Student.printInfo()");   
    } 
}

5、抽象方法不能被 final 修饰 

public class AbstractTest05 {    
    public static void main(String[] args) {  
    
    }  
} 
 
abstract class Person {    
    private String name;    
    public void setName(String name) {   
        this.name = name;  
    }     
    public String getName() {   
        return name;   
    }
    //此方法各个子类都可以使用   
    public void commonMethod1() {   
        System.out.println("---------commonMethod1-------");  
    } 
 
    //不能采用 final 修饰抽象的方法  
    //这两个关键字存在矛盾  
    public final abstract void printInfo(); 
} 
 
class Employee extends Person {    
    //实现抽象的方法  
    public void printInfo() {   
        System.out.println("Student.printInfo()");   
    } 
} 
 
class Student extends Person {    
    //实现抽象的方法  
    public void printInfo() {   
        System.out.println("Student.printInfo()");   
    } 
}

6、抽象类中可以没有抽象方法