Java支持方法重載的原因

更新時間：2021年06月15日 11:30:05 作者：JavaEdge.

今天給大家?guī)淼氖顷P于Java的相關知識,文章圍繞著Java方法重載展開,文中有非常詳細的介紹及代碼示例,需要的朋友可以參考下

Java為什么要支持方法重載

為什么要使用重載？而不是把一個方法名字換成不同的。

任何編程語言中都具備的一項重要特性就是名稱。當你創(chuàng)建一個對象時，就會給此對象分配的內(nèi)存空間一個名稱。一個方法就是一種行為的名稱。通過名稱引用所各種對象，屬性和方法。良好的命名可以讓系統(tǒng)易于理解和修改。

將人類語言細微的差別映射到編程語言中會產(chǎn)生一個問題。通常，相同的詞可以表達多種不同的含義——它們被"重載"了。特別是當含義的差別很小時，這會更加有用。

你會說"清洗襯衫"、“清洗車"和"清洗狗”。而如果硬要這么說就會顯得很愚蠢：“以洗襯衫的方式洗襯衫”、“以洗車的方式洗車"和"以洗狗的方式洗狗”，因為聽眾根本不需要區(qū)分行為的動作。大多數(shù)人類語言都具有"冗余"性，所以即使漏掉幾個詞，你也能明白含義。你不需要對每個概念都使用不同的詞匯——可以從上下文推斷出含義。

大多數(shù)編程語言（尤其是 C）要求為每個方法（在這些語言中經(jīng)常稱為函數(shù)）提供一個獨一無二的標識符。所以，你不能有一個 print() 函數(shù)既能打印整型，也能打印浮點型——每個函數(shù)名都必須不同。

但在 Java (C++) 中，還有一個因素也促使了必須使用方法重載：構造器。因為構造器方法名肯定與類名相同，所以一個類中只會有一個構造器名。
那么你怎么通過不同方式創(chuàng)建一個對象？例如，你想創(chuàng)建一個類，這個類的初始化方式有兩種：一種是標準化方式，另一種是從文件中讀取信息的方式。你需要兩個構造器：無參構造器和有一個 String 類型參數(shù)的構造器，該參數(shù)傳入文件名。兩個構造器具有相同的名字——與類名相同。因此，方法重載是必要的，它允許方法具有相同的方法名但接收的參數(shù)不同。盡管方法重載對于構造器很重要，但也可以對任何方法很方便地進行重載。

重載構造器和方法：

class Tree {
    int height;
    Tree() {
        System.out.println("Planting a seedling");
        height = 0;
    }
    Tree(int initialHeight) {
        height = initialHeight;
        System.out.println("Creating new Tree that is " + height + " feet tall");
    }
    void info() {
        System.out.println("Tree is " + height + " feet tall");
    }
    void info(String s) {
        System.out.println(s + ": Tree is " + height + " feet tall");
    }
}

public class Overloading {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Tree t = new Tree(i);
            t.info();
            t.info("overloaded method");
        }
        new Tree(); 
    }
}

一個 Tree 對象既可以是一顆樹苗，使用無參構造器，也可以是一顆在溫室中已長大的樹，已經(jīng)有一定高度，這就需要有參構造器。

你也許想以多種方式調(diào)用 info()。比如，如果你想打印額外的消息，就可以使用 info(String) 方法。若你無話可說，就可以使用 info() 方法。用兩個命名定義完全相同的概念看起來很奇怪，而使用方法重載，你就可以使用一個命名來定義一個概念。

區(qū)分重載方法

如果兩個方法命名相同，Java是怎么知道你調(diào)用的是哪個呢？
有一條簡單的規(guī)則：每個被重載的方法必須有獨一無二的參數(shù)列表。

除了通過參數(shù)列表的不同來區(qū)分兩個相同命名的方法，其他也沒什么方式了。你甚至可以根據(jù)參數(shù)列表中的參數(shù)順序來區(qū)分不同的方法，盡管這會造成代碼難以維護。

重載與基本類型

基本類型可以自動從小類型轉為大類型。當這與重載結合時，這會令人有點困惑：

public class PrimitiveOverloading {
    void f1(char x) {
        System.out.print("f1(char)");
    }
    void f1(byte x) {
        System.out.print("f1(byte)");
    }
    void f1(short x) {
        System.out.print("f1(short)");
    }
    void f1(int x) {
        System.out.print("f1(int)");
    }
    void f1(long x) {
        System.out.print("f1(long)");
    }
    void f1(float x) {
        System.out.print("f1(float)");
    }
    void f1(double x) {
        System.out.print("f1(double)");
    }
    void f2(byte x) {
        System.out.print("f2(byte)");
    }
    void f2(short x) {
        System.out.print("f2(short)");
    }
    void f2(int x) {
        System.out.print("f2(int)");
    }
    void f2(long x) {
        System.out.print("f2(long)");
    }
    void f2(float x) {
        System.out.print("f2(float)");
    }
    void f2(double x) {
        System.out.print("f2(double)");
    }
    void f3(short x) {
        System.out.print("f3(short)");
    }
    void f3(int x) {
        System.out.print("f3(int)");
    }
    void f3(long x) {
        System.out.print("f3(long)");
    }
    void f3(float x) {
        System.out.print("f3(float)");
    }
    void f3(double x) {
        System.out.print("f3(double)");
    }
    void f4(int x) {
        System.out.print("f4(int)");
    }
    void f4(long x) {
        System.out.print("f4(long)");
    }
    void f4(float x) {
        System.out.print("f4(float)");
    }
    void f4(double x) {
        System.out.print("f4(double)");
    }
    void f5(long x) {
        System.out.print("f5(long)");
    }
    void f5(float x) {
        System.out.print("f5(float)");
    }
    void f5(double x) {
        System.out.print("f5(double)");
    }
    void f6(float x) {
        System.out.print("f6(float)");
    }
    void f6(double x) {
        System.out.print("f6(double)");
    }
    void f7(double x) {
        System.out.print("f7(double)");
    }
    void testConstVal() {
        System.out.print("5: ");
        f1(5);f2(5);f3(5);f4(5);f5(5);f6(5);f7(5);
        System.out.println();
    }
    void testChar() {
        char x = 'x';
        System.out.print("char: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
        System.out.println();
    }
    void testByte() {
        byte x = 0;
        System.out.print("byte: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
        System.out.println();
    }
    void testShort() {
        short x = 0;
        System.out.print("short: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
        System.out.println();
    }
    void testInt() {
        int x = 0;
        System.out.print("int: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
        System.out.println();
    }
    void testLong() {
        long x = 0;
        System.out.print("long: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
        System.out.println();
    }
    void testFloat() {
        float x = 0;
        System.out.print("float: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
        System.out.println();
    }
    void testDouble() {
        double x = 0;
        System.out.print("double: ");
        f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
        System.out.println();
    }

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

輸出：

5: f1(int)f2(int)f3(int)f4(int)f5(long)f6(float)f7(double)
char: f1(char)f2(int)f3(int)f4(int)f5(long)f6(float)f7(double)
byte: f1(byte)f2(byte)f3(short)f4(int)f5(long)f6(float)f7(double)
short: f1(short)f2(short)f3(short)f4(int)f5(long)f6(float)f7(double)
int: f1(int)f2(int)f3(int)f4(int)f5(long)f6(float)f7(double)
long: f1(long)f2(long)f3(long)f4(long)f5(long)f6(float)f7(double)
float: f1(float)f2(float)f3(float)f4(float)f5(float)f6(float)f7(double)
double: f1(double)f2(double)f3(double)f4(double)f5(double)f6(double)f7(double)

若傳入的參數(shù)類型大于方法期望接收的參數(shù)類型，你必須首先做縮窄轉換，否則編譯器就會報錯。

返回值的重載

經(jīng)常會有人困惑，“為什么只能通過類名和參數(shù)列表，不能通過方法的返回值區(qū)分方法呢?”。例如以下兩個方法，它們有相同的命名和參數(shù)，但是很容易區(qū)分：

void f(){}
int f() {return 1;}

有些情況下，編譯器很容易就可以從上下文準確推斷出該調(diào)用哪個方法，如 int x = f()。

但是，你可以調(diào)用一個方法且忽略返回值。這叫做調(diào)用一個函數(shù)的副作用，因為你不在乎返回值，只是想利用方法做些事。所以如果你直接調(diào)用 f()，Java 編譯器就不知道你想調(diào)用哪個方法，閱讀者也不明所以。因為這個原因，所以你不能根據(jù)返回值類型區(qū)分重載的方法。為了支持新特性，Java 8 在一些具體情形下提高了猜測的準確度，但是通常來說并不起作用。

到此這篇關于Java支持方法重載的原因的文章就介紹到這了,更多相關Java方法重載內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: