天天看點
傳回

JavaOOP面向對象程式設計JavaOOP面向對象程式設計

文章目錄

  • JavaOOP面向對象程式設計
    • 一、回顧Java
      • 1、面向對象
      • 2、構造函數和方法重載
    • 二、Java中的繼承與多态
      • 1、繼承
      • 2、多态
    • 三、Java中的接口
      • 1、接口的概念
        • 1.1 為什麼需要接口
        • 1.2 接口的定義
      • 2、Java中的接口
      • 3、C#中的接口
    • 四、總結

JavaOOP面向對象程式設計

一、回顧Java

1、面向對象

我們在程式設計中多次提到對象，而程式設計的目的就是實作模拟現實的方法設計和開發程式，這就是面向對象。

“面向對象”是一個抽象的概念，難點就在于如何從現實中抽出“類”。類就是對某一類的概念上的描述，需要注意的是類并不是具體的事物，類的對象才是現實的、具體的事物。

是以，對象與類互動的過程就是計算機與人的交流。

2、構造函數和方法重載

構造函數和方法重載的用法與c#并無差別：

構造函數文法：

通路修飾符 類名(){
    //内容
}

1、類似方法，隻是少了一個傳回值。

2、方法名有要求：跟類名一緻。

3、構造函數也是會被重載。

方法重載定義：

1、在同一個類中。

2、相同的方法名。

3、不同的參數：

1、個數不相同。

2、對應的參數下标的參數類型不同。

示例：

public class Penguin {
	String name = "無名氏";
	int health = 100;
	int love = 0;
	String sex = "Q仔";
	
	public Penguin() {
		name = "楠楠";
		love = 20;
		sex = "Q妹";
		System.out.println("執行構造方法");
	}
	
	public Penguin(String name, String sex) {
		this.name = name;
		this.sex = sex;
	}
	
	public Penguin(String name,int health,int love, String sex) {
		this.name = name;
		this.health = health;
		this.love = love;
		this.sex = sex;
	}
	
	public void print() {
		System.out.println("寵物的自白：\n我的名字叫" + this.name + ",健康值是" + this.health + ",和主人的親密度是" + this.love + ",性别是" + this.sex + "。");
	}
	
	public static void main(String[] args) {
		Penguin pgn = null;
		pgn = new Penguin();
		pgn.print();
		pgn = new Penguin("亞亞","企鵝");
		pgn.print();
		pgn = new Penguin("美美",80,20,"Q仔");
		pgn.print();
	}
}

二、Java中的繼承與多态

1、繼承

定義：繼承是描述2個類之間的關系。

c#與java的繼承是有所不同的。

java繼承文法：

文法：

修飾符 class 子類名 extends 父類名{
    //内容
}

從文法可以看到繼承的關鍵字是“extends”與c#的“:”是完全不同的。

示例：

//父類
public class Pet {
	private String name = "無名氏";
	private int health = 100;
	private int love = 0;
	
	public Pet() {
		this.health = 95;
		System.out.println("執行寵物的無參構造方法");
	}
	
	public Pet(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getHealth() {
		return health;
	}
	
	public int getLove() {
		return love;
	}
	
	public void print() {
		System.out.print("寵物的自白：\n我的名字叫" + this.name + ",我的健康值是" + this.health + ",我和主人的親密度是" + this.love + "。");
	}
}
           
//子類
public class Penguin extends Pet{
	private String sex;
	
	public Penguin(String name,String sex) {
		super(name);
		this.sex = sex;
	} 
	
	public String getSex() {
		return sex;
	}
	
	public void print() {
		super.print();
		System.out.println("性别是" + this.sex + "。");
	}
}
           
//測試類
public class Test {
	public static void main(String[] args) {
		Penguin pgn = new Penguin("楠楠", "Q妹");
		pgn.print();
	}
}

2、多态

定義：一個事務的多種形态。

實作方式：重載和重寫。

從以上代碼中可以看到，重寫時與c#不同的是不用加上“override”關鍵字來辨別的，當然前提是兩個類必須有繼承關系。

另外重寫還需注意：

  1. 不同的類中。
  2. 相同的方法名。
  3. 相同參數。
  4. 通路修飾符：子類方法的通路權限必須大于等于父類方法的通路權限
  5. 傳回值類型：父類的傳回值類型必須包含子類的傳回值類型。（比如說：父類的傳回值是一個類，那子類重寫時傳回值類型可以是這個類裡的屬性）

和c#一樣java也有抽象類和抽象方法。

文法：

public abstract class 父類名{
    public abstract void 方法名();
}

抽象類與c#相比沒有什麼差別，隻是也不用上“override”關鍵字來辨別。

示例：

//父類，寵物類
public abstract class Pet {
	protected String name = "無名氏";
	protected int health = 100;
	protected int love = 0;
	
	public Pet() {
		this.health = 95;
		System.out.println("執行寵物的無參構造方法");
	}
	
	public Pet(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getHealth() {
		return health;
	}
	
	public int getLove() {
		return love;
	}
	
	public void print() {
		System.out.print("寵物的自白：\n我的名字叫" + this.name + ",我的健康值是" + this.health + ",我和主人的親密度是" + this.love + "。");
	}
	
	public abstract void eat();
}
           
//子類，企鵝類
public class Penguin extends Pet{
	private String sex;
	
	public Penguin(String name,String sex) {
		super(name);
		this.sex = sex;
	} 
	
	public String getSex() {
		return sex;
	}
	
	public void print() {
		super.print();
		System.out.println("性别是" + this.sex + "");
	}
	
	public void eat() {
		super.health = super.health + 5;
		System.out.println("企鵝" + super.name + "吃飽了！健康值增加5。");
	}
	
	public void swimming() {
		System.out.println("企鵝" + super.name + "正在遊泳。");
		super.health = super.health - 10;
		super.love = super.love + 5;
	}
}
           
//子類，狗狗類
public class Dog extends Pet {
	private String strain;
	
	public Dog(String name,String strain) {
		super(name);
		this.strain = strain;
	} 
	
	public String getStrain() {
		return strain;
	}
	
	public void print() {
		super.print();
		System.out.println("我是一隻" + this.strain + "");
	}
	
	public void eat() {
		super.health = super.health + 3;
		System.out.println("狗狗" + super.name + "吃飽了！健康值增加3.");
	}
	
	public void catchingFlyDisc() {
		System.out.println("狗狗" + super.name + "制作接飛盤.");
		super.health = super.health - 10;
		super.love = super.love + 5;
	}
}
           
//主人類
public class Master {
	private String name = "";
	private int money = 0;
	
	public Master() {}
	
	public Master(String name,int money) {
		this.name = name;
		this.money = money;
	}
	
	public void feed(Pet pet) {
		pet.eat();
	}
	
	public void feed(Dog dog) {
		dog.eat();
	}
	
	public void feed(Penguin pgn) {
		pgn.eat();
	}
	
	public Pet getPet(int typeId) {
		Pet pet = null;
		if (typeId == 1) {
			pet = new Dog("歐歐", "雪納瑞");
		} else if (typeId == 2) {
			pet = new Penguin("楠楠", "Q妹");
		}
		return pet;
	}
	
	public void play(Pet pet) {
		if (pet instanceof Dog) {
			Dog dog = (Dog)pet;
			dog.catchingFlyDisc();
		} else if (pet instanceof Penguin) {
			Penguin pgn = (Penguin)pet;
			pgn.swimming();
		}
	}
}
           
//測試類
public class Test {
	public static void main(String[] args) {
		Master master = new Master("王先生",100);
		Scanner input = new Scanner(System.in);
		System.out.println("歡迎來到寵物店！");
		System.out.print("請輸入要領養寵物的類型：（1、狗狗 2、企鵝）");
		int typeId = input.nextInt();
		Pet pet = master.getPet(typeId);
		if (pet != null) {
			System.out.println("領養成功！");
			master.feed(pet);
			master.play(pet);
		} else {
			System.out.println("對不起，沒有此類型的寵物，領養失敗！");
		}
	}
}

抽象方法的應用在于必須讓子類擁有的動作(方法)，也可以說讓事物更加具體、豐滿。

三、Java中的接口

1、接口的概念

1.1 為什麼需要接口

接口在現實中廣泛存在，我們最熟悉的就是“USB接口”了。在這裡我帶大家回顧一下曆史，在個人計算機成為流行的時候，我們需要在電腦上裝軟體是需要用軟碟的，過了一段時間CD光牒和移動硬碟流行了起來，到現在大多數人使用的就隻剩下移動硬碟或者說是U盤了。

那接口在其中有什麼作用呢？

接口是聯通兩個事物的橋梁，你如果需要即可相連，當然不需要的時候直接斷開就行，或者更換。代碼中的接口也是起到這個作用的，它讓我們的代碼不需要在每一種情況下定義不同的類，大大的提高了代碼的複用率。

1.2 接口的定義

文法：

修飾符 interface 接口名 {
	//接口成員
}

特點：

  1. 不能被執行個體化(因為本身就是抽象類)；

  2. 成員方法：隻能是抽象方法，通路修飾abstract；

    ​ 預設通路修飾:public abstract；

  3. 成員變量：隻能定義靜态常量；

    ​ 預設通路符：public static final；

  4. 不能有構造函數

作用：限制子類必須擁有某種行為(方法)。

2、Java中的接口

實作文法：

public class 類名  extends 父類名 implements 接口名1, 接口名2... {
	//接口方法
}
           
修飾符 interface 接口名 extends 父接口1,父接口2... {
	//接口成員
}

從文法中不難發現，接口是可以在類或接口中有多個的。

示例：

//父類，門類
public abstract class Door {
	public abstract void open();
	public abstract void close();
}
           
//接口類，鎖門和開門類
public interface Lock {
	void lockUp();
	void openLock();
}
           
//子類，防盜門類
public class TheftDoor extends Door implements Lock {
	
	public void lockUp() {
		System.out.println("插進鑰匙，向左旋轉鑰匙三圈，鎖上了，拔出鑰匙。");
	}
	
	public void openLock() {
		System.out.println("插進鑰匙，向右旋轉鑰匙三圈，鎖打開了，拔出鑰匙。");
	}
	
	public void open() {
		System.out.println("用力推，門打開了。");
	}
	
	public void close() {
		System.out.println("輕輕拉門，門關上了。");
	}
}
           
//測試類
public class DoorTest {
	public static void main(String[] args) {
		TheftDoor tfd = new TheftDoor();
		tfd.close();
		tfd.lockUp();
		tfd.openLock();
		tfd.open();
	}
}

在運作了以上代碼後可以看到模拟了一個防盜門的功能，并且按照現實來說，并不是每一扇門都有上鎖的功能。接口的意義就在這裡，也可以說接口讓每一個對象都是獨特的。

3、C#中的接口

實作文法：

public class 類名 : 父類, 接口1，接口2... {
	//接口方法
}
           
修飾符 interface 接口名 : 父接口1,父接口2... {
	//接口成員
}

c#中的接口實作java相比：

  1. 把關鍵字改成“:”。
  2. 直接在繼承的父類後用“,”隔開書寫即可。
  3. 定義屬性和定義方法的修飾雖然有預設值但是不可顯示定義。

有興趣可以試着把“門”這個示例在c#中重新編寫一遍。

四、總結

在java的學習中有了較好的基礎後，在運用基繼承和接口時就能明顯的感受到它們給我們帶來的好處。結合實際中的例子就可以更好地了解為什麼需要這樣做，這樣就能真正看懂代碼，以及如何在生活中運用它。

面向對象程式設計
上一篇: JavaScript中的面向對象程式設計
下一篇: 疊代器、可疊代對象及面向對象基礎

繼續閱讀