Pausa caffè #174. Diversi modi per creare un oggetto in Java. Da stringa a Int in Java - Come convertire una stringa in numero intero

Diversi modi per creare un oggetto in Java

Fonte: Medium In questo tutorial impareremo diversi modi per creare un oggetto in Java. Un oggetto Java è un'istanza di una classe Java. Ogni oggetto ha uno stato, un comportamento e un identificatore. I campi (variabili) memorizzano lo stato di un oggetto, mentre i metodi (funzioni) mostrano l'azione di un oggetto. Le classi fungono da "progetti" da cui vengono create le istanze degli oggetti in fase di runtime.

Creare un oggetto in Java

La creazione di oggetti è il processo di allocazione della memoria per archiviare i dati nei campi della classe (chiamati anche variabili). Questo processo viene spesso chiamato creazione di un'istanza di una classe. Esistono quattro modi diversi per creare oggetti in Java:

1. utilizzando la nuova parola chiave
2. metodo nuovaistanza()
3. metodo clone()
4. deserializzare un oggetto

Ora esaminiamo in dettaglio ciascuno dei metodi menzionati.

Parola chiave nuova

Questo è il modo più comune per creare un oggetto in Java. La nuova parola chiave crea un'istanza di una classe allocando memoria per una nuova istanza del tipo specificato. Dopo il nuovo arriva il costruttore, un metodo speciale responsabile della creazione di un oggetto e dell'inizializzazione dei campi dell'oggetto creato. Un oggetto viene creato con l' operatore new e inizializzato con un costruttore. Ecco un esempio di creazione di un oggetto Java con l' operatore new :

Date today = new Date();

Questa espressione genera un nuovo oggetto Date ( Date è una classe all'interno del pacchetto java.util ). Questa singola clausola nel codice esegue tre operazioni: dichiarazione, istanziazione e inizializzazione. Date today è una dichiarazione di variabile che informa il compilatore che today farà riferimento a un oggetto di tipo Date . L'operatore new crea un'istanza della classe Date (creando un nuovo oggetto Date in memoria) e Date() inizializza l'oggetto. Considera l'esempio seguente:

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

Da questo codice creiamo un oggetto Person utilizzando la nuova parola chiave :

• L' oggetto p1 chiama un costruttore non parametrizzato con il valore del nome della variabile impostato su "Michael Cole" e l'UID impostato su 101.
• L' oggetto p2 chiama il costruttore parametrizzato, dove passa al costruttore il valore "John Bodgan" e 102. A questi valori vengono quindi assegnati un nome di variabile e un UID.

Utilizzando il metodo newInstance()

Il metodo newInstance() in Java viene utilizzato per creare dinamicamente un'istanza di un oggetto di una determinata classe. Esistono due usi standard del metodo newInstance() :

• metodo newInstance() dall'API java.lang.Class
• metodo newInstance() dall'API java.lang.reflect.Constructor

Utilizzando newInstance() dall'API della classe

Per creare un oggetto di una classe in fase di runtime, dobbiamo chiamare il metodo newInstance() dall'API Class, che restituisce un oggetto di quella classe. Il metodo newInstance() della classe java.lang.Class non accetta parametri o argomenti e può essere definito un costruttore senza argomenti per quella classe. Diamo un'occhiata ad alcuni esempi di codice per creare un oggetto della classe Person utilizzando il metodo newInstance() della classe 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 (il nome completo della classe) carica una classe denominata Person , quindi newInstance() crea un nuovo oggetto di tipo Person e restituisce un riferimento ad esso. Ora, utilizzando il riferimento Person a p , possiamo chiamare i suoi getters() e setter() per eseguire determinate azioni. Notare che:

• Sia Class.forName() che newIstance() lanciano eccezioni che devono essere gestite utilizzando i blocchi try and catch o la parola chiave Throws .
• Il metodo newInstance() dell'API Class è stato deprecato a partire da Java 9.

Utilizzando newInstance() dall'API del costruttore

Il metodo newInstance() della classe Constructor ( java.lang.reflect.Constructor ) è simile al metodo newInstance() della classe Class , tranne per il fatto che accetta parametri per costruttori con parametri. Dimostriamo questo approccio creando un oggetto della classe Person utilizzando il metodo newInstance() della classe 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();
        }

    }
}

Nel codice sopra, dobbiamo prima caricare la classe utilizzando il metodo Class.forName() . Successivamente, chiameremo il metodo getConstructor() per far corrispondere i tipi di dati dei parametri passati. Infine, nel metodo newInstance() passiamo il parametro richiesto ( null se non ci sono argomenti). Il metodo newInstance() restituirà un nuovo oggetto della classe PersonTwo chiamando il costruttore appropriato.

Utilizzando il metodo clone()

Il metodo clone() fa parte della classe Object e viene utilizzato per creare una copia di un oggetto esistente. Crea un oggetto della classe senza chiamare alcun costruttore di classe. Per clonare un metodo, la classe corrispondente deve aver implementato l' interfaccia Cloneable , che è un'interfaccia marcatore. Ora creeremo un oggetto della classe Person e poi lo cloneremo in un altro oggetto della classe 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();
        }

    }
}

Nota. L'oggetto clonato farà riferimento allo stesso oggetto originale tramite il riferimento p2 . Tuttavia, l'oggetto clonato avrà un'assegnazione di memoria separata. Ciò significa che qualsiasi modifica apportata all'oggetto Person a cui fa riferimento p2 non modificherà l' oggetto Person originale a cui fa riferimento p1 . Questo perché il metodo clone() crea una copia superficiale degli oggetti.

Utilizzo della deserializzazione degli oggetti

La deserializzazione degli oggetti è il processo di estrazione di un oggetto da una serie di flussi di byte. La serializzazione fa il contrario. Il suo scopo principale è recuperare un oggetto memorizzato dal database/rete nuovamente in memoria. Se vogliamo serializzare o deserializzare un oggetto, dobbiamo implementare l' interfaccia Serializable (interfaccia token). Considera l'esempio seguente:

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

Qui per prima cosa serializziamo l' oggetto Person facendo riferimento a p1 in un file di testo. Il metodo writeObject() scriverà il flusso di byte dell'oggetto in un file di testo. Quindi, utilizzando la deserializzazione dell'oggetto, estraiamo nuovamente l' oggetto Person in p2 . Allo stesso modo, il metodo readObject() leggerà un oggetto dal flusso di input dell'oggetto. Infine, stamperemo i dati dall'oggetto Person alla console.

Conclusione

In questo articolo abbiamo appreso i diversi modi per creare un oggetto in Java. Innanzitutto, abbiamo esaminato la creazione di oggetti utilizzando la parola chiave new , che è il modo più comune. Abbiamo quindi imparato il metodo newInstance() dalle classi Class e Constructor , che è un altro modo popolare per creare oggetti. Abbiamo quindi utilizzato il metodo clone() , che crea una copia superficiale dell'oggetto esistente invece di creare un nuovo oggetto. Infine, abbiamo utilizzato il concetto di serializzazione e deserializzazione degli oggetti per creare oggetti in Java.

String to Int in Java: come convertire una stringa in un numero intero

Fonte: FreeCodeCamp Oggi imparerai come convertire una stringa in un numero intero in Java utilizzando due metodi della classe Integer : parseInt() e valueOf() . Questo ti aiuterà quando esegui operazioni matematiche utilizzando il valore di una variabile stringa.

Come convertire una stringa in un numero intero in Java utilizzando Integer.parseInt

Questa opzione presuppone che il metodo parseInt() accetti una stringa da convertire in un numero intero come parametro:

Integer.parseInt(string_varaible)

Prima di vedere un esempio del suo utilizzo, vediamo cosa succede quando aggiungi un valore stringa e un numero intero senza alcuna conversione:

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

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

In questo codice abbiamo creato una variabile età con il valore stringa “10”. Quando abbiamo aggiunto il numero 20 a un valore intero, abbiamo erroneamente ricevuto 1020 invece della risposta corretta di 30. Questo può essere corretto utilizzando il metodo 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
    }
}

Qui, per convertire la variabile age in un numero intero, l'abbiamo passata come parametro al metodo parseInt() - Integer.parseInt(age) - e l'abbiamo memorizzata in una variabile chiamata age_to_int . Ora quando aggiunto a un altro numero intero otteniamo l'addizione corretta: age_to_int + 20 .

Come convertire una stringa in un numero intero in Java utilizzando Integer.valueOf

Il metodo valueOf() funziona allo stesso modo del metodo parseInt() . Prende come parametro una stringa che deve essere convertita in un numero intero. Ecco un esempio:

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

Nel codice sopra puoi vedere la stessa cosa della sezione precedente:

• Abbiamo passato una stringa come parametro a valueOf() : Integer.valueOf(age) . Era memorizzato in una variabile chiamata age_to_int .
• Abbiamo quindi aggiunto 10 alla variabile creata: age_to_int + 20 . Il risultato è stato 30 invece di 1020.

Conclusione

In questo articolo abbiamo discusso della conversione di stringhe in numeri interi in Java. Per convertire una stringa in un numero intero, sono stati utilizzati due metodi della classe Integer : parseInt() e valueOf() . Buona programmazione!