3.4 类的成员之二：方法（JAVASE Chapter3 面向对象）

① 语法格式

public class Person {
	private int age;
	public int getAge() {
		return age;
	}//声明方法getAge
	public void setAge(int i) {
		age = i;
	}//声明方法setAge，将参数i的值赋给类的成员变量age
}

② 对象的创建和使用

//一个类可以实例化出多个对象，且对象与对象之间是互不干扰的
		Person p1 = new Person();
		Person p2 = new Person();
		p1.name="Make";
		p2.name="Lisa";
		p1.showName();
		p2.showName();

Ⅱ method

① 什么是方法

②方法的调用

{
		TestNew tn = new TestNew();
		int area=tn.getArea(2, 3);
		System.out.println(area);
		}
	public int getArea(int x, int y) {
		return x*y;
		}

Ⅲ 关于对象

① 对象的产生

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。
（除了基本数据类型之外的变量类型都是引用类型。）

② 匿名对象

③ 类的访问机制

④ 面向对象“落地”法则

Ⅳ 方法的重载

重载的特点

编写程序，定义三个重载方法并调用。方法名为mOL

• 三个方法分别接受一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果、相乘并输出结果、输出字符串信息。
• 在main方法的主类里分别用参数区别调用三个方法

public class Test {
	public static void main(String[]args) {
		Test t = new Test();
		t.mOL(4);
		t.mOL("wsmd");
		t.mOL(2, 35);
	}
	public void mOL(int i) {
		System.out.println(i*i);
	}
	public void mOL(int i, int j) {
		System.out.println(i*j);
	}
	public void mOL(String j) {
		System.out.println(j);
	}
}

Ⅴ 体会可变个数的形参

public class Person3 {
/*
 * 用数组的方式来传递可变个数的参数
 * 如果没有参数，就要定义一个空数组或者是null
 */
        public void printInfo(String[] a) {
                for(int i=0 ; i< a.length;i++) {System.out.println(a[i]);}
                //能够打印的信息都有来源于方法的参数也就是形参的传递
                //现在可能给方法要传递的不同的参数？如果在这种情况下，我们不知道想要给方法传递多少参数
        }
/*
 * 用java特有的...的方式来传递可变个数的参数，这种参数在使用时与数组的使用方式相同
 * 如果没有参数这种方式可以不填
 * 这种...代表可以传递0到多个参数
 * 如果一个方法有多个形参，可变的形参（...这种的参数）一定要放在所有的参数最后
 * printInfo1（String s , int d , String ... args）这样的放置参数的方式是对的
 * 其他放置顺序都是错误的
 */
        public void printInfo1(String...b) {
                for(int i=0; i<b.length;i++) {
                        System.out.println(b[i]);
                }
        }
}

Ⅵ 方法的参数传递

①基本数据类型的参数传递

public class TestTransfer {
	public static void swap(int i) {
		i = 6;
		System.out.println("swap方法里，i的值是"+i);
	}
	public static void main(String[]args) {
		int a =0;
		swap(a);
		System.out.println("main方法里，变量a的值是"+a);
	}//首先执行的是 int a=0，在栈中开辟了一块内存，地址就是AD8500,存的值是0
	 //其次调用swap方法，执行int i部分，在栈中开辟一块内存地址是AD8600，值就是从a那里复制
	 //复制过来的值，就是0，接着继续执行swap的方法体里面的代码，i-6。把i在栈中的值改成6，最终i在栈中的值就是6
}//总之，基本数据类型类在参数的传递过程中，就是把实参的值复制到形参上

基本数据类型参数传递的练习。

public class TestTransfer {
	public static void swap(int a, int b) {
		int tmp=a;
		a=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);
	}
}
//输出结果：
//swap方法里，a的值是9；b的值是6
//交换结束后，变量a的值是6;变量b的值是9

②引用对象的参数传递

public class TestTransfer1 {
	/*
	 * 名为swap的方法，形参ds1是DataSwap类里的类变量（类名加属性）
	 */
	public static void swap(DataSwap ds1) {
		ds1.a=6;
		System.out.println("swap方法里，a的值是"+ds1.a);
	}
	public static void main(String[]args) {
		DataSwap ds = new DataSwap();
		System.out.println("执行swap方法前，mian方法里，a的值是"+ds.a);
		swap(ds);
		System.out.println("执行swap方法后，main方法里，a的值是"+ds.a);
	/*
	 * 1.DataSwap ds = new DataSwap(),把new DataSwap()存到了堆内存中，地址BE2500
	 * 2.ds引用对象存到栈内存中，地址是AD2500，值是new DataSwap()对象在堆中的地址BE2500
	 * 3.调用swap方法，给ds1引用对象保存到栈内存中，地址是AD9600，存的值是来源于实参（ds）,也就是ds栈中存的值，这个值实际上就是之前new DataSwap（）对象在堆内存中的地址
	 * 到第三步时，实际上ds、ds1其实都是指向同一个对象，这个对象就是在堆内存中地址是BE2500上保存的对象
	 * 在这个例子中，最后的结果是ds和ds1操作实际是同一个对象  
	 */
	}
}

引用对象参数传递的练习。

public class DataSwap {
	public int a;
	public int b;
}
public class TestTransfer1 {
	//名为swap的方法，形参为引用对象DataSwap类型，名为ds
	//
	public static void swap(DataSwap ds) {
		int tmp=ds.a;
		ds.a=ds.b;
		ds.b=tmp;
		System.out.println("swap方法里，a的值是"+ds.a+";b的值是"+ds.b);
	}
		public static void main(String[]args) {
			DataSwap ds = new DataSwap();
			System.out.println("交换结束前，a的值是"+ds.a+";b的值是"+ds.b);
			ds.a=6;
			ds.b=9;
			swap(ds);
			System.out.println("交换结束后，a的值是"+ds.a+";b的值是"+ds.b);
		}
}

//输出结果：
//交换结束前，a的值是0;b的值是0
//swap方法里，a的值是9;b的值是6
//交换结束后，a的值是9;b的值是6