JavaSE入門學習24：Java面向對象補充

一Java中的Object類

Object類是所有Java類的父類，如果一個類沒有使用extends關鍵字明確標識繼承另外一個類，那麼這個類默認

繼承Object類。

public class Person{
      //
}
//等價於
public class Person extends Object{
     //
}

Object類中的方法，適合所有子類。

1)toString()方法

在Object類中定義有public String toString()方法，其返回值是String類型，描述當前對象的有關信息，在進行

String與其類型數據的連接操作時(如：System.ouy.println("info"+person))，將自動調用對象類的toString()方法。也可

以根據需要在用戶自定義類型中重寫toString()方法

實例：

public class Test{
	public static void main(String[] arge){
		Dog d = new Dog();
		System.out.println(d);
		System.out.println("d："+d);
		System.out.println("d："+d.toString());
	}
}

class Dog{
	public String toString(){
		return "I am a dog";
	}
}

運行結果：

2)equals()方法

比較的是對象的引用是否指向同一塊內存地址。一般情況下比較兩個對象時比較它們的值是否一致，所以要進行

重寫。

Object類中定義有：public boolean equals(Object obj)方法提供定義對象類型

實例：

public class Test{
	public static void main(String[] arge){
                String s1 = new String("hello");
		String s2 = new String("hello");
		System.out.println(s1 == s2);//比較對象的地址
		System.out.println(s1.equals(s2));//比較對象的內容
        }
}

運行結果：

二對象轉型(casting)

一個基類的引用類型變量可以指向其子類的對象；

一個基類的引用不可以訪問其子類對象新增的成員(屬性和方法)；

可以使用 引用變量 instanceof 類名 來判斷該引用型變量所指向的對象是否屬於該類或該類的子類。

向上轉型是基類或父類的引用指向子類對象。

這個在前面的例子中我們遇到很多，這裡就不再多說，可以參考：JavaSE入門學習18：Java面向對象之多態。

三動態綁定(池綁定)與多態

動態綁定是指在執行期間(而非編譯期)判斷所引用對象的實際類型，根據其實際的類型調用其相應的方法。

下面例子中，根據Lady對象的成員變量pet所引用的不同的實際類型而調用相應的enjoy()方法。也就是你new的是

那個類型調用的就是該類型的enjoy()方法

實例代碼：

class Animal{
	private String name;
	
	//構造方法
	Animal(String name){
		this.name = name;
	}
	
	public void enjoy(){
		System.out.println("叫聲......");
	}
}


class Cat extends Animal{
	private String eyesColor;
	
	//構造方法
	Cat(String name,String eyesColor){
		//調用父類的構造函數
		super(name);
		this.eyesColor = eyesColor;
	}
	
	//重寫父類Animal的enjoy()方法
	public void enjoy(){
		System.out.println("貓叫聲......");
	} 
}


class Dog extends Animal{
	private String furColor;
	
	//構造方法
	Dog(String name,String furColor){
		//調用父類的構造方法
		super(name);
		this.furColor = furColor;
	}
	
	//重寫父類Animal的enjoy()方法
	public void enjoy(){
		System.out.println("狗叫聲......");
	} 
}


class Lady{
	private String name;
	//引用類型變量成員
	private Animal pet;
	
	//構造函數
	Lady(String name,Animal pet){
		this.name = name;
		this.pet = pet;
	}
	
	public void myPetEnjoy(){
		pet.enjoy();
	}
}


public class Test{
	public static void main(String[] arge){
		Cat c = new Cat("catname","blue");
		Dog d = new Dog("dogname","black");
		
		Lady l1 = new Lady("l1",c);
		Lady l2 = new Lady("l2",d);
		
		l1.myPetEnjoy();
		l2.myPetEnjoy();
	}
}

運行結果：

對於可擴展性的理解：

改寫上述的例子：

添加一個Bird類：

class Bird extends Animal{
	//構造方法
	Bird(){
		//調用父類的構造方法
		super("bird");
	}
	
	//重寫父類Animal的enjoy()方法
	public void enjoy(){
		System.out.println("鳥叫聲......");
	} 
}

改寫main方法：

public class Test{
	public static void main(String[] arge){
		Cat c = new Cat("catname","blue");
		Dog d = new Dog("dogname","black");
		Bird b = new Bird();
		
		Lady l1 = new Lady("l1",c);
		Lady l2 = new Lady("l2",d);
		Lady l3 = new Lady("l3",b);
		
		l1.myPetEnjoy();
		l2.myPetEnjoy();
		l3.myPetEnjoy();
	}
}

運行結果：

多態特性對於系統可擴充性的重要性

繼續改寫鳥類：

class Bird extends Animal{
	private String featherColor;
	
	//構造方法
	Bird(String name,String featherColor){
		//調用父類的構造方法
		super(name);
		this.featherColor = featherColor;
	}
	
	//重寫父類Animal的enjoy()方法
	public void enjoy(){
		System.out.println("鳥叫聲......");
	} 
}

改寫mian方法：

public class Test{
	public static void main(String[] arge){
		Lady l4 = new Lady("l4",new Bird("birdname","green"));
		l4.myPetEnjoy();
	}
}

運行結果：

多態的條件：

1)要有繼承

3)父類引用指向子類對象