方法重载

案例1：

/*
    方法重载机制？
        1 以下程序先不使用方法重载机制，分析程序的缺点？？？
            以下程序没有语法错误，运行也是正常的，你就分析一下代码风格存在什么缺点！
            
            缺点包括两个：
                1 代码不美观（不好看、不整齐），[这是次要的]
                2 程序员需要记忆更多的方法名称，程序员比较累。
*/
public class OverloadTest01{
    public static void main(String[] args){
        
        System.out.println(sumInt(10,20));
        System.out.println(sumLong(20,30));
        System.out.println(sumDouble(11.1,22.2));
    }
    // 定义一个计算int类型数据的求和方法
    public static int sumInt(int a,int b){
        return a + b;
    }
    // 定义一个计算long类型数据的求和方法
    public static long sumLong(long a, long b){
        return a + b;
    }
    // 定义一个计算double类型数据的求和方法
    public static double sumDouble(double a,double b){
        return a + b;
    }
}

案例2：

/*
    使用方法重载机制。解决之前的两个缺点。
    优点1：代码整齐美观。
    优点2：“功能相似”的，可以让“方法名”相同，更易于以后的代码编写。
    
    在java语言中，是怎么进行方法区分的呢？
        首先java编译器会通过方法名进行区分。
        但是在java语言中允许方法名相同的情况出现。
        如果方法名相同的情况下，编译器会通过方法的参数类型进行方法的区分。
*/
public class OverloadTest02{
    public static void main(String[] args){
        // 对于程序员来说，只需要记忆一个方法名即可。
        System.out.println(sum(10,20));
        System.out.println(sum(100L,200L));
        System.out.println(sum(11.1,22.1));
    }
    // 定义一个计算int类型数据的求和方法
    public static int sum(int a,int b){
        System.out.println("int求和");
        return a + b;
    }
    // 定义一个计算long类型数据的求和方法
    public static long sum(long a, long b){
        System.out.println("long求和");
        return a + b;
    }
    // 定义一个计算double类型数据的求和方法
    public static double sum(double a,double b){
        System.out.println("double求和");
        return a + b;
    }
}

案例3：

/*
    方法重载（Overload）
    1 什么时候需要考虑使用方法重载？
        在同一个类当中，如果“功能1”和“功能2”他们的功能是相似的。
        那么可以考虑讲他们的方法名一直，这样代码既美观，又便于后期的代码编写（容易记忆，方便使用）。
        
        注意:方法重载overload不能随便使用。
        如果两个功能压根不相干，不相似，根本没关系，此时两个方法使用重载机制的话，会导致编码更麻烦。
        无法进行方法功能的区分
        
    2 什么时候代码会发生方法重载？
        1 在同一个类当中
        2 方法名相同
        3 参数列表不同
                参数的个数不同算不同
                参数的类型不同算不同
                参数的顺序不同算不同
        只要同时满足以上三个条件，那么我们可以认定方法和方法之间发生了重载机制。
        
        注意：
            不管代码怎么写，最终一定能让java编译器很好的区分开这两个方法。
            
                方法重载和方法的返回值无关。
                返回值类型如果不一样的话，JVM是不会去区分的。这个时候就会报错。方法名和形式参数不一样的才是方法重载。
                和返回值类型无关。返回值类型(void int String)
                和修饰符列表无关。修饰符列表(public static)
    
*/
public class OverloadTest03{
    public static void main(String[] args){
        m1();
        m1(100);
        m2(11.1,10);
        m2(10,11.1);
        m3(100);
        m3(3.14);
        
    }
    
    public static void m1(){
        System.out.println("m1无参数的执行");
    }
    
    // 这个方法的参数个数和上面的方法的参数个数不同
    public static void m1(int a){
        System.out.println("m1有一个int参数执行!");
    }
    
    public static void m2(int x,double y){
        System.out.println("m2(int x,double y)");
    }
    // 参数的顺序不同，也算不同。
    public static void m2(double y,int x){
        System.out.println("m2(double y,int x)");
    }
    
    public static void m3(int a){
        System.out.println("m3(int a)");
    }
    
    public static void m3(double b){
        System.out.println("m3(double b)");
    }
    
    //错误: 已在类 OverloadTest03中定义了方法 m4(int,int)
    // 编译器报错，这不是重载，这是重复。呵呵
    /*public static void m4(int a,int b){
    
    }
    
    public static void m4(int x, int y){
    
    }*/
    
    // 这两个方法有没有发生重载呢？
    // 这不是重载，这是方法重复了。
    // 错误: 已在类 OverloadTest03中定义了方法 m5()
    // 根据方法名和形参判断方法是否重载。
    /*public static int m5(){
        return 1;
    }
    
    public static double m5(){
        return 1.1;
    }*/
    
    // 这两个方法重载了吗？
    // 这个方法没有修饰符列表
    // 错误: 已在类 OverloadTest03中定义了方法 m6()
    /*public static void m6(){
    
    }
    
    void m6(){
        
    }*/
    
}

class Myclass{
    // 不在同一个类当中，不能叫做方法重载
    public static void m1(int x,int y){
        
    }
}

案例4：

public static OverloadTest04{
    public static void main(String[] args){
        // 大家是否承认：printin是一个方法名。
        // println我承认是方法名了，但是这个方法是谁写的？SUN公司的java团队写的。
        // 你直接用就行。
        // println()方法肯定是重载了。（不信，你可以翻阅一下SUN公司写的源代码看看。）
        // 对于println（）方法来说，我们只需要记忆这一个方法名就行。
        // 参数类型可以随便传。这说明println()方法重载了。
        System.out.println(10);
        System.out.println(3.14);
        System.out.println(true);
        System.out.println('a');
        System.out.println("abc");
        
        // 调用m方法
        m(100);
    }
    
    public static void m(int i){
        
    }
}