Coffee break #174. Cara Berbeza untuk Mencipta Objek dalam Java.String ke Int dalam Java - Cara Menukar String kepada Integer

Cara yang berbeza untuk mencipta objek dalam Java

Sumber: Sederhana Dalam tutorial ini, kita akan mempelajari cara yang berbeza untuk mencipta objek dalam Java. Objek Java ialah contoh kelas Java. Setiap objek mempunyai keadaan, tingkah laku dan pengecam. Medan (pembolehubah) menyimpan keadaan objek, manakala kaedah (fungsi) menunjukkan tindakan objek. Kelas berfungsi sebagai "cetak biru" dari mana tika objek dibuat pada masa jalan.

Mencipta Objek dalam Java

Penciptaan objek ialah proses memperuntukkan memori untuk menyimpan data dalam medan kelas (juga dipanggil pembolehubah). Proses ini sering dipanggil mencipta contoh kelas. Terdapat empat cara berbeza untuk mencipta objek dalam Java:

1. menggunakan kata kunci baharu
2. kaedah newInstance()
3. kaedah klon().
4. menyahsiri objek

Sekarang mari kita lihat setiap kaedah yang disebutkan secara terperinci.

Kata kunci baharu

Ini adalah cara yang paling biasa untuk mencipta objek dalam Java. Kata kunci baharu mencipta tika kelas dengan memperuntukkan memori untuk tika baharu jenis yang ditentukan. Selepas baru datang pembina - kaedah khas yang bertanggungjawab untuk mencipta objek dan memulakan medan objek yang dicipta. Objek dicipta dengan pengendali baharu dan dimulakan dengan pembina. Berikut ialah contoh mencipta objek Java dengan pengendali baharu :

Date today = new Date();

Ungkapan ini menjana objek Date baharu ( Date ialah kelas di dalam pakej java.util ). Klausa tunggal dalam kod ini menjalankan tiga operasi: pengisytiharan, instantiasi dan permulaan. Tarikh hari ini ialah pengisytiharan pembolehubah yang memaklumkan pengkompil bahawa hari ini akan merujuk kepada objek jenis Date . Operator baharu membuat instantiate kelas Date (mencipta objek Date baharu dalam ingatan), dan Date() memulakan objek. Pertimbangkan contoh di bawah:

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());
    }
}

Daripada kod ini, kami mencipta objek Orang menggunakan kata kunci baharu :

• Objek p1 memanggil pembina tidak berparameter dengan nilai nama pembolehubah ditetapkan kepada "Michael Cole" dan UID ditetapkan kepada 101.
• Objek p2 memanggil pembina berparameter, di mana ia menghantar nilai "John Bodgan" dan 102 kepada pembina. Nilai ini kemudiannya diberikan nama pembolehubah dan UID.

Menggunakan kaedah newInstance().

Kaedah newInstance() dalam Java digunakan untuk mencipta tika objek kelas tertentu secara dinamik. Terdapat dua kegunaan standard kaedah newInstance() :

• kaedah newInstance() daripada java.lang.Class API
• kaedah newInstance() daripada java.lang.reflect.Constructor API

Menggunakan newInstance() daripada API Kelas

Untuk mencipta objek kelas pada masa jalan, kita mesti memanggil kaedah newInstance() daripada API Kelas, yang mengembalikan objek kelas itu. Kaedah newInstance() kelas java.lang.Class tidak mengambil sebarang parameter atau hujah dan boleh dipanggil pembina tanpa hujah untuk kelas tersebut. Mari lihat beberapa contoh kod untuk mencipta objek kelas Person menggunakan kaedah newInstance() kelas java.lang.Class :

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 (nama kelas yang layak sepenuhnya) memuatkan kelas bernama Person , kemudian newInstance() mencipta objek baharu jenis Person dan mengembalikan rujukan kepadanya. Sekarang, menggunakan rujukan Orang kepada p , kita boleh memanggil getters() dan setter() untuk melakukan tindakan tertentu. Sila ambil perhatian:

• Kedua-dua Class.forName() dan newIstance() membuang pengecualian yang mesti dikendalikan sama ada menggunakan cuba dan tangkap blok atau kata kunci lontaran .
• Kaedah newInstance() daripada API Kelas telah ditamatkan sejak Java 9.

Menggunakan newInstance() daripada Constructor API

Kaedah newInstance() kelas Pembina ( java.lang.reflect.Constructor ) adalah serupa dengan kaedah newInstance() kelas Kelas , kecuali ia menerima parameter untuk pembina berparameter. Mari kita tunjukkan pendekatan ini dengan mencipta objek kelas Person menggunakan kaedah newInstance() kelas java.lang.reflect.Constructor :

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();
        }

    }
}

Dalam kod di atas, mula-mula kita perlu memuatkan kelas menggunakan kaedah Class.forName() . Seterusnya, kami akan memanggil kaedah getConstructor() untuk memadankan jenis data parameter yang diluluskan. Akhir sekali, dalam kaedah newInstance() kita lulus parameter yang diperlukan ( null jika tiada hujah). Kaedah newInstance() akan mengembalikan objek baharu kelas PersonTwo dengan memanggil pembina yang sesuai.

Menggunakan kaedah klon().

Kaedah klon() adalah sebahagian daripada kelas Objek dan digunakan untuk membuat salinan objek sedia ada. Ia mencipta objek kelas tanpa memanggil mana-mana pembina kelas. Untuk mengklon kaedah, kelas yang sepadan mesti telah melaksanakan antara muka Boleh Diklon , yang merupakan antara muka penanda. Sekarang kita akan mencipta objek kelas Person dan kemudian mengklonkannya ke objek lain kelas 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();
        }

    }
}

Catatan. Objek klon akan merujuk objek asal yang sama melalui rujukan p2 . Walau bagaimanapun, objek klon akan mempunyai tugasan memori yang berasingan. Ini bermakna bahawa sebarang perubahan yang dibuat pada objek Orang yang dirujuk oleh p2 tidak akan mengubah objek Orang asal yang dirujuk oleh p1 . Ini kerana kaedah klon() mencipta salinan cetek objek.

Menggunakan Penyahserialisasian Objek

Penyahserialisasian objek ialah proses mengekstrak objek daripada satu siri aliran bait. Serialisasi melakukan sebaliknya. Tujuan utamanya adalah untuk mendapatkan semula objek yang disimpan dari pangkalan data/rangkaian kembali ke dalam ingatan. Jika kita ingin mensiri atau menyahsiri objek, kita perlu melaksanakan antara muka Serializable (antara muka token). Pertimbangkan contoh di bawah:

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();
        }
    }
}

Di sini kita mula-mula menyusun objek Orang dengan merujuk p1 ke dalam fail teks. Kaedah writeObject() akan menulis aliran bait objek ke fail teks. Kemudian, menggunakan penyahserialisasian objek, kami mengekstrak objek Person kembali ke p2 . Begitu juga, kaedah readObject() akan membaca objek daripada aliran input objek. Akhir sekali, kami akan mencetak data dari objek Orang ke konsol.

Kesimpulan

Dalam artikel ini, kami mempelajari tentang cara yang berbeza untuk mencipta objek dalam Java. Mula-mula, kami melihat untuk mencipta objek menggunakan kata kunci baharu , yang merupakan cara yang paling biasa. Kami kemudian mempelajari kaedah newInstance() daripada Class dan Constructor classes , yang merupakan satu lagi cara popular untuk mencipta objek. Kami kemudian menggunakan kaedah clone() , yang mencipta salinan cetek objek sedia ada dan bukannya mencipta objek baharu. Akhir sekali, kami menggunakan konsep pensirilan objek dan penyahseririan untuk mencipta objek dalam Java.

String ke Int dalam Java - cara menukar rentetan kepada integer

Sumber: FreeCodeCamp Hari ini anda akan belajar cara menukar rentetan kepada integer dalam Java menggunakan dua kaedah kelas Integer - parseInt() dan valueOf() . Ini akan membantu anda semasa melakukan operasi matematik menggunakan nilai pembolehubah rentetan.

Bagaimana untuk menukar rentetan kepada integer dalam Java menggunakan Integer.parseInt

Pilihan ini menganggap bahawa kaedah parseInt() mengambil rentetan untuk ditukar kepada integer sebagai parameter:

Integer.parseInt(string_varaible)

Sebelum melihat contoh penggunaannya, mari lihat perkara yang berlaku apabila anda menambah nilai rentetan dan integer tanpa sebarang penukaran:

class StrToInt {
    public static void main(String[] args) {
        String age = "10";
        
        System.out.println(age + 20);
        // 1020
    }
}

Dalam kod ini, kami telah mencipta umur berubah-ubah dengan nilai rentetan "10". Apabila kami menambah nombor 20 kepada nilai integer, kami tersilap menerima 1020 dan bukannya jawapan yang betul 30. Ini boleh dibetulkan menggunakan kaedah 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
    }
}

Di sini, untuk menukar pembolehubah umur kepada integer, kami menyerahkannya sebagai parameter kepada kaedah parseInt() - Integer.parseInt(age) - dan menyimpannya dalam pembolehubah dipanggil age_to_int . Sekarang apabila ditambah kepada integer lain kita mendapat penambahan yang betul: age_to_int + 20 .

Cara menukar rentetan kepada integer dalam Java menggunakan Integer.valueOf

Kaedah valueOf() berfungsi sama seperti kaedah parseInt() . Ia mengambil sebagai parameter rentetan yang perlu ditukar kepada integer. Berikut ialah contoh:

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
    }
}

Dalam kod di atas anda boleh melihat perkara yang sama seperti dalam bahagian sebelumnya:

• Kami menghantar rentetan sebagai parameter kepada valueOf() : Integer.valueOf(age) . Ia disimpan dalam pembolehubah yang dipanggil age_to_int .
• Kami kemudian menambah 10 pada pembolehubah yang dibuat: age_to_int + 20 . Hasilnya ialah 30 berbanding 1020.

Kesimpulan

Dalam artikel ini, kami membincangkan menukar rentetan kepada integer dalam Java. Untuk menukar rentetan kepada integer, dua kaedah kelas Integer digunakan - parseInt() dan valueOf() . Selamat mengekod!