Java方法重载

方法重载

在一个类中，我们可以定义多个方法。如果有一系列方法，它们的功能都是类似的，只有参数有所不同，那么，可以把这一组方法名做成同名方法。例如，在Hello类中，定义多个hello()方法：

class Hello {
    public void hello() {
        System.out.println("Hello, world!");
    }

    public void hello(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public void hello(String name, int age) {
        if (age < 18) {
            System.out.println("Hi, " + name + "!");
        } else {
            System.out.println("Hello, " + name + "!");
        }
    }
}

这种方法名相同，但各自的参数不同，称为方法重载（Overload）。

注意：方法重载的返回值类型通常都是相同的。

方法重载的目的

方法重载的目的是，功能类似的方法使用同一名字，更容易记住，因此，调用起来更简单。

举个例子，String类提供了多个重载方法indexOf()，可以查找子串：

   int indexOf(int ch)：根据字符的Unicode码查找；

   int indexOf(String str)：根据字符串查找；

   int indexOf(int ch, int fromIndex)：根据字符查找，但指定起始位置；

   int indexOf(String str, int fromIndex)根据字符串查找，但指定起始位置。

试一试：

public class Main {
    public static void main(String[] args) {
        String s = "Test string";
        int n1 = s.indexOf('t');
        int n2 = s.indexOf("st");
        int n3 = s.indexOf("st", 4);
        System.out.println(n1);
        System.out.println(n2);
        System.out.println(n3);
    }
}

区分重载方法的关键因素

参数不同是区分重载方法的关键因素，参数不同主要包括以下方面的不同：

1. 参数类型不同。例如：

public void method(String s);
public void method(int s);

1. 参数个数不同。例如：

public void method(String s,int i);
public void method(String s);

1. 参数顺序不同。例如：

public void method(String s,int i);
public void method(int i,String s);

【注意】

参数顺序不同的情况中一定要注意指的是参数全体，而不是简单的参数名，参数名在参数中其实没有实际意义，只是一个代号。例如：

public void method(String s,int i);
public void method(String i,int s);

上面的例子是不属于顺序不同的，因为只是互换了参数的名字，参数的类型并没有互换。

【实例5-1】

public class Overload {
	public static void main(String[] args) {
		getSum(1, 1);//一
		getSum(2.1,2.2);//二
		getSum(3.1,3);//三
		getSum(4,4.4);//四
		getSum(5,5,5);//五
	}
	//求和 2个数的和
		public static void getSum(int a,int b){//一:求两个int类型的和
			System.out.println("int a,int b");
			System.out.println(a+b);
		}
		
		public static void getSum(double a,double b){//二:求两个double类型的和
			System.out.println("double a,double b");
			System.out.println(a+b);
		}
		public static void getSum(double a,int b){//三:求一个double和一个int类型的和
			System.out.println("double a,int b");
			System.out.println(a+b);
		}
		
		public static void getSum(int a,double b){//四:求一个int和一个double类型的和
			System.out.println("int a,double b");
			System.out.println(a+b);
		}
		public static void getSum(int a,int b,int c){//五:求三个int类型的和
			System.out.println("int a,int b,int c");
			System.out.println(a+b+c);
		}
}
3

可以发现方法重载主要目的是为了满足在不同输入的情况下依然可以得到进行相同或相似的处理。在编程上有些麻烦，但是在使用性和灵活性得到了加强。由于实现了Java在编译时的方法的多种状态，所以有时也成为静态多态。

练一练：为showInfo方法实现重载

下面代码中的showInfo( )函数就实现了 方法的重载。

public class Store {
	private  Noodles [] nset;
	private int num ;
	
	public Store() {
		num = 3;
		nset =  new Noodles[num];
        nset[0]= new Noodles("山西刀削面",105.0f,30);
        nset[1]= new Noodles("兰州牛肉面",15.0f,20);
        nset[2]= new Noodles("北京炸酱面",12.0f,30);
	}
	public int getNum() {
		return this.num;
	}
	
	public void  getSet() {
		for(int i=0;i<nset.length;i++) {
        	System.out.println(nset[i].toString());
        }
	}

	public String showInfo() {
		String total="";
		for(int i=0;i<nset.length;i++) {
        	total +=nset[i].toString()+"\n";
        }
		return total;
	}
	public String showInfo(String name) {
		String s="暂无商品信息";
		for(int i=0;i<this.nset.length;i++){
    		if (this.nset[i].getName().equals(name)) {
    			s = this.nset[i].toString();
    		}
    	}
		return s;
	}
	public String toString() {
		String total="";
		for(int i=0;i<nset.length;i++) {
        	total +=nset[i].toString()+"\n";
        }
		return total;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Store s = new Store();    
		System.out.println("仓库的商品总数为："+s.getNum());
		System.out.println("以下为商品详情信息：");
		System.out.println(s.showInfo());
		System.out.println("查找山西刀削面：");
		System.out.println(s.showInfo("山西刀削面"));      
        
        
	}

}

构造方法的重载

在Java里，不仅普通方法可以重载，构造方法也可以重载。构造方法的重载是为了让实例化对象和初始化变量更为方便。

【实例5-2】利用构造函数重载创建对不同变量初始化的对象

public class Rectangle {
	  double width; 
	  double length;
	  Rectangle (){ //直接初始化为数值
		width = 1;
	   	length=5;
	  }
  Rectangle (double x){//把两个变量初始化为相同传入值
	    width = x;
length =x;
	  }
  Rectangle (double w,double len) {//分别对两个属性初始化不同的值
   	width = w;
   	length=len;
	  }
	  public void prnt(){
	    //省略方法体;
}
}
public class ConstructOverLoad {
	  public static void main(String args[]) {
	Rectangle Rectangle1 = new Rectangle (10,20);
	Rectangle Rectangle2 = new Rectangle ();
Rectangle Rectangle3 = new Rectangle(7);
		//省略其他语句
	  }
}

在实例中有三个Rectangle ()构造函数，当new执行时根据指定的参数多少调用适当的构造函数。