Menu

Interface do marcador em Java: serializável e clonável

marker interface java

Experimente Nosso Instrumento Para Eliminar Problemas

Este tutorial explica o que é uma interface de marcador em Java. Ele também cobre a desserialização de serialização e a clonagem em Java com exemplos de código:

Discutiremos o último tópico em Interfaces, ou seja, Marker Interface em Java.

Depois que terminarmos com a interface do marcador, discutiremos dois exemplos, ou seja, interface serializável e clonável em Java. Vamos começar com a interface do Marker.

=> Visite aqui para aprender Java do zero

Interfaces do marcador em Java - serializável e clonável

O que você aprenderá:

Interface do marcador em Java

Uma interface de marcador em Java é uma interface vazia que não possui campos ou métodos. Essa interface de marcador informa ao compilador que os objetos da classe que implementam a interface de marcador são diferentes e que devem ser tratados de maneira diferente.

Cada interface de marcador em Java indica que representa algo especial para JVM ou compilador.

Em Java, temos três interfaces que são interfaces de marcador, conforme mostrado abaixo:

# 1) Interface serializável: Serializable é uma interface de marcador presente no pacote java.io. Podemos serializar objetos usando esta interface, ou seja, salvar o estado do objeto em um arquivo.

# 2) Interface clonável: A interface clonável é parte do pacote java.lang e permite que os objetos sejam clonados.

# 3) Interface remota: A interface remota faz parte do pacote java.RMI e usamos essa interface para criar aplicativos RMI. Essa interface lida principalmente com objetos remotos.

Neste tutorial, discutiremos a interface serializável e clonável. A interface remota será discutida quando mudarmos para RMI em Java.

Serialização em Java

Antes de entrarmos nos detalhes da interface serializável em Java, vamos entender o processo de serialização, bem como a desserialização em Java.

A serialização pode ser definida como um processo pelo qual convertemos o estado do objeto em seu fluxo de bytes equivalente para armazenar o objeto na memória em um arquivo ou persistir o objeto.

Quando quisermos recuperar o objeto de seu estado salvo e acessar seu conteúdo, teremos que converter o fluxo de bytes de volta para o objeto Java real e esse processo é chamado de desserialização.

Dessa forma, pode haver muitos casos em que precisamos serializar / desserializar objetos Java durante a vida útil do aplicativo Java.

O processo de serialização / desserialização é mostrado abaixo:

serialização OU desserialização

Conforme mostrado acima, a serialização converte o objeto em um fluxo. A desserialização converte o fluxo de bytes de volta em um objeto Java.

Todo o mecanismo de serialização e desserialização é independente da plataforma. Isso significa que podemos serializar o objeto em uma plataforma e, em seguida, desserializá-lo em uma plataforma diferente.

Quando dizemos que serializamos o objeto Java, significa que chamamos o método ObjectOutputStream writeObject () para gravar o objeto em um arquivo.

qual o melhor downloader de musica para pc

public final void writeObect (Object obj) lança IOException

Da mesma forma, no caso de desserialização, chamamos o método ObjectInputStream :: readObject () para ler os dados do arquivo que armazenou o objeto.

public final Object readObject () lança IOException, ClassNotFoundException

Interface Java Serializable

Java fornece a interface chamada ‘serializável’ com a qual podemos implementar serialização e desserialização em Java.

A interface serializável é parte do pacote java.io. É um exemplo de uma interface de marcador que discutimos acima e 0 que não possui métodos ou membros. A interface serializável 'marca' as classes Java para que os objetos dessas classes tenham a capacidade de persistir.

Portanto, a classe cujo objeto precisamos persistir deve implementar a interface Serializable. Em seguida, o objeto desta classe (implementando a interface Serializable) usará os métodos writeObject () e readObject () respectivamente para serializar e desserializar o objeto de classe.

Observe que todas as classes de wrapper e a classe String implementam java.io.Serializable por padrão.

Devemos cumprir a seguinte condição para que um objeto seja serializado com sucesso:

  1. A classe cujos objetos são serializados deve implementar a interface java.io.Serializable.
  2. Todos os campos de membro da classe devem ser serializáveis. Se um determinado campo não for serializável, devemos marcá-lo como temporário.

Por outro lado, uma classe é serializável apenas se implementar a interface java.io.Serializable, caso contrário, não é serializável.

Como serializar e desserializar um objeto em Java

Quando serializamos um objeto em Java, usamos o método writeObject de objectOutputStream para gravar o objeto em um arquivo.

Para desserializar o objeto em Java, usamos o método readObject () do ObjectInputStream para ler o conteúdo do arquivo e lê-lo em um objeto.

Neste exemplo, temos uma classe de aluno que implementa a interface serializável. Isso significa que podemos serializar ou desserializar os objetos da classe Aluno.

No método principal do programa Java, criamos um objeto de classe Student. Em seguida, criamos um ObjectOutputStream que aponta para um objeto FileOutputStream que, por sua vez, aponta para um arquivo no qual precisamos escrever o objeto Student. Em seguida, chamamos o método writeObject () que grava o objeto no arquivo.

Ao gravar com sucesso o objeto especificado no arquivo especificado, o programa fornece uma mensagem de saída apropriada. Em seguida, desserializamos o objeto, revertendo o processo acima. Primeiro, criamos um objeto ObjectOutputStream no qual lemos o arquivo cujo conteúdo deve ser lido.

Em seguida, usamos o método readObject () para ler o conteúdo e lançá-lo no objeto Aluno. Em seguida, imprimimos o conteúdo do objeto Aluno.

Exemplo de serialização / desserialização

O programa Java a seguir mostra o mecanismo de serialização / desserialização em Java conforme discutido acima.

import java.io.*; import java.io.Serializable; //Class Student implements class Student implements Serializable{ int id; String name; public Student(int id, String name) { this.id = id; this.name = name; } } class Main{ public static void main(String args()){ try{ //Create the object of student class Student s1 =new Student(27,'Eddie'); //Write the object to the stream by creating a output stream FileOutputStream fout=new FileOutputStream('Eddie.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //close the stream out.close(); System.out.println('Object successfully written to the file'); //Create a stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('Eddie.txt')); Student s=(Student)in.readObject(); //print the data of the deserialized object System.out.println('Student object: ' + s.id+' '+s.name); //close the stream in.close(); }catch(Exception e){System.out.println(e);} } }

Resultado:

Exemplo de serialização / desserialização

Observe que, após a desserialização, obtemos o mesmo objeto que serializamos anteriormente à medida que abrimos o mesmo arquivo novamente.

Palavra-chave transitória Java

Uma palavra-chave transiente é usada para tornar um membro de dados transitório, ou seja, não queremos serializá-lo.

Por exemplo, considere a seguinte classe Employee. Aqui temos o campo Id do funcionário junto com os outros campos. Agora, se decidirmos que o campo Id do funcionário não deve ser serializado, então o declaramos como 'transitório'.

Um exemplo de programa Java é fornecido abaixo.

import java.io.*; class Employee implements Serializable{ transient int id; String name; public Employee(int id, String name) { this.id = id; this.name = name; } } class Main{ public static void main(String args()){ try{ //Create the object of Employee class Employee s1 =new Employee(27,'Eddie'); //Write the object to the stream by creating a output stream FileOutputStream fout=new FileOutputStream('Eddie.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //close the stream out.close(); System.out.println('Object successfully written to the file'); //Create a stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('Eddie.txt')); Employee s=(Employee)in.readObject(); //print the data of the deserialized object System.out.println('Employee object: ' + s.id+' '+s.name); //close the stream in.close(); }catch(Exception e){System.out.println(e);} } }

Resultado:

Palavra-chave transitória Java

No programa acima, serializamos o objeto Employee. Mas observe que o campo de id do Employee da classe Employee é declarado 'transitório'. Agora, para verificar a serialização, desserializamos o objeto. A saída mostra o objeto Employee como ‘0 Eddie’. Isso significa que o ID do funcionário não foi salvo no arquivo.

Java.io.NotSerializableException em Java

A exceção de java.io.NotSerializableException é uma exceção que é lançada quando a classe não é elegível para serialização. A classe que não implementa a interface Serializable torna-se inelegível para serialização.

O programa Java abaixo demonstra a NotSerializableException.

import java.io.*; class Employee { transient int id; String name; public Employee(int id, String name) { this.id = id; this.name = name; } } class Main{ public static void main(String args()){ try{ //Create the object of Employee class Employee s1 =new Employee(27,'Eddie'); //Write the object to the stream by creating a output stream FileOutputStream fout=new FileOutputStream('Eddie.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //close the stream out.close(); System.out.println('Object successfully written to the file'); }catch(Exception e){System.out.println(e);} } }

Resultado:

Java.io.NotSerializableException em Java

Como visto no programa acima, a classe Employee não implementa a interface Serializable. Portanto, quando tentamos serializar o objeto da classe Employee, a NotSerializableException é lançada.

Interface clonável em Java

A clonagem de objetos significa fazer uma cópia dos objetos. Java suporta clonagem de objetos usando o “ Clonável ”Interface. A interface clonável é uma interface de marcador e faz parte do pacote java.lang.

Quando uma classe implementa a interface Clonável, isso implica que podemos clonar os objetos dessa classe. A classe Object de Java contém o ' clone () 'Método. Portanto, a interface clonável implementada por uma classe específica autoriza o método clone () a fazer cópias das instâncias da classe.

Se uma classe não implementa uma interface clonável e ainda invoca o método clone (), então a exceção CloneNotSupportedException é lançado pelo compilador Java.

As classes que implementam a interface Cloneable devem substituir o método clone ().

Então, o que é clonagem de objetos?

A clonagem de objeto é um processo pelo qual criamos uma cópia exata do objeto usando o método clone () da classe Object. Para que o método clone () seja substituído e chamado, a classe precisa implementar a interface Clonável.

A sintaxe geral do método clone () é fornecida abaixo:

protegido Clone de objeto () lança CloneNotSupportedException

O método clone () cria uma cópia exata do objeto com menos tempo de processamento do que o necessário para criar um novo objeto usando a nova palavra-chave.

O programa Java abaixo demonstra o uso do método clone () e da interface clonável.

class Student implements Cloneable{ int rollno; String name; //class constructor Student(int rollno,String name){ this.rollno=rollno; this.name=name; } //clone method public Object clone()throws CloneNotSupportedException{ return super.clone(); } } class Main{ public static void main(String args()){ try{ Student s1=new Student(101,'Lissa'); //clone the s1 object Student s2=(Student)s1.clone(); System.out.println('Original Student object: ' + s1.rollno+' '+s1.name); System.out.println('Cloned Student object: ' + s2.rollno+' '+s2.name); }catch(CloneNotSupportedException c){} } }

Resultado:

Clonagem de Objetos

Neste programa, temos uma classe Student implementando a interface clonável. Ele também substitui o método clone () chamando o método super.clone (). No método principal, criamos um novo objeto Student e então chamamos o método clone () neste objeto que retorna o novo objeto Student.

Clone Array em Java

Exploramos a clonagem de arrays em nosso tutorial sobre Arrays. Como os arrays Java implementam a interface clonável por padrão, eles não precisam ser implementados explicitamente. Quando a matriz unidimensional é clonada, uma cópia profunda da matriz é gerada. Quando uma matriz bidimensional é clonada, uma cópia superficial é feita.

Fazer uma cópia superficial é o comportamento padrão do método clone () em Java. Mas na maioria das vezes desejamos uma clonagem profunda. Na clonagem profunda, fazemos uma cópia do objeto membro por membro e criamos um clone que é independente do objeto original. Quaisquer alterações feitas no objeto clone não serão refletidas no objeto original.

O programa Java a seguir mostra a clonagem de uma matriz unidimensional.

class Main { public static void main(String args()) { //define an array int intArray() = {2,6,3,7,1,8}; //invoke clone () method on intArray int cloneArray() = intArray.clone(); //print the arrays. System.out.println('Original intArray:'); for (int i = 0; i

Resultado:

Clone Array em Java

Lista de clones em Java

O programa a seguir mostra como usar um método clone () para clonar uma lista em Java.

import java.util.ArrayList; import java.util.Arrays; import java.util.List; // MyList Class implementing cloneable class MyList implements Cloneable { String name1; String name2; // Constructor MyList(String name1, String name2) { this.name1 = name1; this.name2 = name2; } // To print the objects in the desired format @Override public String toString() { return 'Hello ' + name1 + ',' + name2 + ' ' ; } // Overriding the clone method @Override protected MyList clone() { return new MyList(name1 , name2); } } class Main { public static void main(String() args) { // Create a list List original = Arrays.asList( new MyList('Sydney','Rose'), new MyList('Joe','Ian')); // Create an empty list List cloned_list = new ArrayList(); // Loop through the list and clone each element for (MyList temp : original) cloned_list.add(temp.clone()); System.out.print(cloned_list); } }

Resultado:

Lista de clones em Java

No programa acima, vemos que criamos uma classe MyList que implementa a interface Cloneable e, dentro dessa classe, substituímos o método clone () que nos ajuda a clonar a List. No método principal, criamos uma lista de elementos e, em seguida, clonamos cada elemento da lista iterando sobre a lista.

perguntas frequentes

P # 1) Qual é o uso da interface do marcador em Java?

Responda: A interface do marcador, também conhecida como 'interface marcada', marca a classe e informa ao compilador que essa classe pode implementar um comportamento especial.

P # 2) O que são todas as interfaces de marcador em Java?

Responda: Serializable, Cloneable e Remote são as interfaces que são exemplos de interfaces de marcador em Java.

P # 3) Por que uma interface de marcador é serializável?

Responda: A interface serializável não possui nenhum método ou variável de membro. É uma interface vazia que a classifica como uma interface de marcador.

P # 4) É executável uma interface de marcador?

Responda: Não, runnable não é uma interface de marcador. A interface executável não está vazia e fornece uma declaração de método run () dentro dela.

P # 5) Por que precisamos implementar uma interface clonável?

Responda: Ao implementar uma interface clonável para uma classe, indicamos que os objetos dessa classe podem ser clonados usando o método clone () da classe Object. Se uma classe usando o método clone () não implementa uma interface clonável, a exceção ‘CloneNotSupportedException’ é lançada.

Conclusão

Com este tutorial, concluímos nossa discussão sobre Interfaces em Java. Discutimos o conceito de interfaces, sua estrutura, definição, uso, etc. Também discutimos algumas das interfaces importantes em interfaces Java-like Comparable, Comparator, Marker, etc.

Neste tutorial, discutimos dois exemplos de interfaces de marcador, ou seja, serializável e clonável. Uma interface serializável é usada para persistir um objeto. A interface clonável é usada para clonar os objetos de classe. Ambas as interfaces são interfaces de marcador, ou seja, estão vazias.

Mas quando uma classe os implementa, eles indicam que o compilador pode esperar algum comportamento especial das classes que os implementam.

Por exemplo, quando uma classe implementa uma interface serializável, podemos serializar ou desserializar os objetos da classe e salvar / recuperar seu estado.

Uma classe que implementa uma interface clonável indica que podemos clonar os objetos dessa classe. A implementação padrão do método clone () cria uma cópia superficial do objeto enquanto podemos substituir o método clone () para criar uma cópia profunda.

=> Explore a série completa de treinamento Java aqui

Leitura recomendada

^