重载方法

重载方法

• 何为重载
  它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。
• 区分重载方法
  每个重载的方法都必须有一个独一无二的参数类型的列表。甚至参数类型的不同也可以区分两个方法，但是这样会使代码难以维护。
• 涉及基本类型的重载
  基本类型能从一个“较小”的类型自动提升至一个“较大”的类型，此过程一旦牵涉到重载，可能会造成混淆。这里有个代码可以发现：

public class PrimitiveOverloading {
         void prt(String s) {
            System.out.print(s);
        }
        void f1(char x) {
            prt("f1(char)");
        }
        void f1(byte x) {
            prt("f1(byte)");
        }
        void f1(short x) {
            prt("f1(short)");
        }
        void f1(int x) {
            prt("f1(int)");
        }
        void f1(long x) {
            prt("f1(long)");
        }

        void f1(float x) {
            prt("f1(float)");
        }

        void f1(double x) {
            prt("f1(double)");
        }

        void f2(byte x) {
            prt("f2(byte)");
        }

        void f2(short x) {
            prt("f2(short)");
        }

        void f2(int x) {
            prt("f2(int)");
        }

        void f2(long x) {
            prt("f2(long)");
        }

        void f2(float x) {
            prt("f2(float)");
        }

        void f2(double x) {
            prt("f2(double)");
        }

        void f3(short x) {
            prt("f3(short)");
        }

        void f3(int x) {
            prt("f3(int)");
        }

        void f3(long x) {
            prt("f3(long)");
        }

        void f3(float x) {
            prt("f3(float)");
        }

        void f3(double x) {
            prt("f3(double)");
        }

        void f4(int x) {
            prt("f4(int)");
        }

        void f4(long x) {
            prt("f4(long)");
        }

        void f4(float x) {
            prt("f4(float)");
        }

        void f4(double x) {
            prt("f4(double)");
        }

        void f5(long x) {
            prt("f5(long)");
        }

        void f5(float x) {
            prt("f5(float)");
        }

        void f5(double x) {
            prt("f5(double)");
        }

        void f6(float x) {
            prt("f6(float)");
        }

        void f6(double x) {
            prt("f6(double)");
        }

        void f7(double x) {
            prt("f7(double)");
        }

        void testConstVal() {
            prt("Testing with 5");
            f1(5);f2(5);f3(5);f4(5);f5(5);f6(5);f7(5);
        }

        void testChar() {
            char x = 'x';
            prt("char argument:");
            f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); 
        }

        void testByte() {
            byte x = 0;
            prt("byte argument:");
            f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); 
        }

        void testShort() {
            short x = 0;
            prt("short argument:");
            f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); 
        }

        void testInt() {
            int x = 0;
            prt("int argument:");
            f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); 
        }

        void testLong() {
            long x = 0;
            prt("long argument:");
            f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); 
        }

        void testFloat() { 
        float x = 0; 

        prt("float argument:"); 
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); 
        }

        void testDouble() {
            double x = 0;
            prt("double argument:");
            f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
        }

public static void main(String[] args) {
            PrimitiveOverloading p = new PrimitiveOverloading();
            p.testConstVal();System.out.println();
            p.testChar();   System.out.println();
            p.testByte();   System.out.println();
            p.testShort();  System.out.println();
            p.testInt();    System.out.println();
            p.testLong();   System.out.println();
            p.testFloat();  System.out.println();
            p.testDouble(); System.out.println();
        }
}

运行结果

若观察这个程序的输出，就会发现常数值 5 被当作一个 int 值处理。所以假若可以使用一个重载的方法，就能获取它使用的int 值。在其他所有情况下，若我们的数据类型“小于”方法中使用的自变量，就会对那种 数据类型进行“转型”处理。char 获得的效果稍有些不同，这是由于如果它没有发现一个准确的 char匹配，就会转型为int。
如果传入的实际参数大于重载方法声明的形式参数：用代码测试一次：

  void testDouble() { 
    double x = 0; 
    prt("double argument:"); 
    f1(x);f2((float)x);f3((long)x);f4((int)x); 
    f5((short)x);f6((byte)x);f7((char)x); 
    } 

运行结果

在这里，方法采用了容量更小、范围更窄的主类型值。若我们的自变量范围比它宽，就必须用括号中的类型名将其转为适当的类型。如果不这样做，编译器会报告出错。 大家可注意到这是一种“缩小转换”。也就是说，在造型或转型过程中可能丢失一些信息。这正是编译器强 迫我们明确定义的原因——我们需明确表达想要转型的愿望。