一、抽象類

	定義：在普通類的基礎上擴充了一些抽象方法 。

1. 抽象方法:只宣告而未實現的方法（沒有方法體）

• 所有抽象方法使用abstract定義。同時抽象方法所在的類也要用abstract定義，表示抽象類。
• 舉例：定義一個抽象類：

抽象類中沒有具體實現，因此抽象類不能直接例項化物件

abstract class Person{
	private String name;//姓名屬性
	public String getName(){
		return this.name;
	}
	public void setName(String name){
		this.name = name;
	}
	//{}為方法體，所有抽象方法沒有方法體{}
	public abstract void getPersonInfo();//抽象方法
}	
 

2.抽象類的使用原則

（1）抽象類必須有子類（abstract與final不能同時使用）。
（2）子類覆寫抽象類所有的抽象方法（abstract與private不能同時使用）。
（3）抽象類例項化物件，必須通過子類向上轉型來例項化物件（抽象類無法直接例項化物件）。

//抽象類的標準操作，也是常用操作。

abstract class Person{
	//姓名屬性
	private String name;
	//普通方法
	public String getName(){
		return this.name;
	}
	public void setName(String name){
		this.name=name;
	}
	//抽象方法
	public abstract void getPersonInfo();
}

//子類繼承抽象類
class Student extends Person{
	public void getPersonInfo(){
		System.out.println("I am a student");
	}
}	

public class Test{
	public static void main(String[] args){
		//例項化子類，向上轉型
		Person per = new Student();	
		//被子類所覆寫的方法
		per.getPersonInfo();
	}
}

執行結果：I am a student
 

abstract class Person{
    private String name ; // 屬性
    public String getName(){ // 普通方法
        return this.name;
    }
    public void setName(String name){
        this.name = name ;
    }
    
    public abstract void getPersonInfo() ; //抽象方法

    public static Person getInstance() { //取得A類物件
    	//定義抽象類的子類 （內部類）
        class Student extends Person {  
            public void getPersonInfo() {
                System.out.println("I am a student");
            }
        }
        return new Student();
    }
}

public class Test{
    public static void main(String[] args) {
        Person per = Person.getInstance();
        per.getPersonInfo() ; //被子類所覆寫的方法
    }
}

執行結果：I am a student
 

3.抽象類的相關規定

（1）抽象類也提供構造方法，並且子類也遵循物件例項化流程：先呼叫父類構造方法，再呼叫子類構造方法

abstract class Person{
	private String name;
	public String getName(){
		return name;
	}
	
	//父類構造方法
	public Person(){
		System.out.println("1.**************");
	}

	//抽象方法
	public abstract void fun();
}

class Student extends Person{
	//子類構造方法
	public Student(){
		System.out.println("2.##############");
	}

	public void fun(){
		System.out.println("子類繼承抽象類");
	}
}
public class Test{
	public static void main(String[] args){
		new Student();//先呼叫父類構造方法，再呼叫子類構造方法
	}
}

執行結果：
1.**************
2.##############

//面試題

abstract class Person{
	public Person(){//3.呼叫父類構造
		this.print();//4.呼叫被子類覆寫的方法
	}
	public abstract void print();//抽象方法
}

class Student extends Person{
	private int num = 100;//此句在物件new成功後才會用到
	public Student(int num){//2.呼叫子類例項化物件
		// super();//3.隱含這一句，實際要先呼叫父類構造
		this.num=num;//7.為類中屬性初始化
	}
	public void print(){//5.此時子類物件的屬性還沒有被初始化
		System.out.println(this.num);//6.輸出其對應資料型別的預設值，為0
	}
}

public class Test{
	public static void main(String[] args){
		new Student(30);//1.例項化子類物件
	}
}
//父類中num=0，子類中num=30。但由於子類中沒有呼叫列印方法，所以只有一個父類的num值，為0。
執行結果：0

（2）抽象類中可以不定義抽象方法，但仍然無法直接例項化物件。

（3）abstract與final、private不能一起用。

• final宣告的類不允許有子類，而abstract抽象類必須有子類。
• 抽象方法必須要被覆寫，因此不能用private封裝。
  （4）抽象類也分為內部抽象類和外部抽象類。
• 內部抽象類（瞭解）可以使用static定義來描述外部抽象類
  
  如果此時在外部抽象類中使用static就會出現語法錯誤，但是內部抽象類允許使用static

//內部抽象類使用static修飾

abstract class A{//此結果出現機率很低
	public abstract void printA();
	static abstract class B{
		public abstract void printB();
	}
}
class x extends A.B{
	public void printB(){}
}

注意：物件例項化的核心步驟
  ①類載入
  ②類物件的空間開闢
  ③類物件中的屬性初始化（構造方法）

方法可以重寫，屬性不能重寫。