文章目錄

• 一 類與對象的定義
• 二 類的成員變量
• • 總結：
• 三 類的方法
• • （1）普通成員方法
  • （2）靜態成員方法
  • 類與對象的關鍵E點：
  • 疑難解答：
• 四 private封裝
• 五 setter與getter
• 六 toString打印
• 七 構造方法（重點理解）
• 八 this關鍵字
• • 1 this調用當前對象的屬性（this.data）
  • 2 this調用當前對象的方法（this.func()）
  • 3 this調用其他構造函數(this())
• 九代碼塊
• • 1 實例代碼塊
  • 2 靜態代碼塊
  • 3 探究兩者之間的關系
• 十 匿名對象
• 總結：

一 類與對象的定義

類：可以簡單理解成是一塊模板，是比較抽象的。
對象：就是對于類的實例化，就是具體的，在java中類的實例化通過關鍵字new來實現。
基本語法規則

//類的創建：
class <類名> {
屬性/字段/成員變量
成員方法
}
// 類的實例化：
<類名>+對象名 = new + <類名>();

例如

class Person{public String name;//成員屬性（成員變量）public int age;//成員屬性（成員變量）public void eat(){//成員方法System.out.println("睡覺");}} public class practiceone{public static void main(String[] args) {Person person = new Person();//對象的實例化person.name="java";//給對象賦值person.age = 1;//給對象賦值System.out.println(person.name);System.out.println(person.age);person.eat();Person person1 = new Person();person1.name="python";System.out.println(person1.name);} }

從以上代碼示例來看，我們可以發現以下特點：
1 一個類是可以創建多個實例化對象（person，person1）
2 通過關鍵字new來實例化對象
3 通過.這個來訪問對象里的屬性以及方法

二 類的成員變量

字段/屬性/成員變量(普通成員變量)

class Person{public String name;public int age;//方法之外，類里面的變量稱為字段/成員變量/屬性public void eat(){System.out.println("睡覺");}} public class practiceone{public static void main(String[] args) {Person person = new Person();//對象的實例化System.out.println(person.name);System.out.println(person.age);} }

運行結果
null
0

1 對于類里的name,age都屬于成員變量
2 如果沒有對對象的成員變量設置一個初始值，那么顯示的就會是一個默認的初始值，在這里對于各種數字類型，默認的值是0
對于浮點類型，默認的值為0.0
對于字符型，默認的值為’\u0000’
對于布爾類型，默認值是false
對于其他引用（String，Array以及定制類），這些的默認值為null。
對于類里面的成員變量是可以直接在類里面賦值的，但我們不希望每一個對象的屬性都是一樣的，以name為例，不能每一個對象就叫做java
靜態成員變量
靜態成員變量就是在普通成員變量的形式上，多加了一個Static進行修飾，體會下列代碼

class Person{public static int count;public String name;public int age;//方法之外，類里面的變量稱為字段/成員變量/屬性public void eat(){System.out.println("睡覺");}} public class practiceone{public static void main(String[] args) {Person person = new Person();//對象的實例化person.count=10;}}

其實這個代碼看上去是沒有什么錯的，但是在編譯器上，對于person.count會報警告，這就是靜態成員變量的特點所決定的，靜態成員變量是不依賴于對象的，所以在這里就沒有必要實例化對象，靜態成員變量是屬于類的，所以正確的調用方式應當直接利用類名（Person.count）

class Person{public static int count;public String name;public int age;public void eat(){System.out.println("睡覺");}} public class practiceone{public static void main(String[] args) {Person person = new Person();person.age++;Person.count++;System.out.print(person.age);System.out.println(Person.count);Person person1 = new Person();person1.age++;Person.count++;System.out.print(person1.age);System.out.print(Person.count);} }

運行結果

11
12

圖解過程

從以上可以得出，其實我們的靜態變量是在方法區中，并且每個對象都是共用一個方法區的，所以才會得出第一個創建對象的count為1，第二個創建對象的count為2.

總結：

1 對于普通成員變量的使用是需要進行對象的實例化，而對于靜態成員變量是不依賴于對象的，所以不需要進行對象的實例化，它是屬于類的，需要利用類名進行使用。
2 對于靜態的成員變量是屬于方法區的，不是在堆里。

三 類的方法

方法：用來描述對象的行為
對于一種特殊的稱為構造方法，在后面的文章中詳細講解，本篇文章主要講解類的普通方法。

（1）普通成員方法

class Person{public static int count;public String name;public int age;public void eat(){System.out.println(name+"在睡覺");}public void sleep(){change();//Static int one = 1;errorSystem.out.println(name+"在吃飯");}public static void change(){//sleep()errorcount=10;}} public class practiceone{public static void main(String[] args) {Person person = new Person();person.name="java";person.eat();person.sleep(); } }

在普通成員方法是可以對靜態方法進行調用，但是在靜態方法里面是不能定義靜態成員變量的，這是因為靜態成員變量是屬于類的，而不屬于方法。

（2）靜態成員方法

從上面代碼分析可以得出，靜態成員方法內不能調用普通成員方法，因為靜態方法與靜態成員變量都是屬于類的，不依賴于對象。而普通成員方法依賴于對象。也說明靜態方法不能直接使用普通成員變（非靜態數據成員）。

類與對象的關鍵E點：

靜態變量與靜態方法屬于類，而且兩者都不依賴于對象
對于普通成員方法以及普通成員變量都必須依賴于對象，換句話說必須要通過關鍵字new去進行實例化對象。

疑難解答：

問：對于Java中main函數為什么是靜態的？
這是因為JVM在底層對于main函數的加載就是使用了靜態的，換句話說就是靜不靜態都是可以的，這個是取決于JVM的（對于JVM的我們后續文章詳解）

四 private封裝

puplic與paivate兩個關鍵字都是表示訪問控制權限，
被puplic修飾的字段和方法，可以直接被類的使用者進行調用，
被private修飾的方法與字段是不可以直接被類的使用者進行調用
對于public修飾進行對象的訪問前面我們已經講解過，這里不多做贅述
下面通過具體的代碼來分析一下

class Person{private int age;private String name;private void eat(){System.out.println("在睡覺");} } public class TestDemo {public static void main(String[] args) {Person person = new Person();person.age=10;//errorperson.eat;//error} }

圖中標注error的是編譯器報錯，這個主要就是關鍵字private的作用了，通過private關鍵字進行修飾字段與方法，那么該字段與方法的作用范圍只能是在當前類下，類的調用者據訪問不到這些字段與方法。這個就是我們所說的private封裝，封裝的作用其實就是為了讓代碼更加的安全。

五 setter與getter

對于實現private封裝的類，里面的字段我們可以通過java中提供的setter于getter方法進行訪問。（注意這里是對字段進行訪問，方法是不使用這個的）

class Person{private int age;private String name;public void setAge(int age) {this.age = age;}public void setName(String name) {this.name = name;}private void eat(){System.out.println("在睡覺");} } public class TestDemo {public static void main(String[] args) {Person person = new Person();person.setAge(10);person.setName("java");} }

注意這里的getter與setter方法我們是可以通過IDEA自動幫助生成，通過快捷鍵Alt+insert就可以進行設置，這個通過自己多動手就知道是怎樣生成。

六 toString打印

與getter與setter快捷鍵一致，可以生成自動將對象轉化為字符串的形式輸出，這一過程（對象轉化為字符串）我們稱為序列化。

@Overridepublic String toString() {return "Person{" +"age=" + age +", name='" + name + '\'' +'}';}

@Override 在 Java 中稱為 "注解“，toString 方法會在 println 的時候被自動調用。

七 構造方法（重點理解）

在前面我們講過普通的方法，這里我們需要理解一個特殊并且很重要的一個方法，就是構造方法。構造方法在使用關鍵字new實例化新對象時會被自動調用,
構造方法的意義：構造對象，對象的實例化。

class Person{private int age;private String name;private void eat(){System.out.println("在睡覺");}public Person(){//構造方法System.out.println("構造方法");} } public class TestDemo {public static void main(String[] args) {Person person = new Person();} }

運行結果：

構造方法

class Person{private int age;private String name;private void eat(){System.out.println("在睡覺");}public Person(){//構造方法System.out.println("構造方法");}public Person(String name){System.out.println("帶一個參數的");}public Person(String name,int age){System.out.println("帶兩個參數的");} } public class TestDemo {public static void main(String[] args) {Person person = new Person();Person person1=new Person("java");Person person2 = new Person("java",1);} }

構造方法要點總結：
從以上我們可以看出構造方法不止一個，可以是多個，并且構造方法之間構成了重載。
構造方法每一個類中至少含有一個，如果自己沒有寫構造方法，那么編譯器自動會生成一個不帶任何參數的構造方法，如果自己寫了構造方法，那么編譯器就不會在生成不帶參數的構造方法。

八 this關鍵字

this要注意的一點就是表示當前對象的引用，而不是當前對象，this一共有三種用法，

1 this調用當前對象的屬性（this.data）

class Person {private int age;private String name;private void eat() {System.out.println("在睡覺");}public void setAge(int age) {this.age = age;//this調用當前對象的屬性}public void setName(String name) {this.name = name;} } public class TestDemo {public static void main(String[] args) {Person person = new Person();} }

2 this調用當前對象的方法（this.func()）

class Person {private int age;private String name;private void eat() {System.out.println("在睡覺");}private void sleep(){this.eat();//調用當前對象的方法System.out.println("在吃飯");} } public class TestDemo {public static void main(String[] args) {Person person = new Person();} }

3 this調用其他構造函數(this())

class Person {private int age;private String name;public Person(){this("java");//調用其他構造函數System.out.println("不帶參數的構造方法");}public Person(String name){System.out.println("帶一個參數的構造方法");}public Person(String name,int age){System.out.println("帶兩個參數的構造方法");} } public class TestDemo {public static void main(String[] args) {Person person = new Person();} }

在這里調用其他構造函數時，this的調用必須放在第一行，如果寫入了兩個this那么這個時候編譯器就會報錯，那么兩個this里面只能選擇一個了。要注意的是這個this（）的使用情況是在一個構造方法里去調用另一個構造方法，在其他情況不能這樣用。

九代碼塊

在這里我們主要介紹實例代碼塊與靜態代碼塊，對于同步代碼塊后續的內容會進行闡述，而本地代碼塊比較簡單，這里就不多加以描述。

1 實例代碼塊

定義：定義在類中的代碼塊(不加修飾符)。構造代碼塊一般用于初始化實例成員變量。

2 靜態代碼塊

定義：使用static定義的代碼塊。一般用于初始化靜態成員屬性。就是在實例化代碼塊前加以static修飾，那么此時這個代碼塊就是靜態代碼塊

3 探究兩者之間的關系

class Person {private int age;private String name;{System.out.println("實例代碼塊");}static{System.out.println("靜態代碼塊");}public Person(){System.out.println("不帶參數的構造方法");}public Person(String name){System.out.println("帶一個參數的構造方法");}public Person(String name,int age){System.out.println("帶兩個參數的構造方法");} } public class TestDemo {public static void main(String[] args) {Person person = new Person();} }

運行結果：

靜態代碼塊
實例代碼塊
不帶參數的構造方法

從運行結果上去分析，我們可以看出靜態代碼塊以及實例化代碼塊都比構造方法更早執行，方法是最后執行的。

class Person {private int age;private String name;{System.out.println("實例代碼塊");}static{System.out.println("靜態代碼塊");}public Person(){System.out.println("不帶參數的構造方法");}public Person(String name){System.out.println("帶一個參數的構造方法");}public Person(String name,int age){System.out.println("帶兩個參數的構造方法");} } public class TestDemo {public static void main(String[] args) {Person person = new Person();System.out.println("===========");Person person1 = new Person("java");} }

運行結果

靜態代碼塊
實例代碼塊
不帶參數的構造方法
===========
實例代碼塊
帶一個參數的構造方法

從上面這一個代碼，我們可以看出靜態代碼塊只能執行一次，而實例代碼塊執行與對象實例化的次數有關。

class Person {private int age;private String name;static int count=10;{System.out.println("實例代碼塊");}static{count=90;System.out.println("靜態代碼塊");} } public class TestDemo {public static void main(String[] args) {System.out.println(Person.count);} }

運行結果：

靜態代碼塊
90

從以上代碼可以看出靜態代碼是不需要通過關鍵字new實例化對象就能使用的，而實例化代碼塊是需要先實例化對象的。

class Person {private int age;private String name;{System.out.println("實例代碼塊");}static{count=90;System.out.println("靜態代碼塊");}static int count=10; } public class TestDemo {public static void main(String[] args) {System.out.println(Person.count);} }

運行結果：

靜態代碼塊
10

這里對比上一個代碼我們發先就是static定義的靜態成員變量位置不同，導致count的值不同，說明這個count的值與static執行的順序有關（這里要特別提一下，static后定義靜態成員變量這種java的語法是支持的，不會報錯）。在這里有一個特殊的例子，就是count沒有初始化值，那么它的值就不與這個執行順序有關，count就等于99，而不等于10了。

十 匿名對象

class Person {private int age;public String name;static int count=10;public void eat(){System.out.println("睡覺");} } public class TestDemo {public static void main(String[] args) {new Person().eat();} }

運行結果：

睡覺

如上代碼所示，不需要通過之前那樣利用person作為引用去實例化對象，直接通過關鍵字new創建對象就被稱為匿名對象，一個對象只能用一次。

總結：

1 被private修飾的屬性，需要通過java提供的setter與getter方法進行訪問操作。
2 靜態代碼塊總是最先執行的，并且只執行一次，不需要實例化對象也能執行，實例代碼塊執行在構造方法之前，構造方法在最后
3 在this這個關鍵字中，它表示的是對當前對象的引用，不是當前對象。

對于this的詳細講解可以參考以下這篇文章：
this的使用詳解

總結

以上是生活随笔為你收集整理的java中类与对象回顾总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。