Java中的類和對象

• 1.Java中類定義和使用
• 2.類的實例化
• • 2.1什么是實例化
  • 2.2訪問類中的屬性和方法
  • 2.3成員變量默認值
• 3.this引用
• • 3.1為什么要用this引用
  • 3.2this引用特性
  • 3.3 this的用法
• 4.對象的構造及初始化
• • 4.1構造方法
  • 4.2 實例化對象時，必須的兩步
  • 4.3創建構造方法的快捷鍵
  • 4.4 this調用構造方法
  • 4.5 初始化對象
• 5. 成員變量的打印(快捷鍵)
• 6.封裝
• • 6.1 public 和 private 的區別：
  • 6.2 成員變量接口的提供 快捷鍵
  • 6.3 包訪問權限(默認權限)
  • • 6.3.1 什么是包?
    • 6.3.2 導入包中的類
    • 6.3.3 如何自定義包？
    • 6.3.4 包訪問權限
    • 6.3.5 public ，private ，默認權限 的權限總結：
    • 6.3.6 常見的包
• 7.static成員
• • 7.1 static 修飾成員變量和成員方法
  • 7.2 類變量和類方法
  • 7.3 訪問類方法和類變量
  • 7.4 解釋一個現象——之前寫的函數都用 static 修飾
• 8. 代碼塊
• • 8.1 代碼塊概念以及分類
• 9. 內部類
• • 9.1 內部類的分類
  • 9.2 實例內部類
  • 9.3 靜態內部類

1.Java中類定義和使用

public class Student{//字段（屬性）或成員變量public String name;public String gender;public double score;//行為 或者 成員方法public void DoClass(){}public void DoHomework(){}public void Exam(){}}

注意事項：

一般一個文件當中只能有一個類

main方法所在的類一般使用public修飾，Eclipse默認會在public修飾的類當中找到main方法

public修飾的類必須要和文件名相同

不要輕易修改public修飾的類的名稱，如果要改，就要通過開發工具修改。

2.類的實例化

2.1什么是實例化

定義了一個類就相當于定義了一個新的數據類型，與int，double類似。
用類類型創建對象的過程就叫做實例化。

class Student{//字段（屬性）或成員變量————定義在類的內部，方法的外部public String name;public String gender;public double score;//行為 或者 成員方法public void DoClass(){System.out.println(name+"正在上課");}public void DoHomework(){System.out.println(name+"正在寫作業");}public void Exam(){System.out.println(name+"得考試結果為"+score);} } public class TestDemo {public static void main(String[] args) {Student student1=new Student();Student student2=new Student();} }

2.2訪問類中的屬性和方法

class Student{//字段（屬性）或成員變量————定義在類的內部，方法的外部public String name;public String gender;public double score;//行為 或者 成員方法public void DoClass(){System.out.println(name+"正在上課");}public void DoHomework(){System.out.println(name+"正在寫作業");}public void Exam(){System.out.println(name+"得考試結果為"+score);} } public class TestDemo {public static void main(String[] args) {Student student=new Student();student.name="李飛飛";student.score=78.8;student.DoClass();student.Exam();} }

2.3成員變量默認值

class Student{//字段（屬性）或成員變量————定義在類的內部，方法的外部public String name;public String gender;public double score;public boolean boy;//行為 或者 成員方法public void DoClass(){System.out.println(name+"正在上課");}public void DoHomework(){System.out.println(name+"正在寫作業");}public void Exam(){System.out.println(name+"得考試結果為"+score);}public void Show(){System.out.println("名字："+name+" 年級"+gender+" 成績"+score+" 是不是男孩"+boy);} } public class TestDemo {public static void main(String[] args) {Student student=new Student();student.Show();} }

當成員變量沒有初始化值的時候，每個成員變量都是它對應的 0 值：

引用類型對應的值是 null
boolean類型對應的是false
char 對應的是一個空格

3.this引用

3.1為什么要用this引用

當形參名不小心與成員變量名相同時：

public class MyDate {public int year;public int month;public int day;/*設置日期*/public void setDate(int year,int month,int day){//遵循局部變量優先原則year=year;month=month;day=day;}public void printDate(){System.out.println(year+"年"+month+"月"+day+"日");}public static void main(String[] args) {MyDate myDate=new MyDate();myDate.setDate(2022,3,25);myDate.printDate();} }

此時就出現了一點不對勁，那怎么解決呢？
加 this 即可

public class MyDate {public int year;public int month;public int day;/*設置日期*/public void setDate(int year,int month,int day){this.year=year;this.month=month;this.day=day;}public void printDate(){System.out.println(this.year+"年"+this.month+"月"+this.day+"日");}public static void main(String[] args) {MyDate myDate=new MyDate();myDate.setDate(2022,3,25);myDate.printDate();} }

此時的情況為什么好起來了呢，我們來調試看一下：
通過調試可以發現，this代表當前對象的引用。

此外，this 本質上是一個隱式參數：

this 到目前為止，我們知道的作用有：

代表當前對象的引用

當形參名不小心與成員變量名相同時，可以區別形參名與成員變量名

this 本質上來說，是一個隱式的參數

3.2this引用特性

this的類型：對應類類型引用，即哪個對象調用就是哪個對象的引用

this只能在成員方法中使用

在成員方法中，this只能引用當前對象，不能引用其他對象

this是“成員方法”第一個隱藏的參數，編譯器會自動傳遞，在成員方法執行時，編譯器會負責將調用成員方法，對象的引用傳遞給該成員方法，this負責來接收

3.3 this的用法

this.data //訪問成員變量

this.fun( ) //訪問成員方法

this( ) //調用本類中的其他構造方法

4.對象的構造及初始化

4.1構造方法

構造方法是一個特殊的成員方法，名字必須與類名相同，在創建對象時，由編譯器自動生調用，并且在整個對象的生命周期只能調用一次

構造方法的特點：

名字必須與類名相同

沒有返回值類型，設置為void也不行

創建對象時由編譯器自動調用，并且在對象的生命周期內只調用一次(相當于人的出生，每個人只能出生一次)

構造方法可以重載(用戶根據自己的需求提供不同參數的構造方法)n

比如：

4.2 實例化對象時，必須的兩步

為對象分配空間

調用合適的構造方法

看一個例子：

運行結果：

從結果來看，在實例化對象時，會調用一個不帶參數的構造方法。
有時候我們并沒有寫構造方法，但是也能運行成功，這是為什么呢？

當程序中沒有構造方法時，編譯器會自己生成一個不帶參數的構造方法。

當自己寫了構造方法時，就不會生成構造方法，這就使得，如果寫了構造方法，就必須寫一個不帶參數的構造方法

多個構造方法之間形成重載

4.3創建構造方法的快捷鍵

鼠標右鍵————》Generate————》Constructor
—————》按住ctrl，選中要作為參數的成員變量

效果如下：

4.4 this調用構造方法

注意：

this（）調用奔類中構造方法時，必須放在第一行

不能形成環

class Student{public Student(String s){System.out.println(s);}public Student(){this("hello");System.out.println("這個是不帶參數的構造方法！");} } public class TestDemo {public static void main(String[] args) {Student student=new Student();} }

結果分析：

4.5 初始化對象

默認初始化

就地初始化

檢測對象對應的類是否加載了，如果沒有加載則加載

為對象分配內存空間

處理并發安全問題
比如：多個線程同時申請對象，JVM要保證給對象分配的空間不沖突

初始化所分配的空間

5. 成員變量的打印(快捷鍵)

先用起來

class Student{public int age;public double score;public String name;@Overridepublic String toString() {return "Student{" +"age=" + age +", score=" + score +", name='" + name + '\'' +'}';} } public class TestDemo {public static void main(String[] args) {Student student=new Student();System.out.println(student);} }

快捷鍵使用：
鼠標右鍵————》Generate————》toString
—————》按住ctrl，選中要作為參數的成員變量

6.封裝

6.1 public 和 private 的區別：

public ：公開的，公共的。意味著,被public修飾的成員在其他類當中也可以訪問

private：私有的。意味著,被private修飾的成員只能在當前類中訪問，這樣就比較安全，類外不可見。即對類的實現細節進行隱藏

例：private的使用

class Student{private int age;private double score;private String name;public void setName(String name){this.name=name;}public String getName(){return name;} } public class TestDemo {public static void main(String[] args) {Student student=new Student();student.setName("李飛飛");String name=student.getName();System.out.println(name);} }

6.2 成員變量接口的提供 快捷鍵

鼠標右鍵————》Generate————》Getter and Setter
—————》按住ctrl，選中要作為參數的成員變量

效果展示：

class Student{private int age;private double score;private String name;public int getAge() {return age;}public void setAge(int age) {this.age = age;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}public String getName() {return name;}public void setName(String name) {this.name = name;} } public class TestDemo {public static void main(String[] args) {Student student=new Student();} }

6.3 包訪問權限(默認權限)

6.3.1 什么是包?

為了更好的管理，把多個類收集在一起成為一組，稱為軟件包。

在Java中，包是對類的、接口等的封裝機制的體現，是一種對類或者接口等的很好的組織形式。

包還有一個重要的作用，在同一個工程中允許存在相同名稱的類，只要存在不同的包中就行

6.3.2 導入包中的類

Java 中已經提供了很多現成的類供我們使用. 例如Date類：可以使用 java.util.Date 導入 java.util 這個包中的 Date類.

public class TestDemo {public static void main(String[] args) {java.util.Date date=new java.util.Date();System.out.println(date.getTime());//getTime( )———獲取時間戳} }

上面的這種寫法雖然也可以導入包中的類，但是非常麻煩，所以我們通常用使用 import語句導入包.

import java.util.Date; public class TestDemo {public static void main(String[] args) {Date date=new Date();System.out.println(date.getTime());} }

當需要導入多個包時，如果一個一個導入，也可能比較麻煩，所以可以用 * 表示導入所有的包：

但是呢，有時候調用的包里面會有名稱相同的類，此時編譯器就不知道是用的哪一個包中的類：

此時就得調用哪一個包：

6.3.3 如何自定義包？

1.創建包的步驟：

2.控制包文件的顯示模式：

3.調用自定義包：

src文件下的 TestDemo 調用自定義包中的TestDemo時，兩個文件類名重復了，所以得直接指定
src文件下的 TestDemo 調用自定義包中的TestDemo1時，就可以用 import 的方法導入自定義包

自定義包的基本原則：

在文件的最上方加上一個 package 語句指定該代碼在哪個包中.

包名需要盡量指定成唯一的名字, 通常會用公司的域名的顛倒形式(例如 com.bit.demo1 ).

包名要和代碼路徑相匹配. 例如創建 com.bit.demo1 的包, 那么會存在一個對應的路徑 com/bit/demo1 來存儲代碼.

如果一個類沒有 package 語句, 則該類被放到一個默認包中

6.3.4 包訪問權限

在包中定義一個包訪問權限的變量 a

在同一個包中訪問 a 時：

在別的包中訪問 a 時：

通過上面的示范可以知道，包訪問權限的變量只能在同一個包中訪問，在不同包中就會訪問受限。

6.3.5 public ，private ，默認權限 的權限總結：

int a=199;//默認權限——————只能在這個包當中使用public int b=200;//可以隨便訪問private int c=100;//只能在同一個類中訪問

6.3.6 常見的包

java.lang:系統常用基礎類(String、Object),此包從JDK1.1后自動導入。

java.lang.reflect:java 反射編程包;

java.net:進行網絡編程開發包。

java.sql:進行數據庫開發的支持包。

java.util:是java提供的工具程序包。(集合類等) 非常重要

java.io:I/O編程開發包

7.static成員

7.1 static 修飾成員變量和成員方法

static修飾成員變量時：

在Java中，被static修飾的成員，稱之為靜態成員，也可以稱為類成員，其不屬于某個具體的對象，是所有對象所共享的。

Java中，被static修飾的成員方法稱為靜態成員方法，是類的方法，不是某個對象所特有的

7.2 類變量和類方法

字段/屬性/成員變量：

普通成員變量

靜態成員變量，又叫類變量

方法/成員方法：

普通成員方法

靜態成員變量，又叫類方法

在下面的JVM中，類變量存在方法區

（其實，在JVM中，方法區放在對里面，但是兩者在邏輯上同等級的）

注意：

普通的成員方法中是可以使用靜態成員變量

靜態成員方法中，不能訪問非靜態的成員。因為靜態的成員依賴于對象。

7.3 訪問類方法和類變量

1.可以通過對象調用，也可以通過類名.靜態方法名(…)方式調用，更推薦使用后者

class Student{public String name;public int age;public double score;//public String classes;public static String classes;public static void doClass(){System.out.println("正在上課");} } public class TestDemo {public static void main(String[] args) {Student student=new Student();student.classes="三班";//通過對象調用Student.doClass();//通過類名.靜態方法名(...)方式調用Student.classes="二班";//通過類名.靜態變量 方式調用} }

2.靜態方法沒有隱藏的this引用參數，因此不能在靜態方法中訪問任何非靜態成員變量

7.4 解釋一個現象——之前寫的函數都用 static 修飾

之前用static修飾時，在 main 中直接用函數名就可以調用 func函數

當沒被static修飾時，就得用以下的方式調用 func 函數

原因分析：
main函數是被static修飾的，所以main的使用不依賴于對象

如果在main里面調用的方法也是被static 修飾，即也不依賴于對象，此時就可以直接調用

如果在main里面調用非靜態成員時，因為非靜態成員依賴于對象，所以此時就得實例化一個對象

8. 代碼塊

8.1 代碼塊概念以及分類

使用 {} 定義的一段代碼稱為代碼塊。根據代碼塊定義的位置以及關鍵字，又可分為以下四種：

普通代碼塊 ：一般不會用
構造塊 /實例代碼塊：一般用來初始化普通成員變量
靜態塊 ：一般用于初始化靜態的數據
同步代碼塊（后續講解多線程部分再談)

class Student{public int a;public int b;public int c;public static int d;public static int e;public static int f;{System.out.println("這是一個實例代碼塊");a=10;b=20;c=30;}public Student(){System.out.println("這是一個構造方法");}static{System.out.println("這是一個靜態代碼塊");d=10;e=20;f=30;} } public class TestDemo {public static void main(String[] args) {Student student=new Student();} }

運行結果：

優先級：靜態代碼塊 > 實例代碼塊 > 構造方法
當有多個靜態代碼塊時，運行的先后順序由代碼的先后順序決定

9. 內部類

內部類就相當于外部類的一個成員，實例內部類就相當于普通成員，其依賴于對象。
靜態內部類就相當于靜態成員，其不依賴于對象

9.1 內部類的分類

目前先知道下面兩種即可。

9.2 實例內部類

實例內部類的問題總結：

如何實例化內部類對象？

實例內部類中不能定義靜態的成員變量。原因：實例內部類是需要實例化外部類對象才能訪問的。那么非要定義的話，可以加 final ，將該變量變為常量

當內部類和外部類變量重名了。怎么辦? 優先使用內部類自己的變量。那么如何拿到外部類的變量呢？

在實例內部類當中不能定義靜態方法，因為實例內部類是依賴對象的，當沒有外部類對象時，內部類這個類是不存在的，當類不存在時，當然也就不能訪問其中的靜態方法。

class OuterClass1{public int data1=10;private int data2=20;public static int data3=30;//實例內部類class InnerClass{public int data1=1000;private int data5=50;//2.在實例內部類中定義靜態的成員變量public static final int data6=60;public InnerClass(){System.out.println("InnerClass1的構造方法！");}public void method(){System.out.println(data1);System.out.println(this.data1);//與data1 一樣//在實例內部類當中訪問重名的外部類的成員變量System.out.println(OuterClass1.this.data1);//可以意識到，在實力內部類當中，不僅包含了自己的this，而且包含了外部類的thisSystem.out.println(data2);System.out.println(data3);System.out.println(data5);System.out.println(data6);System.out.println("InnerClass的一個method方法！");}}//在外部類當中訪問內部變量——————即訪問外部類的對象，所以要創建對象public void methodOut(){InnerClass innerClass = new InnerClass();System.out.println(innerClass.data1);} } public class Test1 {public static void main(String[] args) {//實例化方法1：OuterClass1 outerClass=new OuterClass1();//實例外部類//外部類名.內部類名——————拿到內部類的類型OuterClass1.InnerClass innerClass=outerClass.new InnerClass();//實例化方法2：OuterClass1.InnerClass innerClass1=new OuterClass1().new InnerClass();innerClass.method();} }

9.3 靜態內部類

靜態內部類中的問題總結：

如何實例化靜態的內部：靜態的成員不依賴以對象

在靜態內部類當中，只能訪問外部類的靜態成員變量。但是如果非要訪問外部類的非靜態變量，那么怎么訪問？ 方法：在靜態內部類中實例化一個對象或者傳入一個對象

class OuterClass{public int data1=10;private int data2=20;public static int data3=30;public void method(){System.out.println("OuterClass:method()");}//靜態內部類:static class InnerClass{public int data4=40;private int data5=50;public static int data6=60;//2. 在靜態內部類當中，只能訪問外部類的靜態成員變量。但是如果非要訪問外部類的非靜態變量，那么怎么訪問？OuterClass out=new OuterClass();InnerClass(){System.out.println("InnerClass()");}public void method(){System.out.println(out.data1);System.out.println(out.data2);System.out.println(data3);System.out.println(data4);System.out.println(data5);System.out.println(data6);System.out.println("InnerClass的method");}} } public class Test{public static void main(String[] args) {//在實例化內部類之前并不需要實例化外部類，也不用實例化內部類OuterClass.InnerClass.data6=10;//訪問內部類的靜態成員變量//1.如何實例化靜態的內部//在實例化內部類之前并不需要實例化外部類OuterClass.InnerClass innerClass=new OuterClass.InnerClass();//拿到實例內部類的對象//} }

總結

以上是生活随笔為你收集整理的07. Java中的类和对象(嗜血无敌战神破解版)的全部內容，希望文章能夠幫你解決所遇到的問題。

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