目錄
一、面向對象介紹
二、類和對象
1. 類(Class):對象的模板
2. 對象(Object):類的實例
三、封裝
1. 封裝的概念
2. 封裝的優勢
四、就近原則和 this 關鍵字
1. 就近原則
2. this 關鍵字
五、構造方法
1. 構造方法的作用
2. 構造方法的特點
3. 默認構造方法
六、標準的 JavaBean 類
七、對象內存圖(三種情況)
1. 單個對象的內存圖
2. 兩個對象的內存圖
3. 兩個引用指向同一對象
八、基本數據類型和引用數據類型(面向對象視角)
九、this 的內存原理
十、成員變量和局部變量
總結
一、面向對象介紹
面向對象編程(OOP)是一種以 "對象" 為核心的編程思想,它將現實世界中的事物抽象為程序中的 "對象",通過對象之間的交互完成功能。
與面向過程的區別:
- 面向過程:關注 "步驟",如 "先做什么,再做什么"(例:按步驟實現登錄功能)
- 面向對象:關注 "對象",如 "用戶對象"" 登錄界面對象 ",通過對象協作完成功能
面向對象三大特征:
- 封裝:隱藏對象內部細節,只暴露必要接口
- 繼承:實現類之間的代碼復用
- 多態:同一行為的不同表現形式
優勢:代碼更易維護、擴展,更符合人類對現實世界的認知。
二、類和對象
1. 類(Class):對象的模板
類是對同一類事物的抽象描述,包含這類事物的屬性(數據)和方法(行為)。
// 類的定義:描述"學生"這類事物
public class Student {// 屬性(成員變量):學生的特征String name;int age;// 方法:學生的行為public void study() {System.out.println(name + "正在學習");}
}
2. 對象(Object):類的實例
對象是類的具體 "實例",是真實存在的個體。通過new
關鍵字創建對象。
public class Test {public static void main(String[] args) {// 創建對象:類名 對象名 = new 類名();Student stu1 = new Student();// 給對象的屬性賦值stu1.name = "張三";stu1.age = 18;// 調用對象的方法stu1.study(); // 輸出:張三正在學習// 再創建一個對象(另一個實例)Student stu2 = new Student();stu2.name = "李四";stu2.study(); // 輸出:李四正在學習}
}
類與對象的關系:類是模板,對象是根據模板創建的具體實例(如 "汽車圖紙" 與 "具體的汽車")。
三、封裝
封裝是面向對象的三大特征之一,此外還有繼承和多態。封裝的作用是在拿到一個需求之后,告訴我們如何正確的設計對象的屬性和方法。
1. 封裝的概念
封裝是指隱藏對象的內部細節(如屬性值),只通過公共方法對外提供訪問和修改的接口。
實現方式:
- 用
private
修飾屬性(私有屬性,僅本類可見) - 提供
public
的getter
(獲取屬性值)和setter
(修改屬性值)方法
public class Person {// 私有屬性:外部不能直接訪問private String name;private int age;// getter:獲取namepublic String getName() {return name;}// setter:修改namepublic void setName(String n) {name = n; // 可在此處添加驗證邏輯}// getter:獲取agepublic int getAge() {return age;}// setter:修改age,添加合法性驗證public void setAge(int a) {if (a > 0 && a < 150) { // 年齡必須在合理范圍age = a;} else {System.out.println("年齡不合法");}}
}
2. 封裝的優勢
- 保護數據安全(如限制年齡范圍)
- 隱藏實現細節(外部無需知道屬性如何存儲)
- 便于修改內部實現(不影響外部調用)
3. private關鍵字
- 是一個權限修飾符
- 可以修飾成員(成員變量和成員方法
- 被private修飾的成員只能在本類中才能訪問
示例:
四、就近原則和 this 關鍵字
1.局部變量與成員變量
(1). 成員變量(Member Variable)
-
定義位置:直接在類體中聲明,但在任何方法、構造器或代碼塊之外。
-
生命周期:隨著對象的創建而創建,隨著對象的銷毀而銷毀。
-
存儲位置:存在于堆內存的對象內部。
-
作用域:整個類內部都可見(受訪問修飾符限制)。
-
默認值:系統會自動賦予默認值(如
int
默認為0
,引用類型默認為null
)。 -
示例
public class Dog {String name = "旺財"; // 成員變量 }
(2). 局部變量(Local Variable)
-
定義位置:在方法、構造器、代碼塊或方法的參數列表中聲明。
-
生命周期:從聲明處開始,到所在代碼塊執行結束時銷毀。
-
存儲位置:存在于棧內存中。
-
作用域:僅在聲明它的代碼塊(方法、循環、條件語句等)內部可見。
-
默認值:沒有默認值,必須顯式初始化后才能使用。
-
示例
public void bark() {String name = "小白"; // 局部變量 }
特性 | 成員變量 | 局部變量 |
---|---|---|
定義位置 | 類中方法外 | 方法、構造器或代碼塊內 |
生命周期 | 與對象相同 | 與方法/代碼塊相同 |
存儲位置 | 堆內存 | 棧內存 |
作用域 | 整個類(受訪問控制修飾符限制) | 聲明它的代碼塊內 |
默認值 | 有(系統自動賦值) | 無(必須手動初始化) |
命名沖突處理 | 被局部變量覆蓋(就近原則) | 優先使用局部變量 |
2. 就近原則
當方法中出現局部變量與成員變量同名時,優先使用局部變量(離引用位置更近)。
因為當局部變量與成員變量同名時,在局部變量的作用域內,局部變量會“遮蔽”成員變量。若需訪問被遮蔽的成員變量,需使用 this
關鍵字。
public class Dog {String name = "旺財"; // 成員變量public void bark() {String name = "小白"; // 局部變量System.out.println(name + "在叫"); // 輸出:小白在叫(就近使用局部變量)}
}
3. this 關鍵字
this
代表當前對象的引用,用于:
- 區分同名的局部變量和成員變量
- 調用本類的其他方法或構造方法
public class Cat {String name; // 成員變量// 用this區分局部變量和成員變量public void setName(String name) {this.name = name; // this.name指成員變量,name指局部變量}public void eat() {System.out.println(this.name + "在吃"); // this可省略(無同名局部變量時)}
}
五、構造方法
1. 構造方法的作用
初始化對象(給對象的屬性賦初始值),在創建對象時自動調用。
2. 構造方法的特點
- 方法名與類名完全相同
- 沒有返回值類型(連
void
都不能寫) - 不能被
static
、final
等修飾
public class Book {String title;double price;// 無參構造方法public Book() {System.out.println("創建了一本書");}// 帶參構造方法:初始化時直接賦值public Book(String t, double p) {title = t;price = p;}
}// 調用構造方法
public class Test {public static void main(String[] args) {Book b1 = new Book(); // 調用無參構造Book b2 = new Book("Java編程", 59.9); // 調用帶參構造}
}
3. 默認構造方法
- 如果類中沒有定義任何構造方法,編譯器會自動生成一個無參構造方法
- 如果手動定義了構造方法,默認無參構造會失效(如需使用需手動添加)
六、標準的 JavaBean 類
JavaBean 是一種規范的類,用于封裝數據,遵循以下規則:
- 成員變量私有(
private
) - 提供無參構造方法
- 提供
getter
和setter
方法 - 可根據需要重寫
toString()
(方便打印對象信息)
public class User {// 1. 私有成員變量private String username;private String password;private int age;// 2. 無參構造public User() {}// 3. 帶參構造(可選)public User(String username, String password, int age) {this.username = username;this.password = password;this.age = age;}// 4. getter和setterpublic String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}// 5. 重寫toString()(可選)@Overridepublic String toString() {return "User{username='" + username + "', age=" + age + "}";}
}
七、對象內存圖(三種情況)
1. 單個對象的內存圖
棧內存 堆內存
+----------+ +----------------+
| 引用變量 | | 對象(User) |
| u ------+----------> username: null |
+----------+ | password: null|| age: 0 |+----------------+
- 引用變量(
u
)存于棧中,指向堆中的對象 - 對象的屬性在堆中,有默認值(引用類型為
null
,基本類型為對應默認值)
2. 兩個對象的內存圖
棧內存 堆內存
+----------+ +----------------+
| u1 ------+----------> username: "張三"|
+----------+ | age: 18 |
| u2 ------+----------+----------------+
+----------+ | username: "李四"|| age: 20 |+----------------+
- 兩個引用變量指向堆中不同對象,屬性各自獨立
3. 兩個引用指向同一對象
棧內存 堆內存
+----------+ +----------------+
| u1 ------+----------> username: "張三"|
+----------+ | age: 18 |
| u2 ------+----------+----------------+
+----------+
u1
和u2
指向同一對象,修改u1
的屬性會影響u2
八、基本數據類型和引用數據類型(面向對象視角)
類型 | 存儲方式 | 在對象中的表現 |
---|---|---|
基本數據類型 | 棧中直接存值 | 對象的屬性值直接存在堆中 |
引用數據類型 | 棧中存地址,堆中存值 | 對象的屬性存地址,指向另一對象 |
public class Person {int age; // 基本類型:值直接存在Person對象中String name; // 引用類型:存地址,指向堆中的字符串對象
}
九、this 的內存原理
this
是當前對象的引用,本質上是方法的一個隱藏參數,在創建對象時自動綁定到該對象。
public class Car {String color;public void setColor(String color) {this.color = color; // this指向調用該方法的對象}
}// 調用時
Car c = new Car();
c.setColor("紅色"); // 實際執行:setColor(c, "紅色"),this就是c
內存中:this
與對象的引用變量(如c
)存儲相同的地址,指向堆中的同一個對象。
十、成員變量和局部變量
區別 | 成員變量 | 局部變量 |
---|---|---|
定義位置 | 類中,方法外 | 方法內、方法參數、代碼塊中 |
作用域 | 整個類 | 僅在定義的方法 / 代碼塊中 |
默認值 | 有默認值(如 int 為 0,對象為 null) | 無默認值,必須初始化后使用 |
內存位置 | 堆內存(對象中) | 棧內存(方法棧幀中) |
生命周期 | 隨對象創建而存在,隨對象銷毀而消失 | 隨方法調用而存在,隨方法結束而消失 |
public class VariableDemo {int memberVar = 10; // 成員變量public void method() {int localVar = 20; // 局部變量System.out.println(memberVar + localVar);}
}
總結
面向對象編程是 Java 的核心思想,其核心是類和對象:類是模板,對象是實例。通過封裝保護數據,利用構造方法初始化對象,遵循JavaBean 規范實現標準化封裝。
理解this
關鍵字、成員與局部變量的區別、數據類型的存儲差異,以及對象在內存中的表現,是掌握面向對象編程的基礎。這些概念為后續學習繼承和多態奠定了重要基礎。
如果我的內容對你有幫助,請點贊,評論,收藏。接下來我將繼續更新相關內容!