¿Cuáles son las diferentes formas de crear un objeto en Java?

Tuve una conversación con un compañero de trabajo el otro día sobre esto.

Lo obvio es usar un constructor, pero ¿cuáles son las otras formas allí?

Hay cuatro formas diferentes de crear objetos en Java:

Una . Uso de la newpalabra clave
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.

 MyObject object = new MyObject();

B . Uso Class.forName()
Si conocemos el nombre de la clase y si tiene un constructor público predeterminado, podemos crear un objeto de esta manera.

MyObject object = (MyObject) Class.forName("subin.rnd.MyObject").newInstance();

C . Uso clone()
El clon () se puede usar para crear una copia de un objeto existente.

MyObject anotherObject = new MyObject();
MyObject object = (MyObject) anotherObject.clone();

D . Usar la object deserialization
deserialización de objetos no es más que crear un objeto a partir de su forma serializada.

ObjectInputStream inStream = new ObjectInputStream(anInputStream );
MyObject object = (MyObject) inStream.readObject();

Puedes leerlos desde aquí .

Hay varias formas:

• A través de Class.newInstance.
• A través de Constructor.newInstance.
• A través de la deserialización (usa el constructor sin argumentos de la clase base no derivable más serializable).
• Through Object.clone( no llama a un constructor ).
• A través de JNI (debería llamar a un constructor).
• A través de cualquier otro método que llame newpor usted.
• Supongo que podría describir la carga de clases como la creación de nuevos objetos (como Strings internos ).
• Una matriz literal como parte de la inicialización en una declaración (sin constructor para matrices).
• La matriz en una ...llamada al método "varargs" ( ) (sin constructor para matrices).
• Concatenación de cadenas constante de tiempo sin compilación (produce al menos cuatro objetos, en una implementación típica).
• Causar una excepción para ser creada y lanzada por el tiempo de ejecución. Por ejemplo throw null;o "".toCharArray()[0].
• Ah, y el boxeo de primitivas (a menos que estén en caché), por supuesto.
• JDK8 debería tener lambdas (clases internas anónimas esencialmente concisas), que se convierten implícitamente en objetos.
• Para completar (y Paŭlo Ebermann), también hay alguna sintaxis con la newpalabra clave.

Dentro del lenguaje Java, la única forma de crear un objeto es llamando a su constructor, ya sea explícita o implícitamente. Usando los resultados de la reflexión en una llamada al método del constructor, la deserialización usa la reflexión para llamar al constructor, los métodos de fábrica envuelven la llamada al constructor para abstraer la construcción real y la clonación es, de manera similar, una llamada del constructor envuelto.

Sí, puedes crear objetos usando la reflexión. Por ejemplo, String.class.newInstance()le dará un nuevo objeto String vacío.

Hay cinco formas diferentes de crear un objeto en Java,

1. Usando la newpalabra clave → constructor llamarse

Employee emp1 = new Employee();

2. Usando el newInstance()método deClass → constructor llamarse

Employee emp2 = (Employee) Class.forName("org.programming.mitra.exercises.Employee")
                                .newInstance();

También se puede escribir como

Employee emp2 = Employee.class.newInstance();

3. Usando el newInstance()método deConstructor → constructor llamarse

Constructor<Employee> constructor = Employee.class.getConstructor();
Employee emp3 = constructor.newInstance();

4. Usando el clone()método → sin llamada de constructor

Employee emp4 = (Employee) emp3.clone();

5. Uso de deserialización → sin llamada de constructor

ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
Employee emp5 = (Employee) in.readObject();

Los primeros tres métodos de newpalabras clave y ambos newInstance()incluyen una llamada al constructor, pero luego dos métodos de clonación y deserialización crean objetos sin llamar al constructor.

Todos los métodos anteriores tienen diferentes códigos de bytes asociados con ellos, Leer Diferentes formas de crear objetos en Java con ejemplos para ejemplos y descripciones más detalladas, por ejemplo, conversión de códigos de bytes de todos estos métodos.

Sin embargo, se puede argumentar que crear una matriz o un objeto de cadena también es una forma de crear el objeto, pero estas cosas son más específicas solo para algunas clases y son manejadas directamente por JVM, mientras que podemos crear un objeto de cualquier clase usando estas 5 formas.

Clonación y deserialización .

También puedes usar

 Object myObj = Class.forName("your.cClass").newInstance();

Esto debe tenerse en cuenta si eres nuevo en Java, cada objeto ha heredado de Object

Objeto nativo protegido clone () arroja CloneNotSupportedException;

Además, puede des-serializar datos en un objeto. ¡Esto no pasa por la clase Constructor!

ACTUALIZADO : ¡Gracias Tom por señalar eso en tu comentario! Y Michael también experimentó.

Pasa por el constructor de la superclase no serializable más derivada.
Y cuando esa clase no tiene un constructor sin argumentos, se produce una InvalidClassException al deserializar.

Vea la respuesta de Tom para un tratamiento completo de todos los casos ;-)
¿Hay alguna otra forma de crear un objeto sin usar la palabra clave "nuevo" en Java

Hay un tipo de objeto que no puede construirse mediante mecanismos normales de creación de instancias (llamados constructores): matrices . Las matrices se crean con

 A[] array = new A[len];

o

 A[] array = new A[] { value0, value1, value2 };

Como dijo Sean en un comentario, esto es sintácticamente similar a una llamada de constructor e internamente no es mucho más que asignación e inicialización cero (o inicialización con contenido explícito, en el segundo caso) un bloque de memoria, con algún encabezado para indicar el tipo y la longitud.

Al pasar argumentos a un método varargs, también se crea una matriz (y se llena) implícitamente.

Una cuarta forma sería

 A[] array = (A[]) Array.newInstance(A.class, len);

Por supuesto, la clonación y la deserialización también funcionan aquí.

Hay muchos métodos en la API estándar que crean matrices, pero todos de hecho están utilizando una (o más) de estas formas.

Otras formas si estamos siendo exhaustivos.

• En Oracle JVM está Unsafe.allocateInstance () que crea una instancia sin llamar a un constructor.
• Usando la manipulación de código de byte puede agregar código a anewarray , multianewarray, newarrayo new. Estos se pueden agregar utilizando bibliotecas como ASM o BCEL. Se envía una versión de bcel con Java de Oracle. De nuevo, esto no llama a un constructor, pero puede llamar a un constructor como una llamada separada.

Reflexión:

someClass.newInstance();

La reflexión también hará el trabajo por ti.

SomeClass anObj = SomeClass.class.newInstance();

Es otra forma de crear una nueva instancia de una clase. En este caso, también tendrá que manejar las excepciones que se pueden generar.

• utilizando la new operador (invocando un constructor)
• usando la reflexión clazz.newInstance()(que nuevamente invoca al constructor). O bien clazz.getConstructor(..).newInstance(..)(de nuevo utilizando un constructor, pero puede elegir cuál)

Para resumir la respuesta, una forma principal, invocando al constructor de la clase del objeto.

Actualización: Otra respuesta enumeró dos formas que no implican el uso de un constructor: deseralización y clonación.

Hay CINCO formas diferentes de crear objetos en Java:

1. Usando la palabra clave `new`:

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.

MyObject object = new MyObject();//normal way

2. Mediante el uso del método de fábrica:

ClassName ObgRef=ClassName.FactoryMethod();

Ejemplo:

RunTime rt=Runtime.getRunTime();//Static Factory Method

3. Mediante el uso del concepto de clonación:

Al usar clone(), clone()se puede usar para crear una copia de un objeto existente.

MyObjectName anotherObject = new MyObjectName();
MyObjectName object = anotherObjectName.clone();//cloning Object

4. Usando `Class.forName ()`:

Si conocemos el nombre de la clase y si tiene un constructor público predeterminado, podemos crear un objeto de esta manera.

MyObjectName object = (MyObjectNmae) Class.forName("PackageName.ClassName").newInstance();

Ejemplo:

String st=(String)Class.forName("java.lang.String").newInstance();

5. Usando la deserialización de objetos:

La deserialización de objetos no es más que crear un objeto a partir de su forma serializada.

ObjectInputStreamName inStream = new ObjectInputStreamName(anInputStream );
MyObjectName object = (MyObjectNmae) inStream.readObject();

También puede clonar un objeto existente (si implementa Cloneable).

Foo fooClone = fooOriginal.clone (); 

Método 1

Usando nueva palabra clave. 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.

Employee object = new Employee();

Método 2

Usando Class.forName (). Class.forName () le proporciona el objeto de clase, que es útil para la reflexión. Los métodos que tiene este objeto los define Java, no el programador que escribe la clase. Son iguales para todas las clases. Llamar a newInstance () en eso le da una instancia de esa clase (es decir, callingClass.forName ("ExampleClass"). NewInstance () es equivalente a llamar a new ExampleClass ()), en el que puede llamar a los métodos que la clase define, acceder a los campos visibles, etc.

Employee object2 = (Employee) Class.forName(NewEmployee).newInstance();

Class.forName () siempre usará el ClassLoader de la persona que llama, mientras que ClassLoader.loadClass () puede especificar un ClassLoader diferente. Creo que Class.forName también inicializa la clase cargada, mientras que el enfoque ClassLoader.loadClass () no lo hace de inmediato (no se inicializa hasta que se usa por primera vez).

Otro debe leer:

Java: Introducción de estado de subproceso con ejemplo Ejemplo simple de Java Enum

Método 3

Usando clon (). El clon () se puede usar para crear una copia de un objeto existente.

Employee secondObject = new Employee();
Employee object3 = (Employee) secondObject.clone();

Método 4

Usando el método newInstance ()

Object object4 = Employee.class.getClassLoader().loadClass(NewEmployee).newInstance();

Método 5

Uso de la deserialización de objetos. La deserialización de objetos no es más que crear un objeto a partir de su forma serializada.

// Create Object5
// create a new file with an ObjectOutputStream
FileOutputStream out = new FileOutputStream("");
ObjectOutputStream oout = new ObjectOutputStream(out);

// write something in the file
oout.writeObject(object3);
oout.flush();

// create an ObjectInputStream for the file we created before
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("crunchify.txt"));
Employee object5 = (Employee) ois.readObject();

Desde la perspectiva del usuario de la API, otra alternativa a los constructores son los métodos estáticos de fábrica (como BigInteger.valueOf ()), aunque para el autor de la API (y técnicamente "de verdad") los objetos todavía se crean utilizando un constructor.

Depende exactamente de lo que quieres decir con crear, pero algunos otros son:

• Método de clonación
• Deserialización
• Reflexión (Class.newInstance ())
• Reflexión (objeto constructor)

también hay ClassLoader.loadClass (string) pero esto no se usa con frecuencia.

y si desea ser un abogado total al respecto, las matrices son técnicamente objetos debido a la propiedad .length de una matriz. así que inicializar una matriz crea un objeto.

Podemos crear objetos de 5 maneras:

1. por nuevo operador
2. por reflexión (por ejemplo, Class.forName () seguido de Class.newInstance ())
3. por el método de fábrica
4. por clonación
5. por reflexión api

También podemos crear el objeto de esta manera: -

String s ="Hello";

Nadie lo ha discutido.