Diferentes formas de crear objetos en Java

Hay varias formas en que podemos crear objetos de una clase en Java, ya que todos sabemos que una clase proporciona el modelo para los objetos, crea un objeto a partir de una clase. Este concepto está subestimado y, a veces, demuestra ser beneficioso, ya que muchos programadores lo pasan por alto y, a veces, incluso lo preguntan desde la perspectiva de la entrevista.

Métodos: 

Hay muchas formas diferentes de crear objetos en Java. Vamos a enumerarlos más adelante discutiéndolos más tarde individualmente con la ayuda de programas para ilustrar el funcionamiento interno mediante el cual podemos crear objetos en Java.

1. Usando una nueva palabra clave
2. Usando una nueva instancia
3. Usando el método clon()
4. Usando la deserialización
5. Usando el método newInstance() de la clase Constructor

Discutámoslos uno por uno e implementemos lo mismo agregando un programa java limpio para el mismo.

Método 1: usar una nueva palabra clave

Usar la nueva palabra clave en java es la forma más básica de crear un objeto. Esta es la forma más común de crear un objeto en Java. Casi el 99% de los objetos se crean de esta manera. Al usar este método, podemos llamar a cualquier constructor que queramos llamar (sin argumentos ni constructores parametrizados).

Ejemplo

// Java program to Illustrate Creation of Object
// Using new keyword
 
// Main class
class GFG {
 
    // Declaring and initializing string
    // Custom input string
    String name = "GeeksForGeeks";
 
    // Main driver method
    public static void main(String[] args)
    {
        // As usual and most generic used we will
        // be creating object of class inside main()
        // using new keyword
        GFG obj = new GFG();
 
        // Print and display the object
        System.out.println(obj.name);
    }
}

GeeksForGeeks

Método 2: usar una nueva instancia

Si conocemos el nombre de la clase y si tiene un constructor público predeterminado, podemos crear un objeto Class.forName . Podemos usarlo para crear el Objeto de una Clase. Class.forName en realidad carga la clase en Java pero no crea ningún objeto. Para crear un objeto de la clase, debe usar el nuevo método de instancia de la clase.

Ejemplo

// Java program to Illustrate Creation of Object
// Using new Instance
 
// Main class
class GFG {
 
    // Declaring and initializing string
    String name = "GeeksForGeeks";
 
    // Main driver method
    public static void main(String[] args)
    {
        // Try block to check for exceptions
        try {
 
            Class cls = Class.forName("GFG");
 
            // Creating object of main class
            // using instance method
            GFG obj = (GFG)cls.newInstance();
 
            // Print and display
            System.out.println(obj.name);
        }
 
        // Catch block to handle the exceptions
 
        // Catch block 1
        // Handling ClassNotFound Exception
        catch (ClassNotFoundException e) {
 
            // Display the exception along with line number
            // using printStacktrace() method
            e.printStackTrace();
        }
 
        // Catch block 2
        // Handling InstantiationException
        catch (InstantiationException e) {
 
            e.printStackTrace();
        }
 
        // Catch block 2
        // Handling IllegalAccessException
        catch (IllegalAccessException e) {
 
            e.printStackTrace();
        }
    }
}

Producción: 

GeeksForGeeks

Método 3:   Usar el método clon()

Cada vez que se llama a clone() en cualquier objeto, la JVM en realidad crea un nuevo objeto y copia todo el contenido del objeto anterior en él. La creación de un objeto mediante el método de clonación no invoca a ningún constructor. Para usar el método clone() en un objeto, necesitamos implementar Cloneable y definir el método clone() en él.

Ejemplo

// Java program to Illustrate Creation of Object
// Using clone() method
 
// Main class
// Implementing Cloneable interface
class GFG implements Cloneable {
 
    // Method 1
    @Override
    protected Object clone()
        throws CloneNotSupportedException
    {
        // Super() keyword refers to parent class
        return super.clone();
    }
 
    // Declaring and initializing string
    String name = "GeeksForGeeks";
 
    // Method 2
    // main driver method
    public static void main(String[] args)
    {
        GFG obj1 = new GFG();
 
        // Try block to check for exceptions
        try {
 
            // Using the clone() method
            GFG obj2 = (GFG)obj1.clone();
 
            // Print and display the main class object
            // as created above
            System.out.println(obj2.name);
        }
 
        // Catch block to handle the exceptions
        catch (CloneNotSupportedException e) {
 
            // Display the exception
            // using printStackTrace() method
            e.printStackTrace();
        }
    }
}

GeeksForGeeks

Nota:  

• Aquí estamos creando el clon de un Objeto existente y no cualquier Objeto nuevo.
• La clase necesita implementar la interfaz clonable; de ​​lo contrario, arrojará CloneNotSupportedException .

Método 4: Usar la deserialización

Cada vez que serializamos y luego deserializamos un objeto, JVM crea un objeto separado. En la deserialización , JVM no usa ningún constructor para crear el objeto. Para deserializar un objeto necesitamos implementar la interfaz Serializable en la clase.

Ejemplo 1

// Java Program Illustrate Serializing an Object
 
// Importing input output classes
import java.io.*;
 
// Main class
// Implementing the Serializable interface
class GFG implements Serializable {
 
    // Member variables
    private String name;
    GFG(String name)
    {
        // This keyword refers to current object itself
        this.name = name;
    }
 
    // Main driver method
    public static void main(String[] args)
    {
        // Try block to check for exceptions
        try {
            // Creating object of class in main() method
            GFG d = new GFG("GeeksForGeeks");
 
            FileOutputStream f
                = new FileOutputStream("file.txt");
            ObjectOutputStream oos
                = new ObjectOutputStream(f);
            oos.writeObject(d);
            oos.close();
 
            // Freeing up memory resources
            f.close();
        }
 
        // Catch block to handle the exceptiona
        catch (Exception e) {
            // Display the exception along with line number
            // using printStacktrace() method
            e.printStackTrace();
        }
    }
}

Producción: 

GeeksForGeeks

El objeto de la clase DeserializationExample se serializa mediante el método writeObject() y se escribe en el archivo file.txt.

Ejemplo 2

// Java Program Illustrate Creation of Object
// Using Deserialization
 
// Importing input output classes
import java.io.*;
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Try block to check for exceptions
        try {
 
            GFG d;
 
            // Creating FileInputStream class object
            FileInputStream f
                = new FileInputStream("file.txt");
 
            // Creating ObjectInputStream class object
            ObjectInputStream oos
                = new ObjectInputStream(f);
            d = (DeserializationExample)oos.readObject();
        }
 
        // Catch block to handle the exceptions
        catch (Exception e) {
 
            // Display the exception on console
            // using printStacjtrace() method
            e.printStackTrace();
        }
 
        System.out.println(d.name);
    }
}

Producción: 

GeeksForGeeks

Método 5: Usar el método newInstance() de la clase constructora

Esto es similar al método newInstance() de una clase. Hay un método newInstance() en la clase java.lang.reflect.Constructor que podemos usar para crear objetos. También puede llamar al constructor parametrizado y al constructor privado usando este método newInstance(). Ambos métodos newInstance() se conocen como formas reflexivas de crear objetos. De hecho, el método newInstance() de Class usa internamente el método newInstance() de la clase Constructor. 

Ejemplo

// Java program to illustrate creation of Object
// using newInstance() method of Constructor class
 
// Importing required classes from java.lang package
import java.lang.reflect.*;
 
// Main class
class GFG {
 
    // Member variables of this class
    private String name;
 
    // Constructor of this class
    GFG() {}
 
    // Method 1
    // To set name ofthe string
    public void setName(String name)
    {
        // This method refers to current object itself
        this.name = name;
    }
 
    // Main driver method
    public static void main(String[] args)
    {
        // Try block to check for exceptions
        try {
            Constructor<GFG> constructor
                = GFG.class.getDeclaredConstructor();
 
            GFG r = constructor.newInstance();
 
            // Custom passing
            r.setName("GeeksForGeeks");
            System.out.println(r.name);
        }
 
        // Catch block to handle the exceptions
        catch (Exception e) {
 
            // Display the exception on console
            // using printStackTrace() method
            e.printStackTrace();
        }
    }
}

Producción: 

GeeksForGeeks

Este artículo es una contribución de Saket Kumar . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.