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

Hay varias maneras:

• Hasta Class.newInstance.
• Hasta Constructor.newInstance.
• A través de la deserialización (utiliza el constructor no-args de la clase base no serializable más derivada).
• Hasta Object.clone (no llama a un constructor ).
• A través de JNI (debe llamar a un constructor).
• A través de cualquier otro método que llame a un new para usted.
• Supongo que podría describir la carga de clases como la creación de nuevos objetos (como interned Strings).
• 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 cadena constante en tiempo de no compilación (sucede que produce al menos cuatro objetos, en una implementación típica).
• Causando que una excepción sea creada y lanzada por el tiempo de ejecución. Por ejemplo throw null; o "".toCharArray()[0].
• Oh, y el boxeo de primitivos (a menos que se almacene en caché), de curso.
• JDK8 debería tener lambdas (esencialmente clases internas anónimas concisas), que se convierten implícitamente en objetos.
• Para completar (y Paŭlo Ebermann), hay algo de sintaxis con la palabra clave new también.

Dentro del lenguaje Java, la única forma de crear un objeto es llamando a su constructor, ya sea explícita o implícitamente. El uso de la reflexión resulta en una llamada al método constructor, la deserialización utiliza 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 al constructor envuelta.

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

La Clonación y deserialización.

También puedes usar

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

Esto debe notarse si es nuevo en java, cada objeto ha heredado de Object

Objeto nativo protegido clone () lanza CloneNotSupportedException;

También, puede des-serializar datos en un objeto. ¡Esto no pasa por el Constructor de clases !

ACTUALIZADO: Gracias Tom por señalar que en su comentario ! Y Michael también experimentó.

Pasa por el constructor de la superclase no serializable más derivada.
Y cuando esa clase no tiene ningún constructor no-args, se lanza una InvalidClassException sobre la serialización.

Por favor, vea la respuesta de Tom para una tratamiento completo de todos los casos ;-)
¿hay alguna otra forma de crear un objeto sin usar la palabra clave "new" en java

Hay un tipo de objeto, que no puede ser construido por mecanismos normales de creación de instancias (llamando a constructores): Arrays. Los arrays 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) de un bloque de memoria, con algún encabezado para indicar el tipo y la longitud.

Cuando se pasan argumentos a un método varargs, también se crea (y rellena) implícitamente un array.

Una cuarta vía 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.

Hay cinco formas diferentes de crear un objeto en Java,

1. Usando la palabra clave new → constructor get called

Employee emp1 = new Employee();

2. Usando el método newInstance() de Class → constructor get called

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 método newInstance() de Constructor → constructor get called

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

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

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

5. Utilizando la deserialización → sin llamada de constructor

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

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

Todos los métodos anteriores tienen diferentes bytecode asociados con ellos, Lea Diferentes formas de crear objetos en Java con Example para ejemplos y una descripción más detallada, por ejemplo, conversión de bytecode de todos estos métodos.

Sin embargo, uno puede argumentar que crear un objeto array o string es también 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 objetos de cualquier clase usando estas 5 formas.

Otras formas si estamos siendo exhaustivos.

• En la JVM de Oracle no es seguro.allocateInstance () que crea una instancia sin llamar a un constructor.
• Usando la manipulación de código de bytes puede agregar código a anewarray, multianewarray, newarray o new. Estos se pueden agregar usando bibliotecas como ASM o BCEL. Una versión de bcel se incluye con Java de Oracle. De nuevo esto no llama a un constructor, pero puedes 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 podrían ser lanzadas.

• usando el operador new (invocando así un constructor)
• usando reflexión clazz.newInstance() (que de nuevo invoca al constructor). O por clazz.getConstructor(..).newInstance(..) (de nuevo usando un constructor, pero por lo tanto 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.

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

Foo fooClone = fooOriginal.clone (); 

Hay CINCO formas diferentes de crear objetos en Java:

1. Usando la palabra clave 'nuevo':

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. Usando el Método de Fábrica:

ClassName ObgRef=ClassName.FactoryMethod();

Ejemplo:

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

3. Usando el Concepto de Clonación:

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

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

4. Utilizar `Clase.forName ()`:

Si conocemos el nombre de la clase y si tiene un constructor público por defecto 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();

Método 1

Usando una 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 Clase.forName (). Clase.forName () le da el objeto de clase, que es útil para la reflexión. Los métodos que tiene este objeto son definidos por Java, no por el programador que escribe la clase. Son iguales para todas las clases. Llamar newInstance() que proporciona una instancia de esa clase (es decir, Llamando a clase.forName ("ExampleClass").newInstance () es equivalente a llamar a new ExampleClass ()), en la que puede llamar a los métodos que la clase define, acceder a los campos visibles, etc.

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

Clase.forName () siempre usará el ClassLoader del llamante, mientras que ClassLoader.loadClass () puede especificar un cargador de clases diferente. Creo en esa clase.forName también inicializa la clase cargada, mientras que el ClassLoader.El enfoque loadClass() no hace eso de inmediato (no es inicializado hasta que se usa por primera vez).

Otro debe leer:

Java: Introducción al Estado del hilo con Ejemplo Ejemplo simple de Java Enum

Método 3

Usando clone(). Clone() 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

Usando 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 de fábrica estáticos (como BigInteger.valueOf ()), aunque para el autor de la API (y técnicamente "para real") los objetos todavía se crean usando un constructor.

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

• Método de clonación
• Deserialización
• Reflexión (Clase.newInstance ())
• Reflexión (objeto Constructor)

También hay ClassLoader.loadClass (string) pero esto no se usa a menudo.

Y si quieres ser un abogado total al respecto, los arrays son técnicamente objetos debido a un array .propiedad length. así que inicializar una matriz crea un objeto.

Podemos crear objetos de 5 maneras:

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

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

String s ="Hello";

Nadie lo ha discutido.