方法重载

1、方法重载

/*
	方法重载
	我们将名字相同，参数列表不同的两个（或多个）方法
	称为重载方法。
	参数列表的不同体现在以下两点：
	1 参数的类型不同
	2 参数的个数不同

	方法参数列表的不同，是编译器用来区分调用哪一个
	重载方法的依据。
*/

public class Overload {
	public void f(int x) {
		System.out.println("f(int x)");
	}

	public void f(float a) {
		System.out.println("f(float a)");
	}

	public void g() {
		System.out.println("g()");
	}

	public void g(int x)  {
		System.out.println("g(int x)");
	}

	public void g(int x, int y) {
		System.out.println("g(int x, int y)");
	}

	public static void main(String[] args) {
		Overload o = new Overload();
		int r = 1;
		float t = 1.0f;
		//调用f(int x)方法
		o.f(r);
		//调用f(float a)方法
		o.f(t);
		//调用g()方法
		o.g();
		//调用g(int x)方法
		o.g(r);
		//调用g(int x, int y)方法
		o.g(r, r);
	}
}

　　

/*
	以下条件不同，是否构成方法重载：
	1 参数名字的不同
	2 方法的返回类型不同
*/

public class Overload2 {
	/*
	仅参数名字不同的方法，不能构成重载。
	public void f(int a) {

	}

	public void f(int b) {

	}
	*/

	/*
	仅方法返回类型不同，不能构成重载。
	因为我们在调用方法时，可以忽略返回值。
	public int g() {
		return 5;
	}

	public String g() {
		return "";
	}

	public byte g() {
		return (byte)5;
	}
	*/
	public static void main(String[] args) {
		Overload2 o = new Overload2();
		//o.f(5);
		//int x = o.g();
		//String s = o.g();
		//double d = o.g();
		//o.g();
	}
}

　　2、重载方法

/*
	重载方法：
	声明原则：我们应该将功能相似的两个（或多个）
	方法声明为重载方法。而不应该将功能不相关的
	两个（或多个）方法声明为重载方法。因为这样会
	带来混淆。

	实现原则：因为重载方法具有功能上的相似性，
	因此，重载方法的代码也会有很大的相似性，此时，
	很可能会出现重复的代码。所以，我们应该考虑
	一个重载方法使用另外一个重载方法来实现，而不是
	每个重载方法都有各自的实现。

	调用原则：参数少的方法调用参数多的方法。
*/
public class Overload3 {
	/*
	非常不合适
	public void operation(int a, int b) {
		//相加操作
		int sum = a + b;
	}

	public void operation() {
		System.out.println("输出操作");
	}
	*/

	//标准格式*输出
	public void printStar() {
		/*for (int i = 1; i <= 5; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print("*");
			}
			System.out.println();
		}*/
		printStar(5);
	}

	public void printStar(int row) {
		for (int i = 1; i <= row; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
		
	}
}

　　3、构造器 

/*
	构造器
	声明：
	构造器与类名相同，并且没有返回类型（没有返回类型与
	返回类型是void不同）。访问权限与参数列表与普通方法
	相同，没有限制。

	构造器会在创建对象时，由系统自动调用。

	默认的构造器
	当类中没有显式的声明构造器时，编译器会为该类自动
	生成一个默认的构造器。默认的构造器访问权限与
	类的访问权限相同，参数列表为空。

	如果我们显式的声明了构造器，不论我们声明的构造器
	是否含有参数，默认的构造器都将不复存在。
*/
public class Cons {
	int x;
	int y;
	int z;

	//构造器
	/*public Cons() {
		//System.out.println("构造器执行了。");
		x = 1;
		y = 1;
		z = 1;
	}*/

	//含有参数的构造器
	//可以进行更加灵活的初始化。
	public Cons(int x, int y, int z) {
		this.x = x;
		this.y = y;
		this.z = z;
	}

	public static void main(String[] args) {
		/*Cons c = new Cons();
		System.out.println(c.x);
		System.out.println(c.y);
		System.out.println(c.z);*/
		/*c.x = 1;
		c.y = 1;
		c.z = 1;
		Cons c2 = new Cons();
		c2.x = 2;
		c2.y = 2;
		c2.z = 2;*/

		Cons c = new Cons(1, 2, 3);
		Cons c2 = new Cons(4, 5, 6);
	}
}

　　4、构造器重载

/*
	构造器重载
	可以在类中声明多个构造器，因为构造器的名字与
	类名相同，因此，如果声明了多个构造器，则
	多个构造器必然会重载。
	我们可以在类中声明多个构造器，进而可以实现
	多种初始化方式。
*/

public class ConOverload {
	int x;
	int y;
	
	//默认的初始化方式
	public ConOverload() {
		//x = 10;
		//y = 20;
		//错误
		//ConOverload(10, 20);
		this(10, 20);
	}

	//指定初始化方式
	public ConOverload(int x, int y) {
		this.x = x;
		this.y = y;
	}



	public static void main(String[] args) {
		ConOverload c = new ConOverload();
		ConOverlaod c2 = new ConOverload(50, 100);
	}
}

　　5、构造器调用的原则

/*
	构造器调用的原则：
	1 在调用方式上
	需要使用this来调用构造器，而不能通过构造器的
	名字调用构造器。
	2 在调用位置上
	只能在构造器中对构造器进行调用，而不能在构造器
	之外对构造器进行调用。
	3 在语句顺序上
	调用构造器的语句必须是构造器中的第一条语句。

*/

public class ConCall {
	public ConCall() {
		//错误！
		//ConCall(5);
		//System.out.println("abc");
		this(5);
	}

	public void outCon() {
		//错误！
		//this(5);
	}
	/*
	public void ConCall(int x) {

	}
	*/
	public ConCall(int x) {

	}
}

　　6、this的使用

/*
	this的使用：
	1 this指代当前的对象，可以通过this访问
	类中声明的成员。
	2 可以通过this来调用构造器。

	this：this指代当前的对象。
	当前对象：谁调用的该方法（构造器），当前对象
	就是谁。
*/
public class ThisTest {
	int x;

	public ThisTest() {
		//通过this调用构造器。
		this(5);
	}

	public ThisTest(int x) {
		this.x = x;
	}

	public void setX(int x) {
		//通过this访问被局部变量所遮蔽的成员变量。
		this.x = x;
	}

	public void f() {
		this.x = 1;
		this.setX(5);
		x = 1;
		setX(5);
	}
	/*
	public void f(ThisTest this) {
		this.x = 1;
		this.setX(5);
		x = 1;
		setX(5);
	}

	*/

	public static void main(String[] args) {
		ThisTest t = new ThisTest();
		//ThisTest t = new ThisTest(t);
		t.f();
		//t.f(t);
		ThisTest t2 = new ThisTest();
		t2.f();
		//t2.f(t2);
	}
}

　　7、成员变量的初始化

/*
	成员变量的初始化（实例成员变量）
	1 在实例变量声明处初始化
	2 使用初始化块
	3 使用构造器

	三种初始化的顺序：
	1 实例变量声明处初始化与初始化块按照类中声明
	的顺序执行。
	2 实例变量声明处初始化与初始化块会在构造器之前
	得到执行。
*/

public class Init {
	//在实例变量声明处初始化
	//int x = 1;
	//int x = System.out.println("初始化块1执行");
	int x = initX();

	//初始化块
	{
		//x = 1;
		System.out.println("初始化块1执行");
	}

	//构造器
	public Init() {
		//x = 1;
		System.out.println("构造器执行");
	}

	{
		x = 1;
		System.out.println("初始化块2执行");
	}

	int y = initY();

	public int initX() {
		System.out.println("x声明处初始化执行");
		return 1;
	}

	public int initY() {
		System.out.println("y声明处初始化执行");
		return 1;
	}

	public static void main(String[] args) {
		Init i = new Init();
		//System.out.println(i.x);
	}
}

　　

/*
	声明处初始化与初始化块中的语句会复制到
	每个构造器的最前面。（init）。
	如果构造器中，使用this调用了其他的构造器，
	则不会进行上述的复制。（避免重复的初始化。）
*/

public class Init2 {
	/*
	{
		System.out.println(this.x);
	}
	*/

	//int x = 1;
	int x = initX();
	int y = 2;

	{
		System.out.println("aaa");
	}

	public int initX() {
		System.out.println(y);
		return 1;
	}

	/*public Init2() {
		this(10);
		//System.out.println("bbb");
	}*/

	public Init2(int k) {
		//x = 1;
		//y = 2;
		//System.out.println("aaa");
	}


	public static void main(String[] args) {
		//Init2 i = new Init2();
		new Init2(5);

	}
}

/*
public class Init2 {
	int x;
	int y;
	
	//<init>
	public Init2() {
		System.out.println(x);
		x = 1;
		y = 2;
		System.out.println("aaa");
		System.out.println("bbb");
	}

	public static void main(String[] args) {
		//Init2 i = new Init2();
		new Init2();

	}
}
*/

　　8、可变参数

/*
	可变参数
	可变参数使用...表示，可以接受0个到多个参数。
	可变参数实际上就是一个数组。每个实参都是作为
	数组的一个元素。

	对于main方法的String[] args，实际上就是一个可变
	参数。因此，main方法也可以写成如下形式：
	public static void main(String... args) {

	}

	可变参数的限制：
	可变参数必须作为方法参数列表的最后一个参数。
	这意味着，方法的参数列表最多只能有一个类型
	为可变参数类型。
*/

public class VarArgs {
	public static void main(String... args) {
		VarArgs v = new VarArgs();
		System.out.println(v.add());
		System.out.println(v.add(2));
		System.out.println(v.add(2, 3));
		System.out.println(v.add(2, 3, 4, 5, 6));
	}
	/*
	public int add(int x, int y) {
		return x + y;
	}

	public int add(int x, int y, int z) {
		return x + y + z;
	}
	*/
	public int add(int... x) {
		int sum = 0;
		for (int i : x) {
			sum += i;
		}
		return sum;
	}
	
	/*
	add(1, 2, 3, 4, 5);

	public int add(int... x, int k) {
		//实现
	}

	public int add(int... x, int... y) {

	}

	public int add(int k, int... x) {

	}

	*/
}

　　9、可变参数的重载

/*
	可变参数的重载
	当可变参数参与重载时，可变参数的方法会后考虑，
	这是为了做到对以前程序的兼容。
*/
public class VarOverload {
	public void f(int x) {
		System.out.println("f(int x)");
	}

	public void f(int... x) {
		System.out.println("f(int... x)");
	}

	public static void main(String[] args) {
		VarOverload v = new VarOverload();
		v.f(10);
		v.f();
	}
}