Java中的函数重写重载

超控和过载有什么区别？

• 重载方法是一种编译器技巧，允许您根据参数使用相同的名称执行不同的操作

• 重写一个方法意味着它的整个功能都被替换。重写是在子类中对父类中定义的方法执行的操作

---

src:

重载-类似签名-相同名称，不同参数

void foo() {
   /** overload */
}

void foo( int a ) {
   /** overload */
}

int foo() {
   /** this is NOT overloading, signature is for compiler SAME like void foo() */
}

重写-可以在继承方法体时重新定义它

class A {
   void foo() {
      /** definition A */
   }
}

class B extends A {
   void foo() {
      /** definition B, this definition will be used when you have instance of B */
   }
}

超载：

public Bar foo(int some);
public Bar foo(int some, boolean x);  // Same method name, different signature.

覆盖：

public Bar foo(int some);   // Defined in some class A
public Bar foo(int some);   // Same method name and signature. Defined in subclass of A.

如果没有定义第二个方法，它将继承第一个方法。现在它将被A子类中的第二个方法所取代。

• 重载：根据指定参数的数量和类型，在编译时选择方法签名

• 重写：根据目标对象的实际类型（与表达式的编译时类型相反），在执行时选择方法实现

例如：

class Base
{
    void foo(int x)
    {
        System.out.println("Base.foo(int)");
    }

    void foo(double d)
    {
        System.out.println("Base.foo(double)");
    }
}

class Child extends Base
{
    @Override void foo (int x)
    {
        System.out.println("Child.foo(int)");
    }
}

...

Base b = new Child();
b.foo(10); // Prints Child.foo(int)
b.foo(5.0); // Prints Base.foo(double)

这两个调用都是重载的例子。有两种方法称为

foo

，编译器决定调用哪个签名

第一个调用是重写的一个示例。编译器选择签名“foo（int）”，但在执行时，目标对象的类型决定要使用的实现应该是

Child

覆盖中的实现 当子类从超类继承的方法在子类中被替换（重写）时

class A {
  void foo() {
    /** definition A of foo */
  }
}

class B extends A {
  void foo() {
    /** definition B of foo */
  }
}

现在，如果您使用以下命令调用

foo

：

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

将运行

foo

的

B

定义。这不是很直观，因为如果类

a

没有名为

foo

的方法，则会出现编译错误。因此对象

a

的类型，即

a

必须具有方法

foo

，然后您可以调用它，实例的方法

foo

将被执行，这是类

B

的方法，因此是“执行时间”

超载 创建与现有方法同名的方法时。为了避免编译时错误，必须使用与现有方法不同的参数定义新方法。这样，这些方法将是可区分的。具有相同名称和参数的方法，但不同的返回类型仍然不明确，因此将导致编译错误。过载示例：

class A {
  void bar(int i) {}
  // The following method is overloading the method bar
  void bar(Object a) {}
  // The following will cause a compile error. 
  // Parameters should differ for valid overload
  boolean bar(int i) {
    return true;
  }
}

---

值得一提的是：

public static doSomething(Collection<?> c) {
    // do something
}

public static doSomething(ArrayList<?> l) {
    // do something
}

public static void main(String[] args) {
    Collection<String> c = new ArrayList<String> ();
    doSomething(c); // which method get's called?
}

公共静态剂量仪（集合c）{
//做点什么
}
公共静态剂量仪（ArrayList l）{
//做点什么
}
公共静态void main（字符串[]args）{
集合c=新的ArrayList（）；
doSomething（c）；//调用了哪个方法get？
}

---

有人会假设将调用带有ArrayList参数的方法，但它没有。调用第一个方法是因为在编译时选择了正确的方法。

在Java术语中，通常使用“方法”而不是“函数”。很抱歉，您可以看到我正在尝试学习一些东西，谢谢你的更正，我将从现在开始使用这个功能。如果你在谷歌上输入这个问题，你会得到成千上万的解释。