Pausa para el café #174. Diferentes formas de crear un objeto en Java.String a Int en Java: cómo convertir una cadena en un entero

Diferentes formas de crear un objeto en Java

Fuente: Medio En este tutorial, aprenderemos diferentes formas de crear un objeto en Java. Un objeto Java es una instancia de una clase Java. Cada objeto tiene un estado, un comportamiento y un identificador. Los campos (variables) almacenan el estado de un objeto, mientras que los métodos (funciones) muestran la acción de un objeto. Las clases sirven como "modelos" a partir de los cuales se crean instancias de objetos en tiempo de ejecución.

Creando un objeto en Java

La creación de objetos es el proceso de asignar memoria para almacenar datos en campos de clase (también llamados variables). Este proceso a menudo se denomina creación de una instancia de una clase. Hay cuatro formas diferentes de crear objetos en Java:

1. usando la nueva palabra clave
2. método nuevaInstancia()
3. método clonar()
4. deserializar un objeto

Ahora veamos cada uno de los métodos mencionados en detalle.

palabra clave nueva

Esta es la forma más común de crear un objeto en Java. La nueva palabra clave crea una instancia de una clase asignando memoria para una nueva instancia del tipo especificado. Después de nuevo viene el constructor, un método especial responsable de crear un objeto e inicializar los campos del objeto creado. Se crea un objeto con el nuevo operador y se inicializa con un constructor. A continuación se muestra un ejemplo de creación de un objeto Java con el nuevo operador :

Date today = new Date();

Esta expresión genera un nuevo objeto Fecha ( La fecha es una clase dentro del paquete java.util ). Esta única cláusula del código realiza tres operaciones: declaración, creación de instancias e inicialización. La fecha de hoy es una declaración de variable que informa al compilador que hoy se referirá a un objeto de tipo Fecha . El nuevo operador crea una instancia de la clase Date (creando un nuevo objeto Date en la memoria) y Date() inicializa el objeto. Considere el siguiente ejemplo:

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 este código, creamos un objeto Persona usando la nueva palabra clave :

• El objeto p1 llama a un constructor no parametrizado con el valor del nombre de la variable establecido en "Michael Cole" y el UID establecido en 101.
• El objeto p2 llama al constructor parametrizado, donde pasa al constructor el valor "John Bodgan" y 102. A estos valores luego se les asigna un nombre de variable y un UID.

Usando el método newInstance()

El método newInstance() en Java se utiliza para crear dinámicamente una instancia de un objeto de una clase determinada. Hay dos usos estándar del método newInstance() :

• Método newInstance() de la API java.lang.Class
• Método newInstance() de la API java.lang.reflect.Constructor

Usando newInstance() desde la API de clase

Para crear un objeto de una clase en tiempo de ejecución, debemos llamar al método newInstance() desde Class API, que devuelve un objeto de esa clase. El método newInstance() de la clase java.lang.Class no toma ningún parámetro ni argumento y puede denominarse constructor sin argumentos para esa clase. Veamos un código de ejemplo para crear un objeto de la clase Persona usando el método newInstance() de la clase 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 (el nombre completo de la clase) carga una clase llamada Person , luego newInstance() crea un nuevo objeto de tipo Person y le devuelve una referencia. Ahora, usando la referencia Person a p , podemos llamar a sus getters() y setter() para realizar ciertas acciones. Tenga en cuenta:

• Tanto Class.forName() como newIstance() arrojan excepciones que deben manejarse mediante bloques try and catch o la palabra clave throws .
• El método newInstance() de Class API ha quedado obsoleto desde Java 9.

Usando newInstance() desde la API Constructor

El método newInstance() de la clase Constructor ( java.lang.reflect.Constructor ) es similar al método newInstance() de la clase Class , excepto que acepta parámetros para constructores parametrizados. Demostremos este enfoque creando un objeto de la clase Persona usando el método newInstance() de la clase 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();
        }

    }
}

En el código anterior, primero debemos cargar la clase usando el método Class.forName() . A continuación, llamaremos al método getConstructor() para hacer coincidir los tipos de datos de los parámetros pasados. Finalmente, en el método newInstance() pasamos el parámetro requerido ( nulo si no hay argumento). El método newInstance() devolverá un nuevo objeto de la clase PersonTwo llamando al constructor apropiado.

Usando el método clon()

El método clone() es parte de la clase Object y se utiliza para crear una copia de un objeto existente. Crea un objeto de la clase sin llamar a ningún constructor de clase. Para clonar un método, la clase correspondiente debe haber implementado la interfaz Cloneable , que es una interfaz de marcador. Ahora crearemos un objeto de la clase Persona y luego lo clonaremos en otro objeto de la clase Persona :

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. El objeto clonado hará referencia al mismo objeto original a través de la referencia p2 . Sin embargo, el objeto clonado tendrá una asignación de memoria separada. Esto significa que cualquier cambio realizado en el objeto Persona al que hace referencia p2 no cambiará el objeto Persona original al que hace referencia p1 . Esto se debe a que el método clone() crea una copia superficial de los objetos.

Usando la deserialización de objetos

La deserialización de objetos es el proceso de extraer un objeto de una serie de flujos de bytes. La serialización hace lo contrario. Su objetivo principal es recuperar un objeto almacenado de la base de datos/red a la memoria. Si queremos serializar o deserializar un objeto, necesitamos implementar la interfaz serializable (interfaz token). Considere el siguiente ejemplo:

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

Aquí primero serializamos el objeto Persona por referencia p1 en un archivo de texto. El método writeObject() escribirá el flujo de bytes del objeto en un archivo de texto. Luego, usando la deserialización de objetos, extraemos el objeto Persona nuevamente en p2 . De manera similar, el método readObject() leerá un objeto del flujo de entrada del objeto. Finalmente, imprimiremos los datos del objeto Persona a la consola.

Conclusión

En este artículo, aprendimos sobre las diferentes formas de crear un objeto en Java. Primero, analizamos la creación de objetos usando la nueva palabra clave , que es la forma más común. Luego aprendimos el método newInstance() de las clases Class y Constructor , que es otra forma popular de crear objetos. Luego usamos el método clone() , que crea una copia superficial del objeto existente en lugar de crear un objeto nuevo. Por último, utilizamos el concepto de serialización y deserialización de objetos para crear objetos en Java.

String to Int en Java: cómo convertir una cadena en un número entero

Fuente: FreeCodeCamp Hoy aprenderá cómo convertir una cadena en un número entero en Java usando dos métodos de la clase Integer : parseInt() y valueOf() . Esto le ayudará a la hora de realizar operaciones matemáticas utilizando el valor de una variable de cadena.

Cómo convertir una cadena a un número entero en Java usando Integer.parseInt

Esta opción supone que el método parseInt() toma una cadena para convertirla a un número entero como parámetro:

Integer.parseInt(string_varaible)

Antes de ver un ejemplo de su uso, veamos qué sucede cuando agregas un valor de cadena y un número entero sin ninguna conversión:

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

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

En este código, hemos creado una edad variable con el valor de cadena "10". Cuando sumamos el número 20 a un valor entero, recibimos erróneamente 1020 en lugar de la respuesta correcta de 30. Esto se puede corregir usando el método 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
    }
}

Aquí, para convertir la variable edad en un número entero, la pasamos como parámetro al método parseInt() ( Integer.parseInt(age) ) y la almacenamos en una variable llamada age_to_int . Ahora, cuando lo sumamos a otro número entero, obtenemos la suma correcta: age_to_int + 20 .

Cómo convertir una cadena a un número entero en Java usando Integer.valueOf

El método valueOf() funciona igual que el método parseInt() . Toma como parámetro una cadena que debe convertirse a un número entero. He aquí un ejemplo:

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

En el código anterior puedes ver lo mismo que en la sección anterior:

• Pasamos una cadena como parámetro a valueOf() : Integer.valueOf(age) . Se almacenó en una variable llamada age_to_int .
• Luego agregamos 10 a la variable creada: age_to_int + 20 . El resultado fue 30 en lugar de 1020.

Conclusión

En este artículo, analizamos la conversión de cadenas a números enteros en Java. Para convertir una cadena en un número entero, se utilizaron dos métodos de la clase Integer : parseInt() y valueOf() . ¡Feliz codificación!