Java中的類和對象

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

1.Java中類定義和使用

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

注意事項：

一般一個文件當(dāng)中只能有一個類

main方法所在的類一般使用public修飾，Eclipse默認(rèn)會在public修飾的類當(dāng)中找到main方法

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

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

2.類的實例化

2.1什么是實例化

定義了一個類就相當(dāng)于定義了一個新的數(shù)據(jù)類型，與int，double類似。
用類類型創(chuàng)建對象的過程就叫做實例化。

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

2.2訪問類中的屬性和方法

class Student{//字段（屬性）或成員變量————定義在類的內(nèi)部，方法的外部public String name;public String gender;public double score;//行為 或者 成員方法public void DoClass(){System.out.println(name+"正在上課");}public void DoHomework(){System.out.println(name+"正在寫作業(yè)");}public void Exam(){System.out.println(name+"得考試結(jié)果為"+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成員變量默認(rèn)值

class Student{//字段（屬性）或成員變量————定義在類的內(nèi)部，方法的外部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+"正在寫作業(yè)");}public void Exam(){System.out.println(name+"得考試結(jié)果為"+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();} }

當(dāng)成員變量沒有初始化值的時候，每個成員變量都是它對應(yīng)的 0 值：

引用類型對應(yīng)的值是 null
boolean類型對應(yīng)的是false
char 對應(yīng)的是一個空格

3.this引用

3.1為什么要用this引用

當(dāng)形參名不小心與成員變量名相同時：

public class MyDate {public int year;public int month;public int day;/*設(shè)置日期*/public void setDate(int year,int month,int day){//遵循局部變量優(yōu)先原則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();} }

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

public class MyDate {public int year;public int month;public int day;/*設(shè)置日期*/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();} }

此時的情況為什么好起來了呢，我們來調(diào)試看一下：
通過調(diào)試可以發(fā)現(xiàn)，this代表當(dāng)前對象的引用。

此外，this 本質(zhì)上是一個隱式參數(shù)：

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

代表當(dāng)前對象的引用

當(dāng)形參名不小心與成員變量名相同時，可以區(qū)別形參名與成員變量名

this 本質(zhì)上來說，是一個隱式的參數(shù)

3.2this引用特性

this的類型：對應(yīng)類類型引用，即哪個對象調(diào)用就是哪個對象的引用

this只能在成員方法中使用

在成員方法中，this只能引用當(dāng)前對象，不能引用其他對象

this是“成員方法”第一個隱藏的參數(shù)，編譯器會自動傳遞，在成員方法執(zhí)行時，編譯器會負(fù)責(zé)將調(diào)用成員方法，對象的引用傳遞給該成員方法，this負(fù)責(zé)來接收

3.3 this的用法

this.data //訪問成員變量

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

this( ) //調(diào)用本類中的其他構(gòu)造方法

4.對象的構(gòu)造及初始化

4.1構(gòu)造方法

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

構(gòu)造方法的特點：

名字必須與類名相同

沒有返回值類型，設(shè)置為void也不行

創(chuàng)建對象時由編譯器自動調(diào)用，并且在對象的生命周期內(nèi)只調(diào)用一次(相當(dāng)于人的出生，每個人只能出生一次)

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

比如：

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

為對象分配空間

調(diào)用合適的構(gòu)造方法

看一個例子：

運行結(jié)果：

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

當(dāng)程序中沒有構(gòu)造方法時，編譯器會自己生成一個不帶參數(shù)的構(gòu)造方法。

當(dāng)自己寫了構(gòu)造方法時，就不會生成構(gòu)造方法，這就使得，如果寫了構(gòu)造方法，就必須寫一個不帶參數(shù)的構(gòu)造方法

多個構(gòu)造方法之間形成重載

4.3創(chuàng)建構(gòu)造方法的快捷鍵

鼠標(biāo)右鍵————》Generate————》Constructor
—————》按住ctrl，選中要作為參數(shù)的成員變量

效果如下：

4.4 this調(diào)用構(gòu)造方法

注意：

this（）調(diào)用奔類中構(gòu)造方法時，必須放在第一行

不能形成環(huán)

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

結(jié)果分析：

4.5 初始化對象

默認(rèn)初始化

就地初始化

檢測對象對應(yīng)的類是否加載了，如果沒有加載則加載

為對象分配內(nèi)存空間

處理并發(fā)安全問題
比如：多個線程同時申請對象，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);} }

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

6.封裝

6.1 public 和 private 的區(qū)別：

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

private：私有的。意味著,被private修飾的成員只能在當(dāng)前類中訪問，這樣就比較安全，類外不可見。即對類的實現(xiàn)細(xì)節(jié)進(jìn)行隱藏

例：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 成員變量接口的提供 快捷鍵

鼠標(biāo)右鍵————》Generate————》Getter and Setter
—————》按住ctrl，選中要作為參數(shù)的成員變量

效果展示：

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 包訪問權(quán)限(默認(rèn)權(quán)限)

6.3.1 什么是包?

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

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

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

6.3.2 導(dǎo)入包中的類

Java 中已經(jīng)提供了很多現(xiàn)成的類供我們使用. 例如Date類：可以使用 java.util.Date 導(dǎo)入 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( )———獲取時間戳} }

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

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

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

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

此時就得調(diào)用哪一個包：

6.3.3 如何自定義包？

1.創(chuàng)建包的步驟：

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

3.調(diào)用自定義包：

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

自定義包的基本原則：

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

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

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

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

6.3.4 包訪問權(quán)限

在包中定義一個包訪問權(quán)限的變量 a

在同一個包中訪問 a 時：

在別的包中訪問 a 時：

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

6.3.5 public ，private ，默認(rèn)權(quán)限 的權(quán)限總結(jié)：

int a=199;//默認(rèn)權(quán)限——————只能在這個包當(dāng)中使用public int b=200;//可以隨便訪問private int c=100;//只能在同一個類中訪問

6.3.6 常見的包

java.lang:系統(tǒng)常用基礎(chǔ)類(String、Object),此包從JDK1.1后自動導(dǎo)入。

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

java.net:進(jìn)行網(wǎng)絡(luò)編程開發(fā)包。

java.sql:進(jìn)行數(shù)據(jù)庫開發(fā)的支持包。

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

java.io:I/O編程開發(fā)包

7.static成員

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

static修飾成員變量時：

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

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

7.2 類變量和類方法

字段/屬性/成員變量：

普通成員變量

靜態(tài)成員變量，又叫類變量

方法/成員方法：

普通成員方法

靜態(tài)成員變量，又叫類方法

在下面的JVM中，類變量存在方法區(qū)

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

注意：

普通的成員方法中是可以使用靜態(tài)成員變量

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

7.3 訪問類方法和類變量

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

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="三班";//通過對象調(diào)用Student.doClass();//通過類名.靜態(tài)方法名(...)方式調(diào)用Student.classes="二班";//通過類名.靜態(tài)變量 方式調(diào)用} }

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

7.4 解釋一個現(xiàn)象——之前寫的函數(shù)都用 static 修飾

之前用static修飾時，在 main 中直接用函數(shù)名就可以調(diào)用 func函數(shù)

當(dāng)沒被static修飾時，就得用以下的方式調(diào)用 func 函數(shù)

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

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

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

8. 代碼塊

8.1 代碼塊概念以及分類

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

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

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("這是一個構(gòu)造方法");}static{System.out.println("這是一個靜態(tài)代碼塊");d=10;e=20;f=30;} } public class TestDemo {public static void main(String[] args) {Student student=new Student();} }

運行結(jié)果：

優(yōu)先級：靜態(tài)代碼塊 > 實例代碼塊 > 構(gòu)造方法
當(dāng)有多個靜態(tài)代碼塊時，運行的先后順序由代碼的先后順序決定

9. 內(nèi)部類

內(nèi)部類就相當(dāng)于外部類的一個成員，實例內(nèi)部類就相當(dāng)于普通成員，其依賴于對象。
靜態(tài)內(nèi)部類就相當(dāng)于靜態(tài)成員，其不依賴于對象

9.1 內(nèi)部類的分類

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

9.2 實例內(nèi)部類

實例內(nèi)部類的問題總結(jié)：

如何實例化內(nèi)部類對象？

實例內(nèi)部類中不能定義靜態(tài)的成員變量。原因：實例內(nèi)部類是需要實例化外部類對象才能訪問的。那么非要定義的話，可以加 final ，將該變量變?yōu)槌Ａ?/li>

當(dāng)內(nèi)部類和外部類變量重名了。怎么辦? 優(yōu)先使用內(nèi)部類自己的變量。那么如何拿到外部類的變量呢？

在實例內(nèi)部類當(dāng)中不能定義靜態(tài)方法，因為實例內(nèi)部類是依賴對象的，當(dāng)沒有外部類對象時，內(nèi)部類這個類是不存在的，當(dāng)類不存在時，當(dāng)然也就不能訪問其中的靜態(tài)方法。

class OuterClass1{public int data1=10;private int data2=20;public static int data3=30;//實例內(nèi)部類class InnerClass{public int data1=1000;private int data5=50;//2.在實例內(nèi)部類中定義靜態(tài)的成員變量public static final int data6=60;public InnerClass(){System.out.println("InnerClass1的構(gòu)造方法！");}public void method(){System.out.println(data1);System.out.println(this.data1);//與data1 一樣//在實例內(nèi)部類當(dāng)中訪問重名的外部類的成員變量System.out.println(OuterClass1.this.data1);//可以意識到，在實力內(nèi)部類當(dāng)中，不僅包含了自己的this，而且包含了外部類的thisSystem.out.println(data2);System.out.println(data3);System.out.println(data5);System.out.println(data6);System.out.println("InnerClass的一個method方法！");}}//在外部類當(dāng)中訪問內(nèi)部變量——————即訪問外部類的對象，所以要創(chuàng)建對象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();//實例外部類//外部類名.內(nèi)部類名——————拿到內(nèi)部類的類型OuterClass1.InnerClass innerClass=outerClass.new InnerClass();//實例化方法2：OuterClass1.InnerClass innerClass1=new OuterClass1().new InnerClass();innerClass.method();} }

9.3 靜態(tài)內(nèi)部類

靜態(tài)內(nèi)部類中的問題總結(jié)：

如何實例化靜態(tài)的內(nèi)部：靜態(tài)的成員不依賴以對象

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

class OuterClass{public int data1=10;private int data2=20;public static int data3=30;public void method(){System.out.println("OuterClass:method()");}//靜態(tài)內(nèi)部類:static class InnerClass{public int data4=40;private int data5=50;public static int data6=60;//2. 在靜態(tài)內(nèi)部類當(dāng)中，只能訪問外部類的靜態(tài)成員變量。但是如果非要訪問外部類的非靜態(tài)變量，那么怎么訪問？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) {//在實例化內(nèi)部類之前并不需要實例化外部類，也不用實例化內(nèi)部類OuterClass.InnerClass.data6=10;//訪問內(nèi)部類的靜態(tài)成員變量//1.如何實例化靜態(tài)的內(nèi)部//在實例化內(nèi)部類之前并不需要實例化外部類OuterClass.InnerClass innerClass=new OuterClass.InnerClass();//拿到實例內(nèi)部類的對象//} }

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。