java方法重载和重载方法_Java中的重载与重载

java方法重载和重载方法

Overriding Vs Overloading In Java

在Java中覆盖vs重载

Overriding and Overloading are the core concepts in Java programming. They are the ways to implement polymorphism in our java programs. Polymorphism is one of the OOPS Concepts.

覆盖和重载是Java编程中的核心概念。 它们是在我们的Java程序中实现多态的方法。 多态是OOPS概念之一 。

1.什么是重载和重载？ (1. What is Overloading and Overriding?)

When two or more methods in the same class have the same name but different parameters, it’s called Overloading.

当同一类中的两个或多个方法具有相同的名称但参数不同时，则称为重载。

When the method signature (name and parameters) are the same in the superclass and the child class, it’s called Overriding.

当方法签名（名称和参数）在超类和子类中相同时，称为覆盖。

2.覆盖与重载 (2. Overriding vs Overloading)

1. Overriding implements Runtime Polymorphism whereas Overloading implements Compile time polymorphism.
   覆盖实现运行时多态，而重载实现编译时多态。
2. The method Overriding occurs between superclass and subclass. Overloading occurs between the methods in the same class.
   方法覆盖发生在父类和子类之间。 重载发生在同一类中的方法之间。
3. Overriding methods have the same signature i.e. same name and method arguments. Overloaded method names are the same but the parameters are different.
   覆盖方法具有相同的签名，即名称和方法参数相同。 重载的方法名称相同，但参数不同。
4. With Overloading, the method to call is determined at the compile-time. With overriding, the method call is determined at the runtime based on the object type.
   使用重载时，要在编译时确定要调用的方法。 通过覆盖，可以在运行时根据对象类型确定方法调用。
5. If overriding breaks, it can cause serious issues in our program because the effect will be visible at runtime. Whereas if overloading breaks, the compile-time error will come and it’s easy to fix.
   如果重载中断，可能会在我们的程序中引起严重的问题，因为这种影响将在运行时可见。 如果重载中断，则会出现编译时错误，并且很容易修复。

3.重载和重载示例 (3. Overloading and Overriding Example)

Here is an example of overloading and overriding in a Java program.

这是Java程序中重载和重写的示例。

package com.journaldev.examples;

import java.util.Arrays;

public class Processor {

	public void process(int i, int j) {
		System.out.printf("Processing two integers:%d, %d", i, j);
	}

	public void process(int[] ints) {
		System.out.println("Adding integer array:" + Arrays.toString(ints));
	}

	public void process(Object[] objs) {
		System.out.println("Adding integer array:" + Arrays.toString(objs));
	}
}

class MathProcessor extends Processor {

	@Override
	public void process(int i, int j) {
		System.out.println("Sum of integers is " + (i + j));
	}

	@Override
	public void process(int[] ints) {
		int sum = 0;
		for (int i : ints) {
			sum += i;
		}
		System.out.println("Sum of integer array elements is " + sum);
	}

}

The process() method is overloaded in the Processor class. Then, they are overridden in the child class MathProcessor.

process（）方法在Processor类中重载。 然后，它们在子类MathProcessor中被覆盖。

翻译自: https://www.journaldev.com/32182/overriding-vs-overloading-in-java

java方法重载和重载方法