Comportamento do método estático final

Eu tenho brincado com modificadores com método estático e me deparei com um comportamento estranho.

Como sabemos, métodos estáticos não podem ser substituídos, pois estão associados à classe e não à instância.

Então, se eu tenho o trecho abaixo, ele compila bem

//Snippet 1 - Compiles fine
public class A {
    static void ts() {
    }
}

class B extends A {
    static void ts() {
    }
}

Mas se eu incluir o modificador final do método estático na classe A, a compilação falhará ts () em B e não poderá substituir ts () em A; O método substituído é final estático .

Por que isso está acontecendo quando o método estático não pode ser substituído?

Métodos estáticos não podem ser substituídos, mas podem ser ocultados. O ts()método de B não substitui (não está sujeito a polimorfismo) o ts()de A, mas o oculta. Se você chamar ts()B (NOT A.ts()ou B.ts()... just ts()), o de B será chamado e não A. Como isso não está sujeito ao polimorfismo, a chamada ts()em A nunca será redirecionada para a de B.

A palavra final- chave impedirá que o método seja oculto. Portanto, eles não podem ser ocultados e uma tentativa de fazer isso resultará em um erro do compilador.

Espero que isto ajude.

métodos estáticos não podem ser substituídos

isso não é exatamente verdade. O código de exemplo realmente significa que o método ts em B oculta o método ts em A. Portanto, não é exatamente anulado. Em Javaranch, há uma boa explicação.

Os métodos estáticos pertencem à classe, não à instância.

A.ts()e B.ts()sempre serão métodos separados.

O verdadeiro problema é que o Java permite chamar métodos estáticos em um objeto de instância. Métodos estáticos com a mesma assinatura da classe pai são ocultos quando chamados de uma instância da subclasse. No entanto, você não pode substituir / ocultar os métodos finais .

Você pensaria que a mensagem de erro usaria a palavra oculta em vez de substituída ...

Você pode encontrar-se na posição de pensar em finalizar um método estático, considerando o seguinte:

Tendo as seguintes classes:

class A {
    static void ts() {
        System.out.print("A");
    }
}
class B extends A {
    static void ts() {
        System.out.print("B");
    }
}

Agora, a maneira 'correta' de chamar esses métodos seria

A.ts();
B.ts();

o que resultaria, ABmas você também poderia chamar os métodos nas instâncias:

A a = new A();
a.ts();
B b = new B();
b.ts();

o que resultaria ABtambém.

Agora considere o seguinte:

A a = new B();
a.ts();

isso seria impresso A. Isso pode surpreendê-lo, pois você está realmente tendo um objeto de classe B. Mas como você está chamando a partir de uma referência do tipo A, ele chamará A.ts(). Você pode imprimir Bcom o seguinte código:

A a = new B();
((B)a).ts();

Nos dois casos, o objeto que você possui é realmente da classe B. Mas, dependendo do ponteiro que aponta para o objeto, você chamará o método de Aou deB .

Agora, digamos que você é o desenvolvedor da classe Ae deseja permitir a subclassificação. Mas você realmente deseja um método ts(), sempre que chamado, mesmo de uma subclasse, que é o que você deseja que ele faça e que não seja oculto por uma versão da subclasse. Então você pode fazer isso finale impedir que ele fique oculto na subclasse. E você pode ter certeza de que o código a seguir chamará o método da sua classe A:

B b = new B();
b.ts();

Ok, admitidamente, isso é de alguma forma construído, mas pode fazer sentido para alguns casos.

Você não deve chamar métodos estáticos nas instâncias, mas diretamente nas classes - então você não terá esse problema. Também o IntelliJ IDEA, por exemplo, mostrará um aviso, se você chamar um método estático em uma instância e também se você finalizar um método estático.

O método ts () em B não substitui o método ts () em A; simplesmente é outro método. A classe B não vê o método ts () em A, pois é estático; portanto, pode declarar seu próprio método chamado ts ().

No entanto, se o método for final, o compilador perceberá que existe um método ts () em A que não deve ser substituído em B.

Eu acho que o erro de compilação foi bastante enganador aqui. Não deveria ter dito "o método substituído é final estático.", Mas deveria ter dito "o método substituído é final.". O modificador estático é irrelevante aqui.

Um método estático não pode ser substituído em Java, diferentemente dos métodos não estáticos. Mas eles são herdados como membros de dados estáticos e não estáticos. É por isso que um método não estático com o mesmo nome não pode ser criado na classe pai

class Writer { 
    public static void doo(){
        System.out.println("sth");
    } 
}
class Author extends Writer{ 
    public void doo(){
        System.out.println("ok"); // error overridden method is static
    }
}

A finalpalavra-chave garante que o corpo do método específico seja executado sempre que uma chamada para o método. Agora, se um método estático for criado na classe filho com o mesmo nome e for feita uma chamada para o método, o método na subclasse será executado, o que não deve ser o caso se final for prefixado antes do nome do método estático na classe pai . Portanto, a palavra-chave final restringe a criação do método com o mesmo nome na classe filho.