(1)方法重载概念：

在同一个类中，可以存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

(2）重载特点：

与方法的返回值和修饰符无关，只看参数列表。

(3)重载好处：

便于阅读，优化设计。

(4)使用规范

方法名一定要相同。
方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。
方法的返回类型、修饰符可以相同，也可不同。

(5)方法重载测试：
class ceshi{
	public static void main(String[] args){
		System.out.println(add(2,3));
		System.out.println(add(2,3,10));
	}
	
	//求两个数的和
	public static int add(int a,int b){
		return a+b;
	}
	
	//求三个数的和
	public static int add(int a,int b,int c){
		return a+b+c;
	}
}

可以看到，两个方法都得到了正确的调用：

在 上一期 讲到了递归，今天来讲一下方法的重载！

Java允许同一个类中定义多个同名方法，只要参数的个数或者类型不同即可。如果符合这种条件，即可称为方法的重载！！


文章目录
Java方法重载 概念
Java方法重载 实例
其它

Java方法重载 概念
在Java中，确定一个方法有三个因素：

调用者（方法所属者），既可以是类，又可以是对象；
方法名，方法的标识；
形参列表，当调用方法时，系统会根据传输入的实参列表进行匹配！

方法重载的必要条件：
同一个类中，方法名相同，参数列表不同（即 个数上不同，对应类型上不同）
Java方法重载 实例
public class Main {

    /**
     * CSDN第三女神
     * 方法重载
     *
     * @param args
     */
    public static void main(String[] args) {

        //调用 方法一
        function("第三女神");

        //调用 方法二
        function(26);

        //调用 方法三
        function("第三女神", 26);

    }

    /**
     * 方法一
     *
     * @param text
     */
    private static void function(String text) {
        System.out.println("方法一：" + text);
    }

    /**
     * 方法二
     *
     * @param number
     */
    private static void function(int number) {
        System.out.println("方法二：" + number);
    }

    /**
     * 方法三
     *
     * @param text
     * @param number
     */
    private static void function(String text, int number) {
        System.out.println("方法三：" + text + "，" + number);
    }
}

输出：


从上边代码中可以看到，三个一样的方法名 function 方法，从个数和类型上是不一样的，这样就构成了方法重载的条件，在Main中调用，只需要传入对应类型和个数的即可，就分别调用了三种方法！

如果被重载的方法里包含了个数可变的形参数呢？
public class Main {

    /**
     * CSDN第三女神
     * 方法重载
     *
     * @param args
     */
    public static void main(String[] args) {

        //调用 方法一
        function("第三女神");

        //调用 方法二
        function(new String[]{"第三女神，珠穆朗玛"});
        
    }

    /**
     * 方法一
     *
     * @param text
     */
    private static void function(String text) {
        System.out.println("方法一：" + text);
    }

    /**
     * 方法二
     *
     * @param text
     */
    private static void function(String... text) {
        System.out.println("执行方法二：参数可变");
    }
}

运行效果：



方法二的参数，他就是数组，符合了参数名相同，类型不同。方法一参数是String类型，方法二形参即是String数组！一个是String类型，一个是数组，当然可以重载！

大部分时候并不推荐重载形参个数可变的方法，第一，没有太大的意义，第二，容易降低程序的可读性！
其它
下一期 Java成员变量和局部变量

文章目录
1 方法重载
2 方法覆写
3 方法重载与方法覆写的区别
3.1 概念上
3.2 范围上
3.3 限制

1 方法重载
概念： 方法名称相同，参数的个数或类型不同。
public class Test{
    public static int add(int a,int b)
    {
        return a+b;
    }
    public static int add(int a,int b,int c)
    {
        return a+b+c;
    }
    public static double add(double a,double b)
    {
        return a+b;
    }
    public static void main(String[] args)
    {

        System.out.println(add(1,2));
        System.out.println(add(1,2,3));
        System.out.println(add(1.0,2.0));
    }
}



不能有两个名字相同，参数类型也相同却返回值不同的方法

  public  int add(int a,int b)
    {
        return a+b;
    }
    public String add(int a,int b)
    {
        return " ";
    }



构造方法的重载： 由于同一个类中不可能有两个属性，名称相同，类型不同所以构造方法的重载只能是参数的个数不同。
2 方法覆写
概念： 子类定义了与父类方法名称，返回值类型、参数类型及个数完全相同的方法。
class Person {
    public void fun()
    {
        System.out.println("好好学习。");
    }
}
class Student extends Person{
    //方法覆写
    public void fun()
    {
        System.out.println("天天向上。");
    }
}

  在进行覆写操作时应当关注以下两点：

你当前使用的对象是通过哪个类new的。
当你调用某个方法，如果该方法已经被子类所覆写了，那么调用的一定就是被覆写过的方法。

class Person {
    public void f()
    {
        this.fun();
    }
    public void fun()
    {
        System.out.println("好好学习。");
    }
}
class Student extends Person{
    //方法覆写
    public void fun()
    {
        System.out.println("天天向上。");
    }
}
public class Test2{
    public static void main(String[] args)
    {
        Student student=new Student();
        student.f();
    }
}



被覆写不能够拥有比父类更为严格的控制权限。


public>default（不加任何说明 包访问权限）>private（只能在本类中使用） 即如果父类使用public进行声明，那么子类必须也使用public，如果父类使用default，那么子类可以使用public或者default。
范例：错误的方法覆写：
class Person {
    public void fun()
    {
        System.out.println("好好学习。");
    }
}
class Student extends Person{
    //方法覆写
    void fun()
    {
        System.out.println("天天向上。");
    }
}



问题：父类方法用private定义，子类中使用public定义，可以吗？？

class Person {
    public void f()
    {
        this.fun();
    }
    private void fun()
    {
        System.out.println("好好学习。");
    }
}
class Student extends Person{
    //方法覆写
    public void fun()
    {
        System.out.println("天天向上。");
    }
}
public class Test2{
    public static void main(String[] args)
    {
        Student student=new Student();
        student.f();
    }
}



学生类调用f方法，f方法调用fun方法，如果fun被覆写，就应该执行子类Student的fun方法，但是却执行的是父类的fun方法，可见fun没有被子类覆写。所以  方法覆写不能出现private关键字
如果父类方法使用了private定义，那么就表示该方法只能被父类使用，子类无法使用。换言之，子类根本就不知道父类有这样的方法。这个时候子类的方法只是子类定义的新方法而已，和父类没有任何关系。所以
3 方法重载与方法覆写的区别
3.1 概念上
方法重载： 方法名称相同，参数的个数及类型不同。

方法覆写： 方法名称，返回值类型，参数的个数，参数的类型均相同。
3.2 范围上
方法重载：一个类。

方法覆写：继承关系。
3.3 限制
方法重载：无权限要求。

方法覆写：被覆写的方法不能拥有比父类更严格的访问控制权限。

在Java中，同一个类中的多个方法可以有相同的方法名称，但是有不同的参数列表，这就称为方法重载（method overloading）。
参数列表又叫参数签名，包括参数的类型、参数的个数、参数的顺序，只要有一个不同就叫做参数列表不同。
重载是面向对象的一个基本特性。
public class Demo {

	//一个普通得方法，不带参数，无返回值
	public void add(){
		//method body
	}
	
	//重载上面的方法，并且带了一个整形参数，无返回值
	public void add(int a){
		//method body
	}
	
        //重载上面的方法，并且带了两个整型参数，返回值为int型
	public int add(int a,int b){
		//method body
		return 0;
	}

}
通过上面的例子，不难看出，重载就是在一个类中，有相同的函数名称，但形参不同的函。重载的结果，可以让一个程序段尽量减少代码和方法的种类。
说明：
参数列表不同包括：个数不同、顺序不同、类型不同。
仅仅参数变量名称不同是不可以的。
跟成员方法一样，构造方法也可以重载。
声明为final的方法不能被重载。
声明为static的方法不能被重载，但是能够被在此声明。
方法的重载的规则：
方法名称必须相同。
参数列表必须不同。
方法的返回类型可以相同也可以不相同。
仅仅返回类型不同不足以称为方法的重载。
方法重载的实现：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错，这叫做重载分辨。