Java学习笔记（this关键字/方法的所属性/方法的所属性/递归/方法重载/方法的参数传递机制）--day_6

【1】this关键字
this 关键字总是指向调用该方法的对象.
1.构造器中引用该构造器执行初始化的对象
2.在方法中引用调用该方法的对象
在方法里的this 指谁调用就指谁
注: this 不能用在有static 修饰的方法中.

public class Apple
{
	public String name;
	public String color;
	public double weight;
	public Apple(){}
	// 两个参数的构造器
	public Apple(String name , String color)
	{
		this.name = name;
		this.color = color;
	}
	// 三个参数的构造器
	public Apple(String name , String color , double weight)
	{
		// 通过this调用另一个重载的构造器的初始化代码
		this(name , color);
		// 下面this引用该构造器正在初始化的Java对象
		this.weight = weight;
	}
}

【2】方法的所属性
一旦将一个方法定义在一个类里,如果用static 修饰了,这个方法属于这个类,否则属于这个类的对象.
方法不能独立执行,必须要有调用者.(如:类.方法、对象.方法)
方法不能独立定义,只能定义在类里.（与函数的区别）。
方法要么属于一个类,要么属于一个对象

【3】方法的所属性
如果在定义方法时,在最后一个参数的类型后增加三点…,则表明该形参接受多个参数值,多个参数值被当成数组传入.
长度可变的形参只能位于最后一个参数,并一个方法里只能有一个可变长度的参数.

public class Varargs
{
	// 定义了形参个数可变的方法
	public static void test(int a , String... books)
	{
		// books被当成数组处理
		for (String tmp : books)
		{
			System.out.println(tmp);
		}
		// 输出整数变量a的值
		System.out.println(a);
	}
	public static void main(String[] args)
	{
		// 调用test方法
		test(5 , "西游记" , "三国演义");
	}
}

【4】递归
递归就是在方法中再次调用自己。
递归一定要向已知方向递归.

public class Recursive
{
	public static int fn(int n)
	{
		if (n == 0)
		{
			return 1;
		}
		else if (n == 1)
		{
			return 4;
		}
		else
		{
			// 方法中调用它自身，就是方法递归
			return 2 * fn(n - 1) + fn(n - 2);
		}
	}
	public static void main(String[] args)
	{
		// 输出fn(10)的结果
		System.out.println(fn(10));
	}
}

【5】方法重载
java 允许在一个类里定义多个同名方法,只要形参列表不同即可.
所以方法的重载只要满足两个条件(两同一不同)：1.同一个类中,方法名相同；2.形参不同。和返回值类型无关.所以在调用这些方法时要传入不同的参数值.

public class Overload
{
	// 下面定义了两个test()方法，但方法的形参列表不同
	// 系统可以区分这两个方法，这种被称为方法重载
	public void test()
	{
		System.out.println("无参数");
	}
	public void test(String msg)
	{
		System.out.println("重载的test方法 " + msg);
	}
	public static void main(String[] args)
	{
		Overload ol = new Overload();
		// 调用test()时没有传入参数，因此系统调用上面没有参数的test()方法。
		ol.test();
		// 调用test()时传入了一个字符串参数，
		// 因此系统调用上面带一个字符串参数的test()方法。
		ol.test("hello");
	}
}

public class OverloadVarargs
{
	public void test(String msg)
	{
		System.out.println("只有一个字符串参数的test方法 ");
	}
	// 因为前面已经有了一个test()方法，test()方法里有一个字符串参数。
	// 此处的个数可变形参里不包含一个字符串参数的形式
	public void test(String... books)
	{
		System.out.println("****形参个数可变的test方法****");
	}
	public static void main(String[] args)
	{
		OverloadVarargs olv = new OverloadVarargs();
		// 下面两次调用将执行第二个test()方法
		olv.test();
		olv.test("aa" , "bb");
		// 下面将执行第一个test()方法
		olv.test("aa");
		// 下面调用将执行第二个test()方法
		olv.test(new String[]{"aa"});
	}
}

【6】方法的参数传递机制
传递方式只有一种:值传递.

public class PrimitiveTransferTest
{
	public static void swap(int a , int b)
	{
		// 下面三行代码实现a、b变量的值交换。
		// 定义一个临时变量来保存a变量的值
		int tmp = a;
		// 把b的值赋给a
		a = b;
		// 把临时变量tmp的值赋给b
		b = tmp;
		System.out.println("swap方法里，a的值是"
			+ a + "；b的值是" + b);
	}
	public static void main(String[] args)
	{
		int a = 6;
		int b = 9;
		swap(a , b);
		System.out.println("交换结束后，变量a的值是"
			+ a + "；变量b的值是" + b);
	}
}

class DataWrap
{
	int a;
	int b;
}
public class ReferenceTransferTest
{
	public static void swap(DataWrap dw)
	{
		// 下面三行代码实现dw的a、b两个成员变量的值交换。
		// 定义一个临时变量来保存dw对象的a成员变量的值
		int tmp = dw.a;
		// 把dw对象的b成员变量值赋给a成员变量
		dw.a = dw.b;
		// 把临时变量tmp的值赋给dw对象的b成员变量
		dw.b = tmp;
		System.out.println("swap方法里，a成员变量的值是"
			+ dw.a + "；b成员变量的值是" + dw.b);
		// 把dw直接赋为null，让它不再指向任何有效地址。
		dw = null;
	}
	public static void main(String[] args)
	{
		DataWrap dw = new DataWrap();
		dw.a = 6;
		dw.b = 9;
		swap(dw);
		System.out.println("交换结束后，a成员变量的值是"
			+ dw.a + "；b成员变量的值是" + dw.b);
	}
}