目錄

• 1.面向物件概述
  • 1.1.類與物件的關係
  • 1.2.類的具體描述
• 2.面向物件的三大特性
  • 2.1.繼承
  • 2.2.多型
  • 2.3.封裝

1.面向物件概述

1.1.類與物件的關係

有物件嗎，沒有的話我給你new一個！
物件顧名思義就是一個個的個體，當所有的個體，例如人的總稱為人類，這一類的生物或者物品。人類是對人這種個體的抽象化，不會說你是個人類，而是說你是個人，所以人就是人類的具體實現。
簡而言之，類是物件的抽象化，物件是類的具體實現。
正所謂Java主打的萬物皆物件。

public class Person{
	private String name;
	private int age;
	private String gender;
	
	public Person(String name, int age, String gender){
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	public void say(){
		System.out.println("hello");
	}
	
	public static void main(String[] args){
		Person p = new Person("張三", "22", "男");
		p.say();
	}
}
 

在上面程式碼中，類Person就是人的一種抽象化，每個人都有姓名、年齡、性別等屬性和一些動作，比如說等。在main方法中我們使用關鍵字new將類具體化為一個物件，這個物件名張三、22歲、男性，並且說了hello。

1.2.類的具體描述

類Person中有屬性name、age、gender等，方法say等。還有個比較特殊的方法public Person(...)，這個方法就是類的構造器。
構造方法又成為構造器，和一般的方法不同的是：

• 沒有返回值（沒有返回型別，也沒有void）
• 方法名和類名一樣

一個類可以有多個構造方法，這是後面要說到的過載。

2.面向物件的三大特性

面向物件程式設計的優點：

• 可擴充套件
• 可重用

缺點：

• 複雜程度較高

2.1.繼承

繼承就是子類繼承父類的特徵和行為，得到父類的例項變數和方法。例如貓和狗都是動物，可以繼承動物的一些通用特徵和行為。
為什麼需要繼承？
如果沒有繼承，當我們寫貓和狗的類時：

public class Cat {
	private String name;
	private int age;
	public Cat(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void eat() {
		System.out.println(name+"吃東西");
	}
	public void sleep() {
		System.out.println(name+"睡覺");
	}
}
 

public class Dog {
	private String name;
	private int age;
	public Dog(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void eat() {
		System.out.println(name+"吃東西");
	}
	public void sleep() {
		System.out.println(name+"睡覺");
	}
}

發現我們寫了很多重用的程式碼，比如屬性name、age和方法eat、sleep等。
如果使用繼承程式碼將變成怎麼樣呢？

public class Animal {
	private String name;
	private int age;
	public Animal(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void eat() {
		System.out.println(name+"吃東西");
	}
	public void sleep() {
		System.out.println(name+"睡覺");
	}
}

public class Cat extends Animal {
	public Cat(String name, int age) {
		super(name, age);
	}
}

public class Dog extends Animal {
	public Dog(String name, int age) {
		super(name, age);
	}
}

我們發現只需要寫一個父類，子類就具有父類的屬性和方法了，這樣我們就不需要寫那麼多重複的程式碼了，提高了程式碼的複用性。
總結以下：

• 子類擁有父類的非private的屬性、方法，這裡private之前說過，所修飾的只能在同一個類中可見
• 子類可以對父類進行擴充套件
• 子類可以重寫父類的方法
• Java中不支援多繼承

重寫和過載：

• 重寫（override）：貓和魚都繼承了動物類，如果動物類有一個方法叫run()，對於貓來說使用四肢奔跑，對於魚來說使用魚鰭遊動。這時我們需要重寫父類的方法：

public class Person {
	public void run() {
		System.out.println("動物跑起來了");
	}
}

public class Cat {
	@Override
	public void run() {
		System.out.println("貓跑起來了");
	}
}

public class Fish {
	@Override
	public void run() {
		System.out.println("魚遊起來了");
	}
}

• 過載（overload）：同一個類中，方法名相同，引數不同，返回值可以相同或不同。

public class Animal {
	public void test() {}
	public void test(int num) {}
	public void test(String str) {}
	public void test(int num, String str) {}
	public void test(String str, int num) {}
}

2.2.多型

多型就是同一個行為具有不同的表現形式。
多型分類：

• 編譯時多型：靜態的，主要是方法的過載
• 執行時多型：動態繫結實現的，例如父類的引用指向子類的物件

實現多型的必要條件：

• 繼承
• 重寫
• 向上轉型：父類的引用指向子類的物件

多型的優點：

• 消除耦合關係
• 可擴充套件性
• 簡單易用

多型的實現方式：

• 重寫
• 介面：可多實現介面，解決單繼承的缺陷

public interface Animal {
	public void run();
}

public class Cat implements Animal {
	@Override
	public void run() {
		System.out.println("貓趴");
	}
}

• 抽象類和抽象方法：抽象類中可以存在非抽象方法，抽象方法一定存在於抽象類中，抽象方法只宣告不實現，繼承的子類必須實現抽象類中的抽象方法

public abstract Animal {
	public abstract void run();
}

public class Cat extends Animal {
	@Override
	public void run() {
		System.out.println("貓趴");
	}
}

2.3.封裝

封裝將類的實現細節隱藏，以保證程式和資料不受外部干擾，保護資訊。
優點：

• 保護類中的東西，隱藏資訊，實現細節
• 良好的封裝可以減少耦合
• 類內部結構可以自由修改
• 可以精確控制類成員

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

將類的屬性設定為private，然後對外提供public方法進行賦值和取值。