Pause café #174. Différentes façons de créer un objet en Java.String en Int en Java - Comment convertir une chaîne en entier

Différentes manières de créer un objet en Java

Source : Medium Dans ce tutoriel, nous allons apprendre différentes manières de créer un objet en Java. Un objet Java est une instance d'une classe Java. Chaque objet a un état, un comportement et un identifiant. Les champs (variables) stockent l'état d'un objet, tandis que les méthodes (fonctions) montrent l'action d'un objet. Les classes servent de « plans » à partir desquels les instances d'objet sont créées au moment de l'exécution.

Créer un objet en Java

La création d'objets est le processus d'allocation de mémoire pour stocker des données dans des champs de classe (également appelés variables). Ce processus est souvent appelé création d’une instance d’une classe. Il existe quatre manières différentes de créer des objets en Java :

1. en utilisant le nouveau mot-clé
2. méthode nouvelleInstance()
3. méthode clone()
4. désérialiser un objet

Examinons maintenant en détail chacune des méthodes mentionnées.

Mot clé nouveau

C'est la manière la plus courante de créer un objet en Java. Le mot-clé new crée une instance d'une classe en allouant de la mémoire pour une nouvelle instance du type spécifié. Après new vient le constructeur - une méthode spéciale chargée de créer un objet et d'initialiser les champs de l'objet créé. Un objet est créé avec l' opérateur new et initialisé avec un constructeur. Voici un exemple de création d'un objet Java avec l' opérateur new :

Date today = new Date();

Cette expression génère un nouvel objet Date ( Date est une classe dans le package java.util ). Cette seule clause du code effectue trois opérations : déclaration, instanciation et initialisation. Date Today est une déclaration de variable qui informe le compilateur qu'aujourd'hui fera référence à un objet de type Date . L'opérateur new instancie la classe Date (créant un nouvel objet Date en mémoire) et Date() initialise l'objet. Prenons l'exemple ci-dessous :

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

A partir de ce code, nous créons un objet Person en utilisant le mot-clé new :

• L' objet p1 appelle un constructeur non paramétré avec la valeur du nom de variable définie sur « Michael Cole » et l'UID défini sur 101.
• L' objet p2 appelle le constructeur paramétré, où il transmet au constructeur la valeur « John Bodgan » et 102. Ces valeurs se voient ensuite attribuer un nom de variable et un UID.

Utilisation de la méthode newInstance()

La méthode newInstance() en Java est utilisée pour créer dynamiquement une instance d'un objet d'une classe donnée. Il existe deux utilisations standards de la méthode newInstance() :

• Méthode newInstance() de l'API java.lang.Class
• Méthode newInstance() de l'API java.lang.reflect.Constructor

Utilisation de newInstance() à partir de l'API de classe

Pour créer un objet d'une classe au moment de l'exécution, nous devons appeler la méthode newInstance() depuis l'API Class, qui renvoie un objet de cette classe. La méthode newInstance() de la classe java.lang.Class ne prend aucun paramètre ni argument et peut être appelée constructeur sans argument pour cette classe. Regardons quelques exemples de code pour créer un objet de la classe Person en utilisant la méthode newInstance() de la 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 (le nom complet de la classe) charge une classe nommée Person , puis newInstance() crée un nouvel objet de type Person et renvoie une référence à celui-ci. Maintenant, en utilisant la référence Person à p , nous pouvons appeler ses getters() et setter() pour effectuer certaines actions. Veuillez noter:

• Class.forName () et newIstance() génèrent des exceptions qui doivent être gérées soit à l'aide de blocs try and catch , soit du mot-clé throws .
• La méthode newInstance() de l'API Class est obsolète depuis Java 9.

Utilisation de newInstance() à partir de l'API Constructor

La méthode newInstance() de la classe Constructor ( java.lang.reflect.Constructor ) est similaire à la méthode newInstance() de la classe Class , sauf qu'elle accepte les paramètres des constructeurs paramétrés. Montrons cette approche en créant un objet de la classe Person en utilisant la méthode newInstance() de la 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();
        }

    }
}

Dans le code ci-dessus, nous devons d'abord charger la classe à l'aide de la méthode Class.forName() . Ensuite, nous appellerons la méthode getConstructor() pour faire correspondre les types de données des paramètres passés. Enfin, dans la méthode newInstance() nous passons le paramètre requis ( null s'il n'y a pas d'argument). La méthode newInstance() renverra un nouvel objet de la classe PersonTwo en appelant le constructeur approprié.

Utilisation de la méthode clone()

La méthode clone() fait partie de la classe Object et est utilisée pour créer une copie d'un objet existant. Il crée un objet de la classe sans appeler aucun constructeur de classe. Pour cloner une méthode, la classe correspondante doit avoir implémenté l' interface Cloneable , qui est une interface de marqueur. Nous allons maintenant créer un objet de la classe Person puis le cloner dans un autre objet de la 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();
        }

    }
}

Note. L'objet cloné référencera le même objet original via la référence p2 . Cependant, l'objet cloné aura une affectation de mémoire distincte. Cela signifie que toute modification apportée à l' objet Person référencé par p2 ne modifiera pas l' objet Person d'origine référencé par p1 . En effet, la méthode clone() crée une copie superficielle des objets.

Utilisation de la désérialisation d'objets

La désérialisation d'objets est le processus d'extraction d'un objet à partir d'une série de flux d'octets. La sérialisation fait le contraire. Son objectif principal est de récupérer un objet stocké de la base de données/du réseau vers la mémoire. Si nous voulons sérialiser ou désérialiser un objet, nous devons implémenter l' interface Serialisable (interface de jeton). Prenons l'exemple ci-dessous :

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

Ici, nous sérialisons d’abord l’ objet Person par référence p1 dans un fichier texte. La méthode writeObject() écrira le flux d'octets de l'objet dans un fichier texte. Ensuite, en utilisant la désérialisation d'objet, nous extrayons l' objet Person dans p2 . De même, la méthode readObject() lira un objet à partir du flux d'entrée de l'objet. Enfin, nous imprimerons les données de l' objet Person sur la console.

Conclusion

Dans cet article, nous avons découvert les différentes manières de créer un objet en Java. Tout d’abord, nous avons examiné la création d’objets à l’aide du mot-clé new , qui est la méthode la plus courante. Nous avons ensuite appris la méthode newInstance() des classes Class et Constructor , qui est un autre moyen populaire de créer des objets. Nous avons ensuite utilisé la méthode clone() , qui crée une copie superficielle de l'objet existant au lieu de créer un nouvel objet. Enfin, nous avons utilisé le concept de sérialisation et de désérialisation d'objets pour créer des objets en Java.

String to Int en Java - comment convertir une chaîne en entier

Source : FreeCodeCamp Aujourd'hui, vous apprendrez à convertir une chaîne en entier en Java en utilisant deux méthodes de la classe Integer - parseInt() et valueOf() . Cela vous aidera lors de l'exécution d'opérations mathématiques en utilisant la valeur d'une variable chaîne.

Comment convertir une chaîne en entier en Java en utilisant Integer.parseInt

Cette option suppose que la méthode parseInt() prend une chaîne à convertir en entier comme paramètre :

Integer.parseInt(string_varaible)

Avant de regarder un exemple de son utilisation, voyons ce qui se passe lorsque vous ajoutez une valeur chaîne et un entier sans aucune conversion :

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

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

Dans ce code, nous avons créé une variable age avec la valeur de chaîne « 10 ». Lorsque nous avons ajouté le nombre 20 à une valeur entière, nous avons reçu par erreur 1020 au lieu de la bonne réponse de 30. Cela peut être corrigé en utilisant la méthode 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
    }
}

Ici, pour convertir la variable age en entier, nous l'avons passée en paramètre à la méthode parseInt() - Integer.parseInt(age) - et l'avons stockée dans une variable appelée age_to_int . Désormais, lorsqu'il est ajouté à un autre entier, nous obtenons l'addition correcte : age_to_int + 20 .

Comment convertir une chaîne en entier en Java en utilisant Integer.valueOf

La méthode valueOf() fonctionne de la même manière que la méthode parseInt() . Il prend comme paramètre une chaîne qui doit être convertie en entier. Voici un exemple :

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

Dans le code ci-dessus, vous pouvez voir la même chose que dans la section précédente :

• Nous avons passé une chaîne en paramètre à valueOf() : Integer.valueOf(age) . Il était stocké dans une variable appelée age_to_int .
• Nous avons ensuite ajouté 10 à la variable créée : age_to_int + 20 . Le résultat était de 30 au lieu de 1020.

Conclusion

Dans cet article, nous avons discuté de la conversion de chaînes en entiers en Java. Pour convertir une chaîne en entier, deux méthodes de la classe Integer ont été utilisées - parseInt() et valueOf() . Bon codage !