O objeto é um bloco de construção básico de um OOPs linguagem. Em Java , não podemos executar nenhum programa sem criar um objeto . Existem várias maneiras de criar um objeto em Java que discutiremos nesta seção e também aprenderemos como criar um objeto em Java.
Java fornece cinco maneiras de criar um objeto.
- Usando novo Palavra-chave
- Usando clone() método
- Usando novaInstância() método do Aula aula
- Usando novaInstância() método do Construtor aula
- Usando Desserialização
Usando nova palavra-chave
Usando o novo palavra-chave é a maneira mais popular de criar um objeto ou instância da classe. Quando criamos uma instância da classe usando a palavra-chave new, ela aloca memória (heap) para o recém-criado objeto e também retorna o referência daquele objeto para aquela memória. A palavra-chave new também é usada para criar um array. A sintaxe para criar um objeto é:
ClassName object = new ClassName();
Vamos criar um programa que use a palavra-chave new para criar um objeto.
CreateObjectExample1.java
public class CreateObjectExample1 { void show() { System.out.println('Welcome to javaTpoint'); } public static void main(String[] args) { //creating an object using new keyword CreateObjectExample1 obj = new CreateObjectExample1(); //invoking method using the object obj.show(); } } Saída:
Welcome to javaTpoint
Usando a palavra-chave new, também podemos invocar o construtor (padrão ou parametrizado) da classe.
CreateObjectExample2.java
python é numérico
public class CreateObjectExample2 { //constructor of the class CreateObjectExample2() { System.out.println('Welcome to javaTpoint'); } public static void main(String[] args) { //creating an object using new keyword CreateObjectExample2 obj = new CreateObjectExample2(); } } Saída:
Welcome to javaTpoint
Usando o método clone()
O clone() método é o método de Objeto aula. Cria uma cópia de um objeto e retorna a mesma cópia. O JVM cria um novo objeto quando o método clone() é invocado. Ele copia todo o conteúdo do objeto criado anteriormente em um novo objeto. Observe que ele não chama nenhum construtor. Devemos implementar o Clonável interface ao usar o método clone(). O método lança CloneNotSupportedException exceção se a classe do objeto não suportar a interface Cloneable. As subclasses que substituem o método clone() podem lançar uma exceção se uma instância não puder ser clonada.
Nota: O método cria uma cópia do objeto, não um novo objeto.
Sintaxe:
protected Object clone() throws CloneNotSupportedException
Usamos a seguinte instrução para criar um novo objeto.
ClassName newobject = (ClassName) oldobject.clone();
CreateObjectExample3.java
tabela desc no mysql
public class CreateObjectExample3 implements Cloneable { @Override protected Object clone() throws CloneNotSupportedException { //invokes the clone() method of the super class return super.clone(); } String str = 'New Object Created'; public static void main(String[] args) { //creating an object of the class CreateObjectExample3 obj1 = new CreateObjectExample3(); //try catch block to catch the exception thrown by the method try { //creating a new object of the obj1 suing the clone() method CreateObjectExample3 obj2 = (CreateObjectExample3) obj1.clone(); System.out.println(obj2.str); } catch (CloneNotSupportedException e) { e.printStackTrace(); } } } Saída:
New Object Created
Usando o método newInstance() da classe Class
O novaInstância() O método da classe Class também é usado para criar um objeto. Ele chama o construtor padrão para criar o objeto. Ele retorna uma instância recém-criada da classe representada pelo objeto. Ele usa internamente o método newInstance() da classe Construtor.
Sintaxe:
public T newInstance() throws InstantiationException, IllegalAccessException
Ele joga o IlegalAccessException, InstantiationException, ExceptionInInitializerError exceções.
Podemos criar um objeto das seguintes maneiras:
ClassName object = ClassName.class.newInstance();
Ou
ClassName object = (ClassName) Class.forName('fully qualified name of the class').newInstance();
Na declaração acima, paraNome() é um método estático da classe Class. Ele analisa um parâmetro nome da classe do tipo String. Ele retorna o objeto da classe com o nome totalmente qualificado. Carrega a classe, mas não cria nenhum objeto. Isso joga ClassNotFoundException se a classe não puder ser carregada e Erro de ligação se a ligação falhar.
Para criar o objeto, usamos o novaInstância() método da classe Class. Funciona apenas quando sabemos o nome da classe e a classe tem um construtor público padrão.
No programa a seguir, criamos um novo objeto usando o método newInstance().
CreateObjectExample4.java
public class CreateObjectExample4 { void show() { System.out.println('A new object created.'); } public static void main(String[] args) { try { //creating an instance of Class class Class cls = Class.forName('CreateObjectExample4'); //creates an instance of the class using the newInstance() method CreateObjectExample4 obj = (CreateObjectExample4) cls.newInstance(); //invoking the show() method obj.show(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } } } Saída:
A new object created.
Usando o método newInstance() da classe Construtor
É semelhante ao novaInstância() método do Aula aula. É conhecida como uma forma reflexiva de criar objetos. O método é definido no Construtor classe que é a classe dejava.lang.reflectpacote. Também podemos chamar o construtor parametrizado e o construtor privado usando o método novaInstância() método. É amplamente preferido em comparação ao método newInstance() da classe Class.
Sintaxe:
public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
O método analisa uma matriz de objetos como um argumento. Os valores de tipos primitivos agrupados em um objeto wrapper do tipo apropriado. Ele retorna um novo objeto criado chamando o construtor. Isso joga IllegalAccessException, IllegalArgumentException, InstantiationException, InvocationTargetException, Exceções ExceptionInInitializerError .
como classificar um arraylist em java
Podemos criar um objeto da seguinte maneira:
Constructor constructor = Employee.class.getConstructor(); Employee emp3 = constructor.newInstance();
Vamos criar um programa que crie um objeto usando o método newInstance().
CreateObjectExample5.java
import java.lang.reflect.*; public class CreateObjectExample5 { private String str; CreateObjectExample5() { } public void setName(String str) { this.str = str; } public static void main(String[] args) { try { Constructor constructor = CreateObjectExample5.class.getDeclaredConstructor(); CreateObjectExample5 r = constructor.newInstance(); r.setName('JavaTpoint'); System.out.println(r.str); } catch (Exception e) { e.printStackTrace(); } } } Saída:
converter string para int
JavaTpoint
Usando desserialização
Em Java, serialização é o processo de conversão de um objeto em uma sequência de fluxo de bytes. O processo reverso (fluxo de bytes para objeto) de serialização é chamado desserialização . A JVM cria um novo objeto quando serializamos ou desserializamos um objeto. Ele não usa construtor para criar um objeto. Ao usar a desserialização, o Serializável interface (interface de marcador) deve ser implementada na classe.
Serialização: O escreverObjeto() método do ObjectOutputStream class é usada para serializar um objeto. Ele envia o objeto para o fluxo de saída.
Sintaxe:
public final void writeObject(object x) throws IOException
Desserialização: O método lerObjeto() de ObjectInputStream classe é usada para desserializar um objeto. Ele faz referência a objetos fora de um fluxo.
Sintaxe:
public final Object readObject() throws IOException,ClassNotFoundException
Nota: Torne o campo estático ou transitório se não quisermos incluir um campo como parte do objeto. Não será incluído no processo de serialização.
Vamos entender a serialização e desserialização através de um programa.
Funcionário.java
import java.io.Serializable; public class Employee implements Serializable { int empid; String empname; public Empoyee(int empid, String empname) { this.empid = empid; this.empname = empname; } } Criamos uma classe chamada Funcionário cujo objeto deve ser serializado e desserializado.
java bool para string
Serialização de objeto Java:
No programa a seguir, serializamos um objeto da classe Employee usando o método escreverObjeto() método da classe ObjectOutputStream. O estado do objeto é salvo no funcionário.txt arquivo.
SerializationExample.java
import java.io.*; class SerializationExample { public static void main(String args[]) { Try { //Creating the object Employee emp = new Employee(198054,'Andrew'); //Creates a stream and writes the object FileOutputStream fout=new FileOutputStream('employee.txt'); ObjectOutputStream out=new ObjectOutputStream(employeeout); out.writeObject(emp); out.flush(); //closes the output stream out.close(); System.out.println('Successfully Created'); } catch(Exception e) { System.out.println(e); } } } Saída:
Successfully Created
Desserialização do objeto Java:
No programa a seguir, iremos desserializar um objeto que serializamos no programa acima.
DeserializationExample.java
import java.io.*; class DeserializationExample { public static void main(String args[]) { try { //Creating a stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('employee.txt')); Employee e=(Employee)in.readObject(); //prints the data of the serialized object System.out.println(e.empid+' '+e.empname); //closing the input stream in.close(); } catch(Exception e) { System.out.println(e); } } } Saída:
198054 Andrew
Nos cinco métodos acima, notamos que o novo palavra-chave e ambos novaInstância() métodos usam o construtor para criar objetos, enquanto os dois métodos restantes não usam o construtor.