JAVA编程思想学习笔记（二）---方法重载

        在日常生活中，相同的词可以表达多种不同的含义，特别是含义之间的差别很小时，这种方式十分有用，你可以说“清洗衬衫”，“清洗车”，“清洗狗”等等，这就相当于我们在程序中定义了一个方法名“清洗”，我们可以传入不同的对象“衬衫”，“车”，“狗”等，而不是定义三个方法名“清洗衬衫”，“清洗车”，“清洗狗”，这样会显得很冗余。

        大多数程序语言（例如C）要求每个方法都会提供一个独一无二的标识符，例如我们定义一个print()方法函数显示整数之后，绝对不可以再用一个名字为print()的函数来显示一个浮点数。

        而在java或者C++里面，构造器是强制重载方法名的另一个原因，因为构造器的名字已经由类名决定，就只能有一个构造器名字，那么如果想用多种方式创建一个对象怎么办？

        假设你要创建一个类，既可以用标准方式进行初始化，也可以从文件中读取信息来初始化。这就需要两个构造器：一个是默认构造器，另一个取字符串作为形式参数。由于都是构造器，都需要跟类名一致，所以必须有相同的名字，为了让方法名相同而参数不同的构造器同时存在，必须用到方法重载。

class Tree {
    int height = 5;
    public Tree() { //默认的构造方法
        System.out.println("Tree default height:" + height);
    }
    public Tree(int height) {   //指定树高度的构造方法
        this.height = height;
        System.out.println("Tree height:" + height);
    }
}

        创建Tree对象的时候，既可以没有参数，也可以用树的高度当参数，要支持这种创建方式，得有一个默认构造器和一个采用现有高度作为参数的构造器。

区分重载方法

        要是有几个方法有相同的名字，java如何才能知道你指的是哪一个呢？其实很简单，每个重载的方法都必须有一个独一无二的参数类型列表。
        参数顺序不同也能够区分两个不同方法。不过，这种方式不推荐，这样会使代码难以维护。

class Test {    
    public void show(int i, String s) {
        System.out.println("ok1");
    }
    public void show(String s, int i) {
        System.out.println("ok2");
    }

    public static void main(String[] args) {
        new Test().show(2, "s");
    }
}

涉及基本数据类型的重载

class Test {    
    public void show(char c) {
        System.out.println("(char):" + c);
    }
    public void show(byte b) {
        System.out.println("(byte):" + b);
    }
    public void show(short s) {
        System.out.println("(short):" + s);
    }
    public void show(int i) {
        System.out.println("(int):" + i);
    }
    public void show(long l) {
        System.out.println("(long):" + l);
    }
    public void show(float f) {
        System.out.println("(float):" + f);
    }   
    public void show(double d) {
        System.out.println("(double):" + d);
    }
}

假设现在我写下面的测试方法：

public class Client {
    public static void main(String[] args) {
        Test t = new Test();
        t.show(5);
    }
}

输出的结果会是：

(int):5

        这是因为java会将5当做int值来处理，所以当某个重载的方法接受int型参数，就会被调用，如果传入的数据类型（实际参数类型）小于方法中声明的形式参数类型，实际数据类型就会被提升(byte->short->int->long->float->double)，char类型略有不同，如果无法找到恰好接受char参数的方法，就会把char直接提升到int型（char->int->long->float->double）,例如：

class Test {    
    public void show(long l) {
        System.out.println("(long):" + l);
    }
    public void show(float f) {
        System.out.println("(float):" + f);
    }   
    public void show(double d) {
        System.out.println("(double):" + d);
    }
}

public class Client {
    public static void main(String[] args) {
        Test t = new Test();
        t.show(5);
    }
}

输出：

(long):5

char举例：

class Test {    
    public void show(byte b) {
        System.out.println("(byte):" + b);
    }
    public void show(short s) {
        System.out.println("(short):" + s);
    }
    public void show(int i) {
        System.out.println("(int):" + i);
    }
    public void show(long l) {
        System.out.println("(long):" + l);
    }
    public void show(float f) {
        System.out.println("(float):" + f);
    }   
    public void show(double d) {
        System.out.println("(double):" + d);
    }
}

public class Client {
    public static void main(String[] args) {
        Test t = new Test();
        char c = 'x';
        t.show(c);
    }
}

输出：

(int):120

如果传入的实际参数较大，必须进行强制类型转换，不然会出错。