Java的Class類和Object類如何使用

這篇文章主要介紹“Java的Class類和Object類如何使用”，在日常操作中，相信很多人在Java的Class類和Object類如何使用問(wèn)題上存在疑惑，小編查閱了各式資料，整理出簡(jiǎn)單好用的操作方法，希望對(duì)大家解答”Java的Class類和Object類如何使用”的疑惑有所幫助！接下來(lái)，請(qǐng)跟著小編一起來(lái)學(xué)習(xí)吧！

Java中的構(gòu)造方法

構(gòu)造方法簡(jiǎn)介

構(gòu)造方法是類的一種特殊方法，用來(lái)初始化類的一個(gè)新的對(duì)象。 Java 中的每個(gè)類都有一個(gè)默認(rèn)的構(gòu)造方法，它必須具有和類名相同的名稱，而且沒(méi)有返回類型。構(gòu)造方法的默認(rèn)返回類型就是對(duì)象類型本身，并且構(gòu)造方法不能被 static、final、synchronized、abstract 和 native 修飾。

提示：構(gòu)造方法用于初始化一個(gè)新對(duì)象，所以用 static 修飾沒(méi)有意義；構(gòu)造方法不能被子類繼承，所以用 final 和 abstract 修飾沒(méi)有意義；多個(gè)線程不會(huì)同時(shí)創(chuàng)建內(nèi)存地址相同的同一個(gè)對(duì)象，所以用 synchronized 修飾沒(méi)有必要。

構(gòu)造方法的語(yǔ)法格式如下：

class class_name
{
    public class_name(){}    //默認(rèn)無(wú)參構(gòu)造方法
    public ciass_name([paramList]){}    //定義構(gòu)造方法
    …
    //類主體
}

在一個(gè)類中，與類名相同的方法就是構(gòu)造方法。每個(gè)類可以具有多個(gè)構(gòu)造方法，但要求它們各自包含不同的方法參數(shù)。

構(gòu)造方法實(shí)例

例 1

構(gòu)造方法主要有無(wú)參構(gòu)造方法和有參構(gòu)造方法兩種，示例如下：

public class MyClass
{
    private int m;    //定義私有變量
    MyClass()
    {
        //定義無(wú)參的構(gòu)造方法
        m=0;
    }
    MyCiass(int m)
    {
        //定義有參的構(gòu)造方法
        this.m=m;
    }
}

該示例定義了兩個(gè)構(gòu)造方法，分別是無(wú)參構(gòu)造方法和有參構(gòu)造方法。在一個(gè)類中定義多個(gè)具有不同參數(shù)的同名方法，這就是方法的重載。這兩個(gè)構(gòu)造方法的名稱都與類名相同，均為 MyClass。在實(shí)例化該類時(shí)可以調(diào)用不同的構(gòu)造方法進(jìn)行初始化。

注意：類的構(gòu)造方法不是要求必須定義的。如果在類中沒(méi)有定義任何一個(gè)構(gòu)造方法，則 Java 會(huì)自動(dòng)為該類生成一個(gè)默認(rèn)的構(gòu)造方法。默認(rèn)的構(gòu)造方法不包含任何參數(shù)，并且方法體為空。如果類中顯式地定義了一個(gè)或多個(gè)構(gòu)造方法，則 Java 不再提供默認(rèn)構(gòu)造方法。

例 2

要在不同的條件下使用不同的初始化行為創(chuàng)建類的對(duì)象，這時(shí)候就需要在一個(gè)類中創(chuàng)建多個(gè)構(gòu)造方法。下面通過(guò)一個(gè)示例來(lái)演示構(gòu)造方法的使用。

(1) 首先在員工類 Worker 中定義兩個(gè)構(gòu)造方法，代碼如下：

public class Worker
{
    public String name;    //姓名
    private int age;    //年齡
    //定義帶有一個(gè)參數(shù)的構(gòu)造方法
    public Worker(String name)
    {
        this.name=name;
    }
    //定義帶有兩個(gè)參數(shù)的構(gòu)造方法
    public Worker(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String toString()
    {
        return"大家好！我是新來(lái)的員工，我叫"+name+"，今年"+age+"歲。";
    }
}

在 Worker 類中定義了兩個(gè)屬性，其中 name 屬性不可改變。分別定義了帶有一個(gè)參數(shù)和帶有兩個(gè)參數(shù)的構(gòu)造方法，并對(duì)其屬性進(jìn)行初始化。最后定義了該類的 toString() 方法，返回一條新進(jìn)員工的介紹語(yǔ)句。

提示：Object 類具有一個(gè) toString() 方法，該方法是個(gè)特殊的方法，創(chuàng)建的每個(gè)類都會(huì)繼承該方法，它返回一個(gè) String 類型的字符串。如果一個(gè)類中定義了該方法，則在調(diào)用該類對(duì)象時(shí)，將會(huì)自動(dòng)調(diào)用該類對(duì)象的 toString() 方法返回一個(gè)字符串，然后使用“System.out.println(對(duì)象名)”就可以將返回的字符串內(nèi)容打印出來(lái)。

(2) 在 TestWorker 類中創(chuàng)建 main() 方法作為程序的入口處，在 main() 方法中調(diào)用不同的構(gòu)造方法實(shí)例化 Worker 對(duì)象，并對(duì)該對(duì)象中的屬性進(jìn)行初始化，代碼如下：

public class TestWorker
{
    public static void main(String[] args)
    {
        System.out.println("-----------帶有一個(gè)參數(shù)的構(gòu)造方法-----------");
        //調(diào)用帶有一個(gè)參數(shù)的構(gòu)造方法，Staff類中的sex和age屬性值不變
        Worker worker1=new Worker("張強(qiáng)");
        System.out.println(worker1);
        System.out.println("-----------帶有兩個(gè)參數(shù)的構(gòu)造方法------------");
        //調(diào)用帶有兩個(gè)參數(shù)的構(gòu)造方法，Staff類中的sex屬性值不變
        Worker worker2=new Worker("李麗",25);
        System.out.println(worker2);
    }
}

在上述代碼中，創(chuàng)建了兩個(gè)不同的 Worker 對(duì)象：一個(gè)是姓名為張強(qiáng)的員工對(duì)象，一個(gè)是姓名為李麗、年齡為 25 的員工對(duì)象。對(duì)于第一個(gè) Worker 對(duì)象 Worker1，并未指定 age 屬性值，因此程序會(huì)將其值采用默認(rèn)值 0。對(duì)于第二個(gè) Worker 對(duì)象 Worker2，分別對(duì)其指定了 name 屬性值和 age 屬性值，因此程序會(huì)將傳遞的參數(shù)值重新賦值給 Worker 類中的屬性值。

運(yùn)行 TestWorker 類，輸出的結(jié)果如下：

-----------帶有一個(gè)參數(shù)的構(gòu)造方法-----------
大家好！我是新來(lái)的員工，我叫張強(qiáng)，今年0歲。
-----------帶有兩個(gè)參數(shù)的構(gòu)造方法------------
大家好！我是新來(lái)的員工，我叫李麗，今年25歲。

通過(guò)調(diào)用帶參數(shù)的構(gòu)造方法，在創(chuàng)建對(duì)象時(shí)，一并完成了對(duì)象成員的初始化工作，簡(jiǎn)化了對(duì)象初始化的代碼。

Java中的幾種構(gòu)造方法詳解

普通構(gòu)造方法

方法名與類名相同

無(wú)返回類型

子類不能繼承父類的構(gòu)造方法

不能被static、final、abstract修飾（有final和static修飾的是不能被子類繼承的，abstract修飾的是抽象類，抽象類是不能實(shí)例化的，也就是不能new）

可以被private修飾，可以在本類里面實(shí)例化，但是外部不能實(shí)例化對(duì)象（注意?。。。?/p>

public class A{
    int i=0;
    public A(){
        i=2;
    }
    public A(int i){
        this.i=i;
    }
}

默認(rèn)構(gòu)造方法

如果沒(méi)有任何的構(gòu)造方法，編譯時(shí)系統(tǒng)會(huì)自動(dòng)添加一個(gè)默認(rèn)無(wú)參構(gòu)造方法

隱含的默認(rèn)構(gòu)造方法

    public A(){}

顯示的默認(rèn)構(gòu)造方法

    public A(){
    System.out.print("顯示的默認(rèn)構(gòu)造方法")
    }

重載構(gòu)造方法

比如原本的類里的構(gòu)造方法是一個(gè)參數(shù)的，現(xiàn)在新建的對(duì)象是有三個(gè)參數(shù)，此時(shí)就要重載構(gòu)造方法

當(dāng)一個(gè)類中有多個(gè)構(gòu)造方法，有可能會(huì)出現(xiàn)重復(fù)性操作，這時(shí)可以用this語(yǔ)句調(diào)用其他的構(gòu)造方法。

public class A{
    private int age;
    private String name;
    public A(int age,String name){
        this.age=age;
        this.name=name;
    }
    public A(int age){
        this(age,"無(wú)名氏");//調(diào)用 A(int age,String name)構(gòu)造方法
    }
    public A(){
        this(1);//調(diào)用 A(int age)構(gòu)造方法
    }
    public void setName(String name) {this.name=name;}
    public String getName() {return name;}
    public void setAge(int age) {this.age=age;}
    public int getAge() {return age;}
}
A a=new A(20,"周一");
A b=new A(20);
A c=new A();
String name = a.getName();
String name1 = b.getName();
int age = c.getAge();
System.out.println(name);
System.out.println(name1);
System.out.println(age);

java子類構(gòu)造方法調(diào)用父類構(gòu)造方法

首先父類構(gòu)造方法是絕對(duì)不能被子類繼承的。

子類構(gòu)造方法調(diào)用父類的構(gòu)造方法重點(diǎn)是：子類構(gòu)造方法無(wú)論如何都要調(diào)用父類的構(gòu)造方法。

子類構(gòu)造方法要么調(diào)用父類無(wú)參構(gòu)造方法（包括當(dāng)父類沒(méi)有構(gòu)造方法時(shí)。系統(tǒng)默認(rèn)給的無(wú)參構(gòu)造方法），要么調(diào)用父類有參構(gòu)造方法。當(dāng)子類構(gòu)造方法調(diào)用父類無(wú)參構(gòu)造方法，一般都是默認(rèn)不寫(xiě)的，要寫(xiě)的話就是super（），且要放在構(gòu)造方法的第一句。當(dāng)子類構(gòu)造方法要調(diào)用父類有參數(shù)的構(gòu)造方法，那么子類的構(gòu)造方法中必須要用super（參數(shù)）調(diào)用父類構(gòu)造方法，且要放在構(gòu)造方法的第一句。

當(dāng)子類的構(gòu)造方法是無(wú)參構(gòu)造方法時(shí)，必須調(diào)用父類無(wú)參構(gòu)造方法。因?yàn)橄到y(tǒng)會(huì)自動(dòng)找父類有沒(méi)有無(wú)參構(gòu)造方法，如果沒(méi)有的話系統(tǒng)會(huì)報(bào)錯(cuò)：說(shuō)父類沒(méi)有定義無(wú)參構(gòu)造方法。

當(dāng)子類構(gòu)造方法是有參構(gòu)造方法時(shí)，這時(shí)就會(huì)有兩種情況。
第一種：子類構(gòu)造方法沒(méi)有寫(xiě)super，也就是說(shuō)你默認(rèn)調(diào)用父類無(wú)參構(gòu)造方法，這樣的話就和子類是無(wú)參構(gòu)造方法一樣。

第二種：子類構(gòu)造方法有super（參數(shù)）時(shí)，就是調(diào)用父類有參構(gòu)造方法，系統(tǒng)會(huì)找父類有沒(méi)有參數(shù)一致（參數(shù)數(shù)量，且類型順序要相同）的有參構(gòu)造方法，如果沒(méi)有的話，同樣也會(huì)報(bào)錯(cuò)。

但是這里會(huì)遇到和重載構(gòu)造方法this一樣問(wèn)題，一個(gè)參數(shù)的構(gòu)造方法可以調(diào)用多個(gè)參數(shù)構(gòu)造方法，沒(méi)有的參數(shù)給一個(gè)自己定義值也是可以的。

Java中的代碼塊簡(jiǎn)介

在java中用{}括起來(lái)的稱為代碼塊，代碼塊可分為以下四種：

一.簡(jiǎn)介

1.普通代碼塊：

類中方法的方法體

2.構(gòu)造代碼塊：

構(gòu)造塊會(huì)在創(chuàng)建對(duì)象時(shí)被調(diào)用，每次創(chuàng)建時(shí)都會(huì)被調(diào)用，優(yōu)先于類構(gòu)造函數(shù)執(zhí)行。

3.靜態(tài)代碼塊：

用static{}包裹起來(lái)的代碼片段，只會(huì)執(zhí)行一次。靜態(tài)代碼塊優(yōu)先于構(gòu)造塊執(zhí)行。

4.同步代碼塊：

使用synchronized（）{}包裹起來(lái)的代碼塊，在多線程環(huán)境下，對(duì)共享數(shù)據(jù)的讀寫(xiě)操作是需要互斥進(jìn)行的，否則會(huì)導(dǎo)致數(shù)據(jù)的不一致性。同步代碼塊需要寫(xiě)在方法中。

二.靜態(tài)代碼塊和構(gòu)造代碼塊的異同點(diǎn)

相同點(diǎn)：都是JVM加載類后且在構(gòu)造函數(shù)執(zhí)行之前執(zhí)行，在類中可定義多個(gè)，一般在代碼塊中對(duì)一些static變量進(jìn)行賦值。

不同點(diǎn)：靜態(tài)代碼塊在非靜態(tài)代碼塊之前執(zhí)行。靜態(tài)代碼塊只在第一次new時(shí)執(zhí)行一次，之后不在執(zhí)行。而非靜態(tài)代碼塊每new一次就執(zhí)行一次。

Java代碼塊使用

局部代碼塊

位置：局部位置（方法內(nèi)部）

作用：限定變量的生命周期，盡早釋放，節(jié)約內(nèi)存

調(diào)用：調(diào)用其所在的方法時(shí)執(zhí)行

 public class 局部代碼塊 {
@Test
public void test (){
    B b = new B();
    b.go();
}
}
class B {
    B(){}
    public void go() {
        //方法中的局部代碼塊，一般進(jìn)行一次性地調(diào)用，調(diào)用完立刻釋放空間，避免在接下來(lái)的調(diào)用過(guò)程中占用?？臻g
        //因?yàn)闂？臻g內(nèi)存是有限的，方法調(diào)用可能會(huì)會(huì)生成很多局部變量導(dǎo)致棧內(nèi)存不足。
        //使用局部代碼塊可以避免這樣的情況發(fā)生。
        {
            int i = 1;
            ArrayList<Integer> list = new ArrayList<>();
            while (i < 1000) {
                list.add(i ++);
            }
            for (Integer j : list) {
                System.out.println(j);
            }
            System.out.println("gogogo");
        }
        System.out.println("hello");
    }
}

構(gòu)造代碼塊

位置：類成員的位置，就是類中方法之外的位置

作用：把多個(gè)構(gòu)造方法共同的部分提取出來(lái)，共用構(gòu)造代碼塊

調(diào)用：每次調(diào)用構(gòu)造方法時(shí)，都會(huì)優(yōu)先于構(gòu)造方法執(zhí)行，也就是每次new一個(gè)對(duì)象時(shí)自動(dòng)調(diào)用，對(duì)  對(duì)象的初始化

class A{
    int i = 1;
    int initValue;//成員變量的初始化交給代碼塊來(lái)完成
    {
        //代碼塊的作用體現(xiàn)于此：在調(diào)用構(gòu)造方法之前，用某段代碼對(duì)成員變量進(jìn)行初始化。
        //而不是在構(gòu)造方法調(diào)用時(shí)再進(jìn)行。一般用于將構(gòu)造方法的相同部分提取出來(lái)。
        //
        for (int i = 0;i < 100;i ++) {
            initValue += i;
        }
    }
    {
        System.out.println(initValue);
        System.out.println(i);//此時(shí)會(huì)打印1
        int i = 2;//代碼塊里的變量和成員變量不沖突，但會(huì)優(yōu)先使用代碼塊的變量
        System.out.println(i);//此時(shí)打印2
        //System.out.println(j);//提示非法向后引用，因?yàn)榇藭r(shí)j的的初始化還沒(méi)開(kāi)始。
        //
    }
    {
        System.out.println("代碼塊運(yùn)行");
    }
    int j = 2;
    {
        System.out.println(j);
        System.out.println(i);//代碼塊中的變量運(yùn)行后自動(dòng)釋放，不會(huì)影響代碼塊之外的代碼
    }
    A(){
        System.out.println("構(gòu)造方法運(yùn)行");
    }
}
public class 構(gòu)造代碼塊 {
    @Test
    public void test() {
        A a = new A();
    }
}

靜態(tài)代碼塊

 位置：類成員位置，用static修飾的代碼塊
 作用：對(duì)類進(jìn)行一些初始化  只加載一次，當(dāng)new多個(gè)對(duì)象時(shí)，只有第一次會(huì)調(diào)用靜態(tài)代碼塊，因?yàn)?，靜態(tài)代碼塊                  是屬于類的，所有對(duì)象共享一份
 調(diào)用: new 一個(gè)對(duì)象時(shí)自動(dòng)調(diào)用
 public class 靜態(tài)代碼塊 {
@Test
public void test() {
    C c1 = new C();
    C c2 = new C();
    //結(jié)果,靜態(tài)代碼塊只會(huì)調(diào)用一次，類的所有對(duì)象共享該代碼塊
    //一般用于類的全局信息初始化
    //靜態(tài)代碼塊調(diào)用
    //代碼塊調(diào)用
    //構(gòu)造方法調(diào)用
    //代碼塊調(diào)用
    //構(gòu)造方法調(diào)用
}
}
class C{
    C(){
        System.out.println("構(gòu)造方法調(diào)用");
    }
    {
        System.out.println("代碼塊調(diào)用");
    }
    static {
        System.out.println("靜態(tài)代碼塊調(diào)用");
    }
}

Java代碼塊、構(gòu)造方法（包含繼承關(guān)系）的執(zhí)行順序

這是一道常見(jiàn)的面試題，要回答這個(gè)問(wèn)題，先看看這個(gè)實(shí)例吧。

一共3個(gè)類：A、B、C
其中A是B的父類，C無(wú)繼承僅作為輸出

A類：

public class A {
static {
    Log.i("HIDETAG", "A靜態(tài)代碼塊");
}
private static C c = new C("A靜態(tài)成員");
private  C c1 = new C("A成員");
{
    Log.i("HIDETAG", "A代碼塊");
}
static {
    Log.i("HIDETAG", "A靜態(tài)代碼塊2");
}
public A() {
    Log.i("HIDETAG", "A構(gòu)造方法");
}
}

B類：

public class B extends A {
private static C c1 = new C("B靜態(tài)成員");
{
    Log.i("HIDETAG", "B代碼塊");
}
private C c = new C("B成員");
static {
    Log.i("HIDETAG", "B靜態(tài)代碼塊2");
}
static {
    Log.i("HIDETAG", "B靜態(tài)代碼塊");
}
public B() {
    Log.i("HIDETAG", "B構(gòu)造方法");
}
}

C類：

public class C {
public C(String str) {
    Log.i("HIDETAG", str + "構(gòu)造方法");
}
}

執(zhí)行語(yǔ)句：new B();

輸出結(jié)果如下：

 I/HIDETAG: A靜態(tài)代碼塊
 I/HIDETAG: A靜態(tài)成員構(gòu)造方法
 I/HIDETAG: A靜態(tài)代碼塊2
 I/HIDETAG: B靜態(tài)成員構(gòu)造方法
 I/HIDETAG: B靜態(tài)代碼塊2
 I/HIDETAG: B靜態(tài)代碼塊
 I/HIDETAG: A成員構(gòu)造方法
 I/HIDETAG: A代碼塊
 I/HIDETAG: A構(gòu)造方法
 I/HIDETAG: B代碼塊
 I/HIDETAG: B成員構(gòu)造方法
 I/HIDETAG: B構(gòu)造方法

得出結(jié)論：

執(zhí)行順序依次為：
父類的靜態(tài)成員和代碼塊
子類靜態(tài)成員和代碼塊
父類成員初始化和代碼快
父類構(gòu)造方法
子類成員初始化和代碼塊
子類構(gòu)造方法

注意：可以發(fā)現(xiàn)，同一級(jí)別的代碼塊和成員初始化是按照代碼順序從上到下依次執(zhí)行

看完上面這個(gè)demo，再來(lái)看看下面這道題，看看你搞得定嗎？

看下面一段代碼，求執(zhí)行順序：

class A {
    public A() {
        System.out.println("1A類的構(gòu)造方法");
    }
    {
        System.out.println("2A類的構(gòu)造快");
    }
    static {
        System.out.println("3A類的靜態(tài)塊");
    }
}
public class B extends A {
    public B() {
        System.out.println("4B類的構(gòu)造方法");
    }
    {
        System.out.println("5B類的構(gòu)造快");
    }
    static {
        System.out.println("6B類的靜態(tài)塊");
    }
    public static void main(String[] args) {
        System.out.println("7");
        new B();
        new B();
        System.out.println("8");
    }
}

執(zhí)行順序結(jié)果為：367215421548

為什么呢？

首先我們要知道下面這5點(diǎn)：

每次new都會(huì)執(zhí)行構(gòu)造方法以及構(gòu)造塊。
構(gòu)造塊的內(nèi)容會(huì)在構(gòu)造方法之前執(zhí)行。
非主類的靜態(tài)塊會(huì)在類加載時(shí)，構(gòu)造方法和構(gòu)造塊之前執(zhí)行，切只執(zhí)行一次。
主類（public class）里的靜態(tài)塊會(huì)先于main執(zhí)行。
繼承中，子類實(shí)例化，會(huì)先執(zhí)行父類的構(gòu)造方法，產(chǎn)生父類對(duì)象，再調(diào)用子類構(gòu)造方法。
所以題目里，由于主類B繼承A，所以會(huì)先加載A，所以第一個(gè)執(zhí)行的是第3句。

從第4點(diǎn)我們知道6會(huì)在7之前執(zhí)行，所以前三句是367。

之后實(shí)例化了B兩次，每次都會(huì)先實(shí)例化他的父類A，然后再實(shí)例化B，而根據(jù)第1、2、5點(diǎn)，知道順序?yàn)?154。

最后執(zhí)行8

所以順序是367215421548

到此，關(guān)于“Java的Class類和Object類如何使用”的學(xué)習(xí)就結(jié)束了，希望能夠解決大家的疑惑。理論與實(shí)踐的搭配能更好的幫助大家學(xué)習(xí)，快去試試吧！若想繼續(xù)學(xué)習(xí)更多相關(guān)知識(shí)，請(qǐng)繼續(xù)關(guān)注億速云網(wǎng)站，小編會(huì)繼續(xù)努力為大家?guī)?lái)更多實(shí)用的文章！