喝咖啡休息#174。在 Java 中建立物件的不同方法。Java 中的 String 到 Int - 如何將 String 轉換為 Integer

在 Java 中建立物件的不同方法

來源：Medium 在本教程中，我們將學習在 Java 中建立物件的不同方法。 Java 物件是Java 類別的實例。每個物件都有一個狀態、一個行為和一個識別符。欄位（變數）儲存物件的狀態，而方法（函數）顯示物件的操作。類別充當在運行時創建物件實例的“藍圖”。

在 Java 中建立對象

創建物件是分配記憶體以儲存類別欄位中的資料（也稱為變數）的過程。這個過程通常稱為創建類別的實例。在 Java 中建立物件有四種不同的方法：

1. 使用new關鍵字
2. 方法newInstance()
3. 克隆()方法
4. 反序列化物件

現在讓我們詳細看看提到的每個方法。

關鍵字新

這是在 Java 中建立物件最常見的方法。new關鍵字透過為指定類型的新實例分配記憶體來建立類別的實例。new 之後是建構子 - 一種特殊方法，負責建立物件並初始化所建立物件的欄位。物件是使用new運算子創建的，並使用建構函數初始化的。以下是使用new運算子建立 Java 物件的範例：

Date today = new Date();

此表達式產生一個新的Date物件（Date是java.util套件中的一個類別）。程式碼中的這個子句執行三個操作：宣告、實例化和初始化。Date Today是一個變數聲明，它通知編譯器今天將引用Date類型的物件。new 運算子實例化Date類別（在記憶體中建立一個新的Date物件），並且Date()初始化該物件。考慮下面的例子：

public class Person {
    private String name;
    private int uid;

    public Person() {
        this.name = "Michael Cole";
        this.uid = 101;
    }

    public Person(String name, int uid) {
        super();
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...

    public static void main(String[] args) {

        Person p1 = new Person();
        Person p2 = new Person("John Bodgan", 102);
        System.out.println("Name: " + p1.getName() + " UID: " + p1.getUid());
        System.out.println("Name: " + p2.getName() + " UID: " + p2.getUid());
    }
}

在這段程式碼中，我們使用new關鍵字建立一個Person物件：

• p1物件呼叫非參數化建構函數，變數名稱值設定為“Michael Cole”，UID 設定為 101。
• p2物件呼叫參數化建構函數，將值「John Bodgan」和102傳遞給建構函數，然後為這些值指派變數名稱和UID。

使用 newInstance() 方法

Java 中的newInstance()方法用於動態建立給定類別的物件實例。newInstance()方法有兩種標準用法：

• java.lang.Class API中的newInstance()方法
• java.lang.reflect.Constructor API中的newInstance()方法

使用類別 API 中的 newInstance()

要在執行時間建立類別的對象，我們必須從 Class API 呼叫newInstance()方法，該方法傳回該類別的對象。java.lang.Class類別的newInstance()方法不帶任何參數或實參，可以稱為該類別的無參建構子。讓我們來看一些使用java.lang.Class類別的newInstance()方法建立Person類別物件的範例程式碼：

public class Person {
    private String name;
    private int uid;

    public Person() {
        this.name = "Carl Max";
        this.uid = 101;
    }

   // getters and setters...
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class c = Class.forName("com.medium.option2.Person");
        @SuppressWarnings("deprecation")
        Person p = (Person) c.newInstance();
        System.out.println("Name: " + p.getName());
        System.out.println("UID: " + p.getUid());
    }
}

Class.forName（類別的完全限定名）載入一個名為Person的類，然後newInstance()建立一個Person類型的新物件並傳回對其的參考。現在，使用Person對p 的引用，我們可以呼叫它的getters()和setter()來執行某些操作。請注意：

• Class.forName ()和newIstance()都會拋出異常，必須使用try和catch區塊或throws關鍵字來處理這些異常。
• 自 Java 9 起，類別 API 中的newInstance()方法已被棄用。

使用建構函式 API 中的 newInstance()

Constructor類別( java.lang.reflect.Constructor ) 的newInstance()方法與Class類別的newInstance()方法類似，不同之處在於它接受參數化建構子的參數。讓我們透過使用java.lang.reflect.Constructor類別的newInstance()方法來建立Person類別的物件來示範這種方法：

public class PersonTwo {
    private String name;
    private int uid;

    public PersonTwo() {
        this.name = "Maya Kumari";
        this.uid = 101;
    }

    public PersonTwo(String name) {
        this.name = name;
        this.uid = 102;
    }

    public PersonTwo(String name, Integer uid) {
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...
    public static void main(String[] args) {
        try {
            Class.forName("com.medium.option2.PersonTwo");

            Constructor c1 = PersonTwo.class.getConstructor();
            PersonTwo p1 = (PersonTwo) c1.newInstance();
            System.out.println("Name: " + p1.getName());
            System.out.println("UID: " + p1.getUid());

            Constructor c2 = PersonTwo.class.getConstructor(String.class);
            PersonTwo p2 = (PersonTwo) c2.newInstance("James Gunn");
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());

            Constructor c3 = PersonTwo.class.getConstructor(String.class, Integer.class);
            PersonTwo p3 = (PersonTwo) c3.newInstance("Mark Brown", 103);
            System.out.println("Name: " + p3.getName());
            System.out.println("UID: " + p3.getUid());

        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

在上面的程式碼中，首先我們需要使用Class.forName()方法 來載入類別。接下來，我們將呼叫getConstructor()方法來匹配傳遞參數的資料類型。最後，在newInstance()方法中，我們傳遞所需的參數（如果沒有參數則為null ）。newInstance()方法將透過呼叫適當的建構子傳回PersonTwo類別的新物件。

使用clone()方法

clone()方法是Object類別的一部分，用於建立現有物件的副本。它創建類別的物件而不呼叫任何類別構造函數。要克隆方法，對應的類別必須實作Cloneable接口，這是一個標記接口。現在我們將建立一個Person類別的對象，然後將其克隆到Person類別的另一個對象：

public class Person implements Cloneable {
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    private String name;
    private int uid;

    public Person(String name, int uid) {
        super();
        this.name = name;
        this.uid = uid;
    }

    // getters and setters...

    public static void main(String[] args) {
        Person p1 = new Person("Ryan", 101);
        try {
            Person p2 = (Person) p1.clone();
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }
}

筆記。克隆的物件將透過p2引用引用相同的原始物件。但是，克隆的物件將具有單獨的記憶體分配。這表示對p2引用的Person物件所做的任何更改都不會更改p1引用的原始Person物件。這是因為clone()方法建立了物件的淺表副本。

使用物件反序列化

物件反序列化是從一系列位元組流中提取物件的過程。序列化則相反。它的主要目的是將儲存的物件從資料庫/網路檢索回記憶體。如果我們想要序列化或反序列化一個對象，我們需要實作Serialized介面（token介面）。考慮下面的例子：

public class PersonDriver {

    public static void main(String[] args) {
        Person p1 = new Person("Max Payne", 101);
        FileOutputStream fileOutputStream;
        try {
            fileOutputStream = new FileOutputStream("link to text file");
            ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
            outputStream.writeObject(p1);
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        FileInputStream fileInputStream;
        try {
            fileInputStream = new FileInputStream("link to text file");
            ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
            Person p2 = (Person) inputStream.readObject();
            System.out.println("Name: " + p2.getName());
            System.out.println("UID: " + p2.getUid());
            inputStream.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

這裡我們先引用p1將Person物件序列化到文字檔中。writeObject()方法會將物件的位元組流寫入文字檔。然後，使用物件反序列化，我們將Person物件提取回p2。類似地，readObject()方法將從物件的輸入流中讀取物件。最後，我們將Person物件中的資料列印到控制台。

結論

在本文中，我們了解了在 Java 中建立物件的不同方法。首先，我們研究了使用new關鍵字建立對象，這是最常見的方式。然後我們從Class和Constructor類別中學習了newInstance()方法，這是另一種建立物件的流行方法。然後我們使用clone()方法，它建立現有物件的淺表副本，而不是建立新物件。最後，我們使用物件序列化和反序列化的概念在Java中建立物件。

Java 中的 String to Int - 如何將字串轉換為整數

來源： FreeCodeCamp 今天您將學習如何在 Java 中使用Integer類別的兩個方法- parseInt()和valueOf()將字串轉換為整數。這將有助於您使用字串變數的值執行數學運算。

如何在 Java 中使用 Integer.parseInt 將字串轉換為整數

此選項假設parseInt()方法將字串轉換為整數作為參數：

Integer.parseInt(string_varaible)

在查看其使用範例之前，讓我們看看當您將字串值和整數相加而不進行任何轉換時會發生什麼：

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        System.out.println(age + 20);
        // 1020
    }
}

在此程式碼中，我們建立了一個字串值「10」的變數age 。當我們將數字 20 加到整數值時，我們錯誤地收到了 1020，而不是正確的答案 30。這可以使用 parseInt ()方法來修正：

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        int age_to_int = Integer.parseInt(age);

        System.out.println(age_to_int + 20);
        // 30
    }
}

在這裡，為了將age變數轉換為整數，我們將其作為參數傳遞給parseInt()方法- Integer.parseInt(age) - 並將其儲存在名為age_to_int的變數中。現在，當加入到另一個整數時，我們得到正確的加法：age_to_int + 20。

如何在 Java 中使用 Integer.valueOf 將字串轉換為整數

valueOf()方法的工作方式與parseInt()方法相同。它採用需要轉換為整數的字串作為參數。這是一個例子：

class StrToInt {
    public static void main(String[] args) {
        String age = "10";

        int age_to_int = Integer.valueOf(age);

        System.out.println(age_to_int + 20);
        // 30
    }
}

在上面的程式碼中，您可以看到與上一節相同的內容：

• 我們將一個字串作為參數傳遞給valueOf()：Integer.valueOf(age)。它儲存在名為age_to_int 的變數中。
• 然後我們將 10 加到已建立的變數：age_to_int + 20。結果是 30，而不是 1020。

結論

在本文中，我們討論了在 Java 中將字串轉換為整數。要將字串轉換為整數，使用了Integer類別的兩個方法- parseInt()和valueOf()。快樂編碼！