1.面向物件程式設計有三大特點，分別是封裝，繼承，多型，接下來就介紹一下這三個特點，積累一下。

2.封裝，封裝是面向物件程式設計的核心思想，將物件的屬性和行為封裝起來，而將物件的屬性和行為封裝起來的載體是類，類通常對使用者隱藏其實現的細節，這就是封裝的思想，在Java中通常通過建立一個實體類，用來封裝物件的屬性和行為，通過setXxx()和getXxx()方法封裝起來，例如，使用者在使用一款軟體的時候，只需知道如何使用軟體，點選某個按鈕就可以實現一定的功能，使用者不需要知道軟體是如何被開發出來的，軟體內部是如何工作的，在使用該軟體時不依賴於開發時的細節和軟體內部工作的細節。

採用封裝的思想保證了類內部資料結構的完整性，應用該類的使用者不能輕易直接操縱該資料結構，而只能執行該類允許公開的資料。這樣可以避免外部對內部資料的影響，提高程式的可維護性。

總結一下，封裝性就是利用抽象資料型別將資料和基於資料的操作封裝在一起，保護資料並隱蔽具體的細節，只保留有限的介面與外界聯絡。

接下來附上一個封裝的例子，定義一個實體類，宣告屬性為私有的，通過setXxx()和getXxx()的公共方法來封裝資料(即封裝屬性)，利用this關鍵字來引用成員變數，最後通過建立一個測試類來呼叫setXxx()和getXxx()方法，其中實體類中有兩個構造方法，一個為無參構造方法，一個為有參構造方法，程式碼如下所示：

Student.java檔案，實體類程式碼：

package tom.bean;

/*
 * 學生實體類
 */
public class Student {
	private String name;// 宣告一個私有字串變數，表示姓名
	private int age;// 宣告一個私有整型變數，表示年齡
	private String sex;// 宣告私有一個私有字串變數，表示性別
	private String major;// 宣告一個私有字串變數，表示專業

	public Student() { // 無參構造方法
	}

	public Student(String name, int age, String sex, String major) { // 有參構造方法
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.major = major;
	}

	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;
	}

	public String getSex() {	//獲得性別的方法
		return sex;
	}

	public void setSex(String sex) {	//設定性別的方法
		this.sex = sex;
	}

	public String getMajor() {	//獲得專業的方法
		return major;
	}

	public void setMajor(String major) {	//設定專業的方法
		this.major = major;
	}

}
 

Test.java檔案，測試類程式碼：

package tom.test;

import tom.bean.Student;

public class Test {
	public static void main(String[] args){
		Student student=new Student();//例項化Student物件
		/*設定各個屬性的內容*/
		student.setName("Lc");
		student.setAge(22);
		student.setSex("男");
		student.setMajor("軟體工程專業");
		/*獲得學生各個屬性的內容，列印輸出資訊*/
		System.out.print("第一位學生的資訊如下:"+"\n"+"姓名為"+student.getName());
		System.out.print(",年齡為"+student.getAge());
		System.out.print(",性別為"+student.getSex());
		System.out.print(",專業為"+student.getMajor());
		
		Student student1=new Student("123nh", 21, "女", "英語專業");
		System.out.print("\n");
		System.out.print("第二位學生的資訊如下:"+"\n"+"姓名為"+student1.getName());
		System.out.print(",年齡為"+student1.getAge());
		System.out.print(",性別為"+student1.getSex());
		System.out.print(",專業為"+student1.getMajor());
	}
}
 

執行測試類後結果如下：

3.繼承性，簡單來說就是使子類的物件擁有父類的全部屬性和行為，同時可以增添自己的所特有的屬性和行為。這樣可以節省寫共同具有的屬性和方法程式碼的時間，有利於程式碼的複用，這就是繼承的基本思想。軟體的程式碼使用繼承思想可以縮短軟體開發的時間，複用那些已經定義好的類可以提高系統和軟體的效能，減少系統和軟體在使用過程中出現錯誤的機率。一個類可以是其他類的父類，為其他類提供屬性和行為，也可以是其他類的子類，繼承父類的屬性和方法，子類的例項都是父類的例項，但不能說父類的例項是子類的例項。

繼承的實現，在Java語言中，繼承通過extends關鍵字來實現，用這個extends關鍵字時指明當前的類為子類，並指明從哪個類繼承而來，即在子類的宣告中，通過使用extends關鍵字來指明其父類，其基本格式如下：

修飾符 class 子類名 extends 父類名{

類體

}

接下來附上一個小例子，定義一個People類，其中有姓名，年齡和性別屬性和setXxx()和getXxx()的方法，作為父類，在定義一個Student類，繼承於父類，作為子類，在子類中只定義2個屬性，一個學號，一個專業，再定義一個Test測試類，例項化子類，利用子類物件呼叫父類的屬性和方法，具體見程式碼：

目錄結構如下圖：

People.java檔案程式碼：

package tom.bean;

/*
 * 定義一個人類，作為Student的父類
 */
public class People {
	private String name;//宣告一個私有變數，表示姓名
	private int age;//宣告一個私有變數，表示年齡
	public String sex="男";//宣告一個公有變數，表示性別，初始化為男
	
	public People() {	//無參構造方法
	}

	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;
	}

	public String getSex() {	//獲得性別方法
		return sex;
	}

	public void setSex(String sex) {	//設定性別方法
		this.sex = sex;
	}
	
	
}

Student.java檔案程式碼：

package tom.bean;

/*
 * 定義一個學生類，繼承於人類，作為子類
 */
public class Student extends People{
	private String stuId;//宣告一個變數，表示學號
	private String major;//宣告一個變數，表示專業
	
	public Student(){	//定義無參構造方法		
	}

	public String getStuId() {	//獲得學號方法
		return stuId;
	}

	public void setStuId(String stuId) {	//設定學號方法
		this.stuId = stuId;
	}

	public String getMajor() {	//獲得專業方法
		return major;
	}

	public void setMajor(String major) {	//設定專業方法
		this.major = major;
	}
	
	
}

Test.java檔案的程式碼：

package tom.test;

import tom.bean.Student;

/*
 * 測試類，例項化子類，呼叫父類的屬性和方法，也呼叫自己所特有的方法
 */
public class Test {
	//主方法
	public static void main(String[] args) {
		Student student = new Student();//例項化Student類
		student.setName("Xg");//呼叫父類People類的設定姓名的方法
		student.setAge(22);//呼叫父類People類的設定年齡的方法
		student.setStuId("2012131735");//呼叫Student類的設定學號的方法
		student.setMajor("軟體工程");//呼叫Student類的設定專業的方法
		/*列印輸出學生資訊*/
		System.out.println("學生資訊如下：");
		System.out.print("姓名為"+student.getName());
		System.out.print("，年齡為"+student.getAge());
		System.out.print("，性別為"+student.sex);
		System.out.print("，學號為"+student.getStuId());
		System.out.print("，專業為"+student.getMajor());
	}
}

執行Test.java檔案後，結果如下圖所示：

4.多型性，簡單來說就是一個程式中同名的多個不同方法共存的情況，通常使用方法的過載和重寫（也叫覆蓋）來實現類的多型性，多型性允許以統一的風格編寫程式，以處理種類繁多的已存在的類以及相關類，多型的實現並不依賴具體類，而是依賴抽象類和介面，在多型的機制中，父類通常會被定義為抽象類，在抽象類中給出一個方法的標準，而不給出實現的具體過程，通過繼承父類來實現，而比抽象類更方便的是將抽象類定義為介面。這裡先暫時介紹到這裡，多型中使用方法的重寫和過載以後在專門寫一篇文章！以免這篇文章篇幅過長！

5.以上就是面向物件程式設計的三大特點，僅供大家學習參考，寫得不好請見諒，如有錯誤請指出，謝謝！