Uso de static em interfaces

8 respostas
Gravitor91w

Hoje tentei criar um método static numa interface e vi que Java não permite… Qual o motivo?

8 Respostas

T

Um método static não está associado a uma instância de um objeto, e sim a uma classe.

Acontece que uma interface (no caso do Java) indica o que uma classe deve implementar quanto a seus métodos de instância.

(Essa foi uma decisão de projeto; poderia ser que o Java suportasse métodos static em interfaces, mas só com o intuito de obrigar a implementação desses métodos. Por exemplo, você poderia ter uma interface assim:

interface Application {
    public static void main (String[] args);
}
...
class MinhaAplicacao extends JFrame implements Application {
    public static void main(String[] args) {
        ....
    }
}
Gravitor91w

Java não aceita apenas por especificação? Não há nenhum motivo envolvendo algun conceito?

Marky.Vasconcelos

Eu pensei que fosse porque métodos static não sofrem polimorfismo
=/

Gravitor91w

Mas se eu quiser obrigar uma classe a ter um certo método static? Como posso fazer isso sem ser por uma interface?

LPJava

vc nao pode ter static em uma interface pq o metodo static nao pode herdado… e na classe fica assim:

class Sol{
static void metodo(){}
}
//metodo static da class

flw!! :smiley:

peczenyj

Cite um exemplo onde vc precisa que uma classetenha um método static.

interface X{
        String xxx();
}
class Pai implements X{
        public static String estatico(){
                return "metodo estatico da classe Pai";
        }
        public String instancia(){
                return "metodo de instancia da classe Pai";
        }
        public String xxx(){
                return "acabou a criatividade";
        }
}

class Filho extends Pai implements X{
        public static String estatico(){
                return "metodo estatico da classe Filha";
        }
        public String instancia(){
                return "metodo de instancia da classe Filha";
        }
        public String xxx(){
                return "sei la...";
        }
}

public class A{
        public static void main(String [] x){
                Pai p = new Pai();
                Filho f = new Filho();
                Pai pf = new Filho();
                X x1 = new Pai();
                X x2 = new Filho();


                System.out.println("p  "+p.estatico());
                System.out.println("p  "+p.instancia());
                System.out.println("p  "+p.xxx());
                System.out.println("f  "+f.estatico());
                System.out.println("f  "+f.instancia());
                System.out.println("f  "+f.xxx());
                System.out.println("pf "+pf.estatico());
                System.out.println("pf "+pf.instancia());
                System.out.println("pf "+pf.xxx());
                System.out.println("x1 "+x1.xxx());
                System.out.println("x2 "+x2.xxx());


        }
}
p  metodo estatico da classe Pai
p  metodo de instancia da classe Pai
p  acabou a criatividade
f  metodo estatico da classe Filha
f  metodo de instancia da classe Filha
f  sei la...
pf metodo estatico da classe Pai
pf metodo de instancia da classe Filha
pf sei la...
x1 acabou a criatividade
x2 sei la...

Normalmente tu trabalhas com instâncias de objetos que podem implementar interfaces.

Veja o exemplo do objeto pf: mesmo que Filho seja uma especialização de pai, os métodos estáticos não sofrem polimorfismo. De que adianta que uma dada classe tenha um método X? Vc não vai converter uma Classe em Outra ;-)

T

Eu havia mencionado que foi uma decisão de projeto, mais que alguma coisa inerente à programação orientada a objetos.

De fato, forçar a implementação de um método estático às vezes é útil mas não pode ser expressa convenientemente em Java.
O exemplo clássico é o de que “uma classe, para ser executada, deve ter o método “public static void main””.
Isso não pode ser expresso em Java a partir de código, só a partir de documentação, o que convenhamos que não é suficiente.

T

Acho que se métodos estáticos pudessem ser especificados em interfaces, talvez tivéssemos de alterar um pouco a definição do bytecode invokeinterface - já que invokeinterface sempre passa ao método chamado uma referência a this; ele teria de checar se o método é estático e nesse caso não passar a referência a this. É meio chato isso.

http://java.sun.com/docs/books/jvms/second_edition/html/Compiling.doc.html#14787

Criado 22 de novembro de 2007
Ultima resposta 24 de nov. de 2007
Respostas 8
Participantes 5