A avut o conversație cu un coleg zilele trecute despre asta.
Nu's evident folosind un constructor, dar care sunt alte modalități de acolo?
Există patru moduri diferite de a crea obiecte în java:
O. Folosind " noi " de cuvinte cheie
Acesta este cel mai comun mod de a crea un obiect în java. Aproape 99% din obiecte sunt create în acest fel.
MyObject object = new MyObject();
B. Folosind Clasa.forName()`
Dacă știm numele clasei & dacă are un public constructorul implicit putem crea un obiect în acest fel.
MyObject object = (MyObject) Class.forName("subin.rnd.MyObject").newInstance();
C. Folosind clone()`
Clone() poate fi folosit pentru a crea o copie a unui obiect existent.
MyObject anotherObject = new MyObject();
MyObject object = (MyObject) anotherObject.clone();
D. Folosind obiect deserializarea
Obiect deserializarea este nimic, dar a crea un obiect de formă serializată.
ObjectInputStream inStream = new ObjectInputStream(anInputStream );
MyObject object = (MyObject) inStream.readObject();
Puteți să le citiți din aici.
Există diferite moduri:
...
) metoda call (nici un constructor pentru tablouri).arunca null; " sau " "".toCharArray()[0]
.În limbajul Java, singura modalitate de a crea un obiect este de asteptare sale de constructor, fie în mod explicit sau implicit. Folosind reflexia rezultatele într-un apel la metoda constructor, deserializarea folosește reflecție pentru a apela constructorul, fabrica metode încheia apelul la constructor la abstract la construcția propriu-zisă și clonarea este similar unui înfășurat apel constructor.
Există cinci moduri diferite de a crea un obiect în Java,
1. Folosind " noi " cuvinte cheie → constructor numit
Employee emp1 = new Employee();
2. Folosind newInstance()
metoda de "Clasa" → constructor numit
Employee emp2 = (Employee) Class.forName("org.programming.mitra.exercises.Employee")
.newInstance();
Acesta poate fi, de asemenea, scris ca
Employee emp2 = Employee.class.newInstance();
3. Folosind newInstance()
metoda Constructorul
→ constructor numit
Constructor<Employee> constructor = Employee.class.getConstructor();
Employee emp3 = constructor.newInstance();
4. Folosind clone ()` metode → fără apel constructor
Employee emp4 = (Employee) emp3.clone();
5. Folosind deserializarea → fără apel constructor
ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
Employee emp5 = (Employee) in.readObject();
Primele trei metode " noi " de cuvinte cheie și atât newInstance()
includ un apel constructor, dar mai târziu a două clone și deserializarea metode de a crea obiecte fără a apela la constructor.
Toate metodele de mai sus au diferite bytecode asociat cu ei, Citi moduri Diferite de a crea obiecte în Java cu Exemplu pentru exemple și descriere mai detaliată, de exemplu bytecode conversie a tuturor acestor metode.
Cu toate acestea, se poate argumenta că crearea unei matrice sau obiect șir este, de asemenea, o modalitate de a crea obiectul, dar aceste lucruri sunt mai specifice pentru unele clase numai și manipulate direct de către JVM, în timp ce putem crea un obiect de orice clasă, cu ajutorul acestor 5 moduri.
De asemenea, puteți de-serialize date într-un obiect. Asta nu't merge prin Constructorul clasei !
**** ACTUALIZAT : Multumesc Tom subliniat asta in comentariul tau ! Și Michael, de asemenea, experimentat.
trece prin constructor de cele mai multe derivate non-serializable superclasa. Și când acel curs nu are nici-args constructor, un InvalidClassException este aruncat pe de-serializarea.
Vă rugăm să consultați Tom's a răspunde pentru un tratament complet de toate cazurile ;-) https://stackoverflow.com/questions/2103089/is-there-any-other-way-of-creating-an-object-without-using-new-keyword-in-java/2103578#2103578
Există un tip de obiect, care poate't fi construite de exemplu crearea de mecanisme (de asteptare constructori): Tablouri. Tablouri sunt create cu
A[] array = new A[len];
sau
A[] array = new A[] { value0, value1, value2 };
Ca Sean a spus într-un comentariu, acest lucru este punct de vedere sintactic similar cu un apel constructor și pe plan intern nu este mult mai mult decât alocarea și zero-inițializarea (sau inițializarea cu conținut explicit, în al doilea caz) un bloc de memorie, cu un antet care să indice tipul și lungimea.
Atunci când transmiterea argumentelor la un varargs-metoda, o matrice este acolo l-a creat (și umplut), implicit, de asemenea.
O a patra modalitate ar fi
A[] array = (A[]) Array.newInstance(A.class, len);
Desigur, clonarea și deserializing lucrează aici, de asemenea.
Există mai multe metode din Standard API care creează tablouri, dar toate sunt, de fapt, folosind una (sau mai multe) din aceste moduri.
Alte moduri dacă suntem de a fi exhaustivă.
anewarray
, multianewarray
, newarray
sau noi
. Acestea pot fi adăugate folosind biblioteci, cum ar fi ASM sau BCEL. O versiune de bcel este livrat cu Oracle's Java. Din nou, aceasta nu't apela un constructor, dar puteți apela un constructor ca o separa de apel.clazz.newInstance()
(care din nou invocă constructor). Sau de clazz.getConstructor(..).newInstance(..)
(din nou, folosind un constructor, dar puteți astfel alege care unul)Pentru a rezuma răspuns - un singur fel principal - prin invocarea constructorului obiectului's class.
Update: un Alt răspuns enumerați două modalități care nu implică utilizarea unui constructor - deseralization și clonarea.
Reflecție, de asemenea, va face treaba pentru tine.
SomeClass anObj = SomeClass.class.newInstance();
este un alt mod de a crea o nouă instanță a unei clase. În acest caz, veți avea nevoie, de asemenea, să se ocupe de excepțiile care ar putea fi aruncat.
Există CINCI moduri diferite de a crea obiecte în Java:
Acesta este cel mai comun mod de a crea un obiect în Java. Aproape 99% din obiecte sunt create în acest fel.
MyObject object = new MyObject();//normal way
ClassName ObgRef=ClassName.FactoryMethod();
Exemplu:
RunTime rt=Runtime.getRunTime();//Static Factory Method
Prin utilizarea clone ()", " de clone()
poate fi folosit pentru a crea o copie a unui obiect existent.
MyObjectName anotherObject = new MyObjectName();
MyObjectName object = anotherObjectName.clone();//cloning Object
Dacă știm numele clasei & dacă are un public constructorul implicit putem crea un obiect în acest fel.
MyObjectName object = (MyObjectNmae) Class.forName("PackageName.ClassName").newInstance();
Exemplu:
String st=(String)Class.forName("java.lang.String").newInstance();
Obiect deserializarea este nimic, dar a crea un obiect de formă serializată.
ObjectInputStreamName inStream = new ObjectInputStreamName(anInputStream );
MyObjectName object = (MyObjectNmae) inStream.readObject();
Metoda 1
Folosind cuvinte cheie noi. Acesta este cel mai comun mod de a crea un obiect în java. Aproape 99% din obiecte sunt create în acest fel.
Employee object = new Employee();
Metoda 2
Folosind Clasa.forName(). Clasa.forName() vă oferă clasa object, care este util pentru reflecție. Metodele că acest obiect are sunt definite de Java, nu de programator scris de clasă. Acestea sunt aceleași pentru fiecare clasă. De asteptare newInstance() pe care vă oferă o instanță a acelei clase (de exemplu callingClass.forName("ExampleClass").newInstance() este echivalentă cu apelarea noi ExampleClass()), pe care puteți apela metodele clasei definește, acces la câmpuri vizibile etc.
Employee object2 = (Employee) Class.forName(NewEmployee).newInstance();
Clasa.forName() va utiliza întotdeauna Agent al apelantului, întrucât Agent.loadClass (), se poate specifica un alt Agent. Eu cred că Clasa.forName inițializează încărcate de clasă, precum și, întrucât Agent.loadClass() abordare nu face asta imediat (nu este inițializat până când este folosit pentru prima dată).
Un alt trebuie să citească:
Java: Fir de Stat cu Introducerea Exemplu Simple Java Enum Exemplu
Metoda 3
Folosind clone(). Clone() poate fi folosit pentru a crea o copie a unui obiect existent.
Employee secondObject = new Employee();
Employee object3 = (Employee) secondObject.clone();
Metoda 4
Folosind newInstance() metoda
Object object4 = Employee.class.getClassLoader().loadClass(NewEmployee).newInstance();
Metoda 5
Folosind Obiect Deserializarea. Obiect Deserializarea este nimic, dar a crea un obiect de formă serializată.
// 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();
De la un user API perspectivă, o altă alternativă pentru constructorii sunt metode fabrică statice (cum ar fi BigInteger.valueOf()), deși pentru API autor (și din punct de vedere tehnic "reală") obiectele sunt încă create folosind un constructor.
există, de asemenea, Agent.loadClass(string), dar acest lucru nu este de multe ori folosit.
și dacă vrei să fii un total avocat despre asta, tablouri sunt tehnic obiecte din cauza unei matrice's .lungimea de proprietate. deci inițializarea unei matrice creează un obiect.