java面向對象一：實作繼承、重載、重寫

一、繼承：根據現有類（一個寫好的類）的功能來建立新類（利用現有類建立）的過程

1、實作關鍵字extends

2、實作繼承的好處：可以直接通路父類非私有的一些屬性和方法

//dog子類或者派生類；Animal父類或者基類；或者dog派生至Animal
public class dog extends Animal {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		dog d = new dog();
		d.name = "dog";// 繼承了animal，可以調用公有的方法
		d.eat();
		//d.age();//私有的屬性子類不能通路
<pre name="code" class="java">        }
           

public class Animal {

    public String name="Animal";
    private String age;
    protected String money;//protected修飾的變量:同一個包下所有類可以用；位于其他包的子類也可以通路
    public void eat()
    {
        System.out.println(name+"正在吃東西");
    }
}
}
           

3、繼承中通路說明符的差別：

4、super關鍵字：當子類與父類屬性同名時，要通路父類的屬性，需要使用super關鍵字

5、繼承父類構造方法：

1）執行個體化子類時會調用父類的構造方法。先調用父類的構造方法，再調用子類的構造方法。

2）子類的構造方法會預設調用父類不帶參數的構造方法（無論顯示的還是不顯示的）。

3）如果顯示調用父類不帶參數的構造方法，使用super();，必須寫在子類構造方法的第一行。

4）如果顯示調用父類帶參數的構造方法，使用super(參數);，必須寫在子類構造方法的第一行；super();與super(參數);同時隻能調用一個：

public class dog extends Animal {
	
	public dog()
	{
		super("abc");
		System.out.println("dog的構造方法");
	}
           

5）如果想要執行個體化的時候去實作一些邏輯的，可以顯示寫出來構造方法

6、子類和父類的類型轉換：向上轉型、向下轉型

public class dog extends Animal {

	private String name="dog";
	public static void main(String[] args)
	{
		Animal d1 = new Animal();
		Animal d2 = new dog();<span style="color:#FF0000;">//向上轉型，将父類d1(向上轉型)執行個體化為dog()對象,自動</span>
		System.out.println(d1.name);
		System.out.println(d2.name);
		dog d=(dog)d2;<span style="color:#FF0000;">//向下轉型，将父類還原為子類，非自動</span>
		System.out.println(d.name);
		//dog d3=(dog)d1;//子類的引用不能指向父類的對象
        }
}
           

特殊情況：instanceof運算符：左邊代表判斷某個對象是不是某個類/接口/抽象類的類型，用于轉型前的判斷

System.out.println(d1 instanceof dog);//d1不是dog對象，傳回false
System.out.println(d2 instanceof dog);//d2是dog對象，傳回true
           

二、多态：一個對象不同的表現形态（重載/重寫）

1、靜态多态（重載） 同名的方法，具有不同參數清單（使用更靈活）：

1）參數的個數不同

2）參數的順序不同

3）參數的資料類型不同

public class OverloadingDemo {
	//方法簽名：public void add(int add1,int add2)
	//方法名稱相同，java允許一個類裡面可存在方法名相同，但不允許整個方法簽名相同
	public void add(long add1,float add2)
	{
		
	}
	public void add(long add1,int add2,int add3)//參數個數不同
	{
		
	}
	public void add(long add1,long add2)//參數資料類型不同
	{
		
	}
	public void add(int add1,long add2)//參數順序不同
	{
		
	}
	public int add(int add1,int add2)//不算重載
	{
	    return 0;
	}
	
}
           

調用時根據輸入的參數不同，調用不同的重載方法：

OverloadingDemo o=new OverloadingDemo();
o.add(100, 100.1f);
o.add(100, 100L);//自動根據參數，自動調用重載的方法
           

2、動态多态（重寫:override，子類覆寫父類的方法）：java代碼執行時，JVM需要動态判斷調用子類方法還是父類方法，判斷是動态的過程。重寫規則：

1）private的方法不能重寫。

2）final的方法不能重寫。

3）子類重寫的方法的通路權限級别 >= 父類被重寫方法的通路權限，如父類中protected、預設的修飾的方法，子類重寫時，隻能是public、protected、預設的。

      通路權限級别的順序：從高到低 public >protected>預設的>private

//父類
public class Car {

	public void run()
	{
		System.out.println("開車");
	}
	protected void fly()
	{
		System.out.println("開車");
	}
}
           

//子類
public class Bmw extends Car {
	//重寫了父類的run方法
	public void run()
	{
		System.out.println("Bmw開起來更快");
	}
	public void fly()
	{
		System.out.println("開車");
	}
	public static void main(String[] args)
	{
		Bmw b=new Bmw();
		b.run();//調用子類的run方法
        }
}