ist es möglich, eine endgültige Methode zu überladen

Question

In Java können wir nicht eine endgültige Methode überschreiben, aber ist es möglich, zu überlasten?

Answer 1

Ja, das Überladen einer endgültigen Methode ist vollkommen legitim.

Zum Beispiel:

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

Answer 2

Ja Es ist möglich.

Sie können diese Art von Dingen untersuchen, indem Sie kleine Java-Klassen schreiben.

class TestClass{ 
    final public void testMethod(){ 

    } 

    final public void testMethod(int i){ 

    } 
} 

Answer 3

JA, warum nicht? Es ist so legal wie nicht-finale Methoden zu überladen.

Aber man kann sie nicht außer Kraft setzen (Sie wissen es bereits).

ZB:

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

ja letzte Methode Überlastung ist möglich, in java.As sind endgültige Verfahren beschränkt nicht die Methoden außer Kraft zu setzen.

Beim Überladen der Argumentliste muss ein anderer Typ der Überlademethode angegeben werden.

Answer 5

Ja, sehr viel möglich.

Ein kleines Programm, um es zu zeigen:

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); 
    } 
} 

Ausgang:

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

Answer 6

Ja, aber bewusst sein, dass dynamischer Dispatch vielleicht nicht tun, was Sie erwarten! Schnell Beispiel:

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)); 
} 

Dies drucken:

Object 
Object

Answer 7

ja wir die letzten Methoden überlasten

Answer 8

Ja:

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); 
    } 
}