Interface

17 de julho de 2008 5 respostas

edymrex 17 de julho de 2008

Já venho estudando OO há algum tempo e ainda não entedo o porque do uso de interfaces sem nenhum método. Um exemplo é a interface Serializable, essa interface não contém nenhum método, ela é utilizada para serializar objetos, seu esboco é o seguinte:

* @author  unascribed
 * @version 1.25, 11/17/05
 * @see java.io.ObjectOutputStream
 * @see java.io.ObjectInputStream
 * @see java.io.ObjectOutput
 * @see java.io.ObjectInput
 * @see java.io.Externalizable
 * @since   JDK1.1
 */
public interface Serializable {
}

Tanto em Java quanto em C# existem essas interfaces, posso citar outro exemplo em java, a interface Cloneable, nesta interface minha dúvida ainda
é maior pois eu só posso sobrescrever o método clone da classe Object caso eu implemente essa interface, alguém sabe o porque disso ?

5 Respostas

Popeye12345 17 de jul. de 2008

Cara, por várias razões - desde polimorfismo até organização, um dos conceitos de OO é programar para interfaces e não para implementações.

Porque elas existem? Para que cada codigo faça a sua propria implementação. Digamos que você tem uma classe chamada Animais, e os animais tem comportamento de comer, certo? Então o correto é você criar uma interface dando a cada animal diferente a possibilidade de falar o que ele vai comer e do jeito dele.

Isso é um dos conceitos fundamentais de OO.

Outra coisa, essa interface Serializable que não tem nenhum método é uma interface do tipo Marcadora, ela diz que aquela classe vai poder serializar algum objeto.

edymrex 17 de jul. de 2008

Ok cara, esse conceito de interface marcadora que não entendo, porque eu só consigo dar um override no método clone da classe Object
se eu implementar a interface Cloneable ? como o compilador entede isso ?

helionagamachi 17 de jul. de 2008

Se você implementar a interface cloneable não será apenas esse método que você poderá dar um Override.
Outros métodos, da classe Object (toString(), hash() por exemplo), ou métodos da classe mãe da sua classe também podem ser redefinidos,
contanto que eles não possuam o modificador “final” que indica, que o método não pode ser redefinido.

EDIT:

Agora, para exemplificar , você tem uma classe que implementou a interface cloneable, e tem um código feito por você para o método clone().
se uma instância dessa classe chamar o método clone() , a máquina virtual irá utilizar sua implementação para o método.

Se a classe do objeto que chamou o método clone não tiver uma implementação própria para o método, então , uma implementação será procurada na classe mãe, e assim vai indo até achar uma implementação do mesmo, podendo chegar até na implementação do método clone() da classe Object.

edymrex 17 de jul. de 2008

Mas isso não explica cara.
Veja a classe Object:

public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }


    public final native Class<?> getClass();


    public native int hashCode();


    public boolean equals(Object obj) {
	return (this == obj);
    }


    protected native Object clone() throws CloneNotSupportedException;


    public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    public final native void notify();


    public final native void notifyAll();


    public final native void wait(long timeout) throws InterruptedException;


    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
				"nanosecond timeout value out of range");
        }

	if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
	    timeout++;
	}

	wait(timeout);
    }

 
    public final void wait() throws InterruptedException {
	wait(0);
    }


    protected void finalize() throws Throwable { }
}

O método clone “protected native Object clone()” como é protected, qualquer classe que herde de Object pode dar override esse método. Como todas as classes em java herdam implicitamente de Object, pela teoria eu podeia dar um override neste método, mas não é o que acontece caso eu queria utilizar esse método tenho que implementar a interface Cloneable como neste exemplo:

package com.certification.serializable;

import java.io.*;

	class Cat implements Serializable,Cloneable 
	{
		private String x;
		private String y;
		transient private String endereco;
		
		public void setX(String x) 
		{
			this.x = x;
		}
		public String getX() 
		{
			return x;
		}
		public void setY(String y) 
		{
			this.y = y;
		}
		public String getY() 
		{
			return y;
		}
		public void setEndereco(String endereco) 
		{
			this.endereco = endereco;
		}
		public String getEndereco() 
		{
			return endereco;
		}
		public Object clone() 
		{
		    //shallow copy
		    try {
		      return super.clone();
		    } catch (CloneNotSupportedException e) {
		      return null;
		    }
		  }
	} 

	class SerializeCat
	{
	
		public static void main(String args[])
		{
		
			Cat c = new Cat(); //criando o objeto
			Cat c2;
			  //aqui vou serializar meu objeto da class cat
			
			  try
			  {
			
				  FileOutputStream fo = new FileOutputStream("memoria");
			
				  ObjectOutputStream oo = new ObjectOutputStream(fo);
				  
				  c.setX("Antes de serializar x");
				  c.setY("Antes de serializar y");
				  c.setEndereco(c.toString());
				  c2=(Cat)c.clone();
			      oo.writeObject(c); // serializo objeto cat
			       
			      c.setX("Depois de serializar x");
				  c.setY("Depois de serializar y");
				  c.setEndereco(c.toString());
			      
			      
			
			      oo.close();
			
			      System.out.println("Class Cat - object serializado com sucesso");
			
			  }
			 catch(Exception e){e.printStackTrace();}                            
			
			 //des-serializo o objeto
			 try
			 {
			      FileInputStream fi = new FileInputStream("memoria");
			      ObjectInputStream oi = new ObjectInputStream(fi);
			      System.out.println(c.getEndereco());
			      c =(Cat) oi.readObject();
			      System.out.println(c.getEndereco());
			      oi.close();
			      System.out.println("agora ele foi des-serializado com sucesso");
			
			  }catch(Exception e){e.printStackTrace();}                          
		
		   }
		}

Minha dúvida é, porque eu tenho que implementar a interface Cloneable ?

sergiotaborda 17 de jul. de 2008

Puppets:

Tanto em Java quanto em C# existem essas interfaces, posso citar outro exemplo em java, a interface Cloneable, nesta interface minha dúvida ainda
é maior pois eu só posso sobrescrever o método clone da classe Object caso eu implemente essa interface, alguém sabe o porque disso ?

Coisas que existem em C# e Java não devem ser estranhas porque o C# é uma adpatação do Java ( aka um copia distorcida)
Interfaces sem métodos são chamadas interfaces marcadoras. Elas existem por dois motivos: no inicio do java não existiam anotações. Se existisse teríamos o seguinte:

@Serializable
public class ABC {

}

Segundo, interfaces podem mudar. Embora isso seja totalmente desaconselhado não é impossível (vide sql.DataSource). Isso forçaria todas as classes a implementar um novo método.

Para que “clone” seja visivel. “clone” já existem todos os objetos mas é protected. Cloneable informa que deve existir um método publico chamado clone. Quando a JVM não encontra isso dá problema.

Criado 17 de julho de 2008

Ultima resposta 17 de jul. de 2008

Respostas 5

Participantes 4

5 Respostas

Topicos relacionados