面向過程和面向對象
- c語言是面向過程的，關注的是過程，分析出求解問題的步驟，通過函數調用逐步解決問題。
- java是基于面向對象的，關注的是對象，將一件事情拆分成不同的對象，靠對象之間的交互完成。
- 面向過程注重的是過程，在整個過程中所涉及的行為，就是功能。
- 面向對象注重的是對象，也就是參與過程所涉及到的主體。是通過邏輯將一個個功能實現連接起來
【面向對象概念】
- 面向對象是思考問題的一種思考方式，是一種思想。比如：概念與實例。理論與實踐。名和實等等。
- 類就是一類對象的統稱。對象就是這一類具體化的一個實例
- 面向對象的好處：將復雜的事情變簡單了，只要面對一個對象就行。
【面向對象設計】
面向對象設計把握一個重要的經驗：誰擁有數據，誰對外提供操作這些數據（私有）的方法?。ū粍拥囊环绞菙祿膿碛姓撸鲃拥囊环绞菆绦姓撸?/p>
開發時：找對象，建對象，用對象，并維護對象之間的關系。
總結：面向對象就是用代碼(類)來描述客觀世界的事物的一種方式. 一個類主要包含一個事物的屬性和行為
類和類的實例化
類就是一類對象的統稱。對象就是這一類具體化的一個實例
一個類可以實例化無數個對象
下面我們通過一個例子了解類和類的實例化
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
class person { public int age;//成員屬性 實例變量 字段 屬性 public string name; public static string sex; //靜態成員變量 方法區 public void eat() {//成員方法 system.out.println("吃飯!"); } public void sleep() { system.out.println("睡覺!"); } public static void func(){ system.out.println("靜態成員方法"); }}public class main{ public static void main(string[] args) { person person = new person();//通過new實例化對象 person.eat();//成員方法調用需要通過對象的引用調用 person.sleep();//產生對象 實例化對象 person person2 = new person(); person person3 = new person(); //靜態成員變量和方法的調用 system.out.println(person.sex); person.func(); }} |
成員變量：
定義在類的內部，方法的外部
通過對象的引用來訪問
如果沒有初始化，那么它的值就是一個默認默認值（默認零值）
- 如果是引用類型，那么值就是null（包括數組，string字符串等）
- 如果是簡單類型，那么值就是其這種類型所對應的默認值
| byte | short | int | long | float | double | char | boolean |
|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0l | 0.0f | 0.0 | '\u0000'十六進制（也可以當作0） | false |
行為/方法：
【eat() sleep()】為實例成員方法
func()為靜態成員方法
對于靜態的成員變量和成員方法該該怎么訪問呢
這里可以看到，對于靜態的，不需要實例化對象！！！
直接調用
類名.靜態成員變量/靜態成員方法
總結static：
- 對于靜態的成員屬性或者靜態的成員方法，是不依賴于對象的。
- 靜態的成員變量 ，只有一份，存儲在方法區中。
- 靜態的方法內部是不可以訪問非靜態的數據的。
實例化類的存儲結構
初始化成員變量的方式
1、就地初始化（在類內進攻初始化）
2、默認初始化
3、類外初始化（用的比較多）
|
1
2
3
4
5
6
7
8
9
10
11
|
public class main{ public static void main(string[] args) { person person1 = new person(); person1.name = "星星"; person1.age = 20; person person2 = new person(); person2.name = "狒狒"; person2.age = 40; }} |
封裝
在我們寫代碼的時候經常會涉及兩種角色: 類的實現者和類的調用者. 封裝的本質就是讓類的調用者不必太多的了解類的實現者是如何實現類的,只要知道如何使用類就行了.
這樣就降低了類使用者的學習和使用成本, 從而降低了復雜程度
private/ public 這兩個關鍵字表示 “訪問權限控制” .
- 被 public 修飾的成員變量或者成員方法, 可以直接被類的調用者使用.
- 被 private 修飾的成員變量或者成員方法,不能被類的調用者使用
舉個例子
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class person { private string name = "張三"; private int age = 18; public void show() { system.out.println("我叫" + name + ", 今年" + age + "歲"); }}class test { public static void main(string[] args) { person person = new person(); person.show(); }} |
- 此時字段已經使用 private 來修飾. 類的調用者(main方法中)不能直接使用. 而需要借助 show 方法. 此時類的使用者就不必了解 person 類的實現細節.
- 同時如果類的實現者修改了字段的名字, 類的調用者不需要做出任何修改(類的調用者根本訪問不到 name, age這樣的字段)
getter和setter方法
getter：得到屬性值的方法
setter：修改屬性值的方法
我們用這兩者方法將類的屬性封裝起來，從而來達到訪問屬性的目的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class person { private string name;//實例成員變量 private int age; public void setname(string name){//name = name;//不能這樣寫 this.name = name;//this引用，表示調用該方法的對象 } public string getname(){ return name; } public void show(){ system.out.println("name: "+name+" age: "+age); }}class main { public static void main(string[] args) { person person = new person(); person.setname("caocao"); string name = person.getname(); system.out.println(name); person.show(); }} |
this關鍵字
我們在剛才的代碼可以看到setter方法
|
1
2
3
4
5
|
private string name;public void setname(string name){ //name = name;//不能這樣寫 this.name = name;//this引用，表示調用該方法的對象} |
this表示當前對象引用， 可以借助 this 來訪問對象的字段和方法
三個用法：
- this.屬性; //訪問當前對象的屬性
- this.方法；//調用當前對象的方法
- this(); //調用當前對象的構造方法 （ps：必須放在第一行，且只能存在一個構造方法內部）
構造方法
構造方法是一種特殊方法, 使用關鍵字new實例化新對象時會被自動調用, 用于完成初始化操作
實例化一個對象/創建一個對象分幾步？
student stu = new student() ；//實例化一個對象
兩步
- 為對象分配內存
- 調用合適的構造方法，說明構造方法不止一個，可能更多
語法規則
- 方法名稱必須與類名稱相同
- 構造方法沒有返回值類型聲明
- 每一個類中一定至少存在一個構造方法（沒有明確定義，則系統自動生成一個無參構造）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
class person { private string name;//實例成員變量 private int age; private string sex; //默認構造函數 構造對象 public person() { this.name = "caocao"; this.age = 10; this.sex = "男"; } //帶有3個參數的構造函數 public person(string name,int age,string sex) { this.name = name; this.age = age; this.sex = sex; } public void show(){ system.out.println("name: "+name+" age: "+age+" sex: "+sex); }}public class main{ public static void main(string[] args) { person p1 = new person();//調用不帶參數的構造函數 如果程序沒有提供會調用不帶參數的構造函數 p1.show(); person p2 = new person("zhangfei",80,"男");//調用帶有3個參數的構造函數 p2.show(); }} |
tostring方法
|
1
2
|
person person = new person("caocao",19);system.out.println(person); |
如果打印引用，他會默認調用tostring方法，執行這樣一個結果：
我們可以重寫tostring方法，來打印自己想要的結果
例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
class person { private string name; private int age; public person(string name,int age) { this.age = age; this.name = name; } public void show() { system.out.println("name:"+name+" " + "age:"+age); } //重寫object的tostring方法 @override public string tostring() { return "person{" + "name='" + name + '\'' + ", age=" + age + '}'; }}public class main { public static void main(string[] args) { person person = new person("caocao",19); person.show(); system.out.println(person); }} |
這樣打印引用的化，就會按照想要的內容進行輸出。
匿名對象
匿名只是表示沒有名字的對象.
- 沒有引用的對象稱為匿名對象.
- 匿名對象只能在創建對象時使用.
- 如果一個對象只是用一次, 后面不需要用了, 可以考慮使用匿名對象
|
1
|
new person("caocao",19).show();//通過匿名對象調用方法 |
特點：不依賴于對象，我們只需要通過類名就可以調用其屬性或者方法
代碼塊
- 本地代碼塊
- 靜態代碼塊
- 實例代碼塊/構造代碼塊
- 同步代碼塊（多線程）
本地代碼塊： 在方法中的代碼塊
|
1
2
3
4
5
6
7
8
9
10
|
public class main{ public static void main(string[] args) { { //直接使用{}定義，普通方法塊 int x = 10 ; system.out.println("x1 = " +x); } int x = 100 ; system.out.println("x2 = " +x); }} |
靜態代碼塊： 一般用于初始化靜態成員屬性
|
1
2
3
4
5
|
//靜態代碼塊static {count = 10;//只能訪問靜態數據成員system.out.println("i am static init()!");} |
實例代碼塊： 定義在類中的代碼塊，構造代碼塊一般用于初始化實例成員變量
|
1
2
3
4
5
6
7
|
//實例代碼塊{this.name = "bit";this.age = 12;this.sex = "man";system.out.println("i am instance init()!");} |
執行順序
靜態代碼塊實例代碼塊構造方法
總結
到此這篇關于java中類和對象的文章就介紹到這了,更多相關java類和對象內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！
原文鏈接：https://blog.csdn.net/starry1441/article/details/113757382
