es posible sobrecargar un método final

Question

En Java no podemos anular un método final pero ¿es posible sobrecargar?

Answer 1

Sí, la sobrecarga de un método final es perfectamente legítima.

Por ejemplo:

public final void doStuff(int x) { ... } 
public final void doStuff(double x) { ... } 

Answer 2

Sí Es posible.

Puede examinar este tipo de cosas escribiendo pequeñas clases de Java.

class TestClass{ 
    final public void testMethod(){ 

    } 

    final public void testMethod(int i){ 

    } 
} 

Answer 3

SÍ, ¿por qué no? Es tan legal como sobrecargar métodos no finales.

Pero no se los puede sustituir (ya lo saben).

Ej:

public final void func(String x) {/* code */} 
public final void func(double x) { /* more code */ } 
public final void func(int x) { /* yeah I have still more code */ } 

Answer 4

sí sobrecarga último método es posible en java.As métodos finales están restringidas no para anular los métodos.

mientras que la lista de argumentos de sobrecarga debe ser del tipo diferente del método de sobrecarga.

Answer 5

Sí, es muy posible.

Un pequeño programa para demostrar que:

class A{ 
    final void foo(){ System.out.println("foo ver 1 from class A"); } 
    final void foo(int a){ System.out.println("foo ver 2 from class A"); } 
    } 


class B extends A{ 
    final void foo(long l){ System.out.println("foo ver 3 from class B"); } 
    // final void foo(){ System.out.println("foo ver 1 from class A"); } NOT ALLOWED 
} 

public class Test {  
    public static void main(String [] args){ 
     B obj = new B(); 

     obj.foo(); 
     obj.foo(1); 
     obj.foo(1L); 
    } 
} 

Salida:

 
foo ver 1 from class A 
foo ver 2 from class A 
foo ver 3 from class B 

Answer 6

Sí, pero tenga en cuenta que el envío dinámica podría no hacer lo que usted está esperando! Ejemplo rápido:

class Base { 
    public final void doSomething(Object o) { 
     System.out.println("Object"); 
    } 
} 

class Derived extends Base { 
    public void doSomething(Integer i) { 
     System.out.println("Int"); 
    } 
} 

public static void main(String[] args) { 
    Base b = new Base(); 
    Base d = new Derived(); 
    b.doSomething(new Integer(0)); 
    d.doSomething(new Integer(0)); 
} 

Esto imprimirá:

Object 
Object

Answer 7

sí podemos sobrecargar los métodos finales

Answer 8

Sí:

class a { 
    final void method1(int a,int b) { 
    System.out.println("super class"); 
    int d = a+ b; 
    System.out.println(d); 
    } 
} 
class b extends a{ 
    final void method1(int a) { 
    System.out.println("sub class"); 
    System.out.println(a); 
    } 
} 
public class c { 
    public static void main(String ar[]) { 
    b m = new b(); 
    m.method1(10); 
    } 
}