JAVA面向对象基础：成员变量、方法、方法的重载、构造函数

本文转载链接地址：http://android.yaohuiji.com/archives/3115
一、用程序讲解小白的故事

小白是一条狗，它心情好的时候会恭喜人发财，它心情差的时候会对路人撒野，吓得路人落荒而逃。下面我们用面向对象的方式用程序讲述一下小白的故事。

public class Dog {

	//构造函数
	public Dog(){
		size =3;
	}

	//定义叫声常量
	final String BARK_NORMAL = "汪！汪汪！";
	final String BARK_HAPPY = "旺！旺旺！";
	final String BARK_SAD = "呜……嗷！";

	//定义心情常量
	static final int NORMAL =0;
	static final int HAPPY =1;
	static final int SAD = 2;	

	// 定义了狗的个头大小的属性
	private int size;

	// 定义获取个头的方法
	public int getSize() {
		return size;
	}

	// 定义狗叫的方法
	public void bark(){
		if(size<5){
			System.out.println("汪汪汪!");
		}else{
			System.out.println("嗷!嗷!");
		}
	}

	//定义狗叫的方法，带心情参数
	public void bark(int mood){
		switch(mood){
		case NORMAL:
			System.out.println(BARK_NORMAL);
			break;
		case HAPPY:
			System.out.println(BARK_HAPPY);
			break;
		case SAD:
			System.out.println(BARK_SAD);
			break;
		}
	}

	//定义main方法
	public static void main(String[] args) {
		//创建了名字叫小白的狗对象
		Dog xiaoBai = new Dog();
		//调用它叫的方法
		xiaoBai.bark();

		//调用带参数的方法
		xiaoBai.bark(HAPPY);
	}

}

运行程序，看一下输出结果：

二、类定义中的五个顶级成员（top-level member）

实体	static修饰	没用static修饰
成员变量	类变量	实例变量
初始化块	静态初始化块	实例初始化块
构造方法	/	构造方法
方法	类方法	实例方法
接口	嵌套的接口 member interface	/
类	嵌套顶层类 nested top-level class	内部成员类 inner member class

三、成员变量（类或对象的状态）

1、认识成员变量（类或对象的状态）、类变量、实例变量、局部变量、方法参数之间的区别

成员变量（field）是没有定义在代码块（包括初始化块、成员方法）中的变量。成员变量是类变量还是实例变量取决于在其声明中是否使用了static关键字。

类变量在声明是用了static关键字，它的另一个名字叫静态变量、静态成员变量(static field) 。

实例变量是在声明时没有使用static关键字的成员变量，它的另一个名字叫非静态成员变量（non-static field）。

定义在代码块里的变量被称为局部变量（local variable）。

定义在方法声明中的变量叫方法参数。

public class Lesson08 {

	// 类变量
	static String s1 = "类变量";

	// 实例变量
	String s2 = "实例变量";

	// 初始化代码块里的局部变量
	{
		String s3 = "初始化代码块里的局部变量";
		System.out.println(s3);
	}

	// 静态初始化代码块里的局部变量
	static {
		String s4 = "静态初始化代码块里的局部变量";
		System.out.println(s4);
	}

	// 方法的参数和方法里的局部变量
	public void printString(String s5) {
		String s6 = "方法里的局部变量";
		System.out.println("方法的参数:"+s5);
		System.out.println(s6);
	}

	// 类方法
	public static void printString() {
		String s7="类方法里的局部变量";
		System.out.println(s7);
	}

	// main方法
	public static void main(String[] args) {

		//调用类方法
		Lesson08.printString();	

		//打印类变量
		System.out.println(s1);

		//创建对象
		Lesson08 lesson = new Lesson08();

		//打印实例变量
		System.out.println(lesson.s2);

		//调用实例方法
		lesson.printString("参数的值");

	}

}

对于他们之间的区别，我们在以后的学习中你会越来越清晰的。

2、变量的初始化

实例变量一经定义就会有初始值，局部变量定义时不赋初值而直接使用，编译器会报错

public class Lesson08_1 {

	int i;
	static int j;
	{
		int k;
		System.out.println(k);
	}

	static {
		int l;
		System.out.println(l);
	}

	public void print(String m){

		System.out.println(m);
	}

	// main方法
	public static void main(String[] args) {
		int n;
		System.out.println(n);

		Lesson08_1 lesson =new Lesson08_1();
		lesson.print("m");
	}

}

运行程序，查看结果：

然后我们再给局部变量都附上初值，再把实例变量和类变量都打印出来看看，代码如下：

public class Lesson08_1 {

	int i;
	static int j;

	{
		int k=2;
		System.out.println(k);
	}

	static {
		int l=2;
		System.out.println(l);
	}

	public void print(String m){

		System.out.println(m);
	}

	// main方法
	public static void main(String[] args) {	

		System.out.println(j);

		int n=2;
		System.out.println(n);

		Lesson08_1 lesson =new Lesson08_1();
		lesson.print("m");
		System.out.println(lesson.i);
	}

}

运行程序，查看结果：

我们看到类变量和实例变量没赋值照样有值打印出来，我们也看到int的初始值是0 。

实例变量和类变量的类型	初始值
整数	0
浮点类型	0.0
字符类型	‘/u0000′
布尔类型 boolean	false
引用数据类型(譬如数组、接口、类)	null

四、方法（类或对象的行为）

1、方法

Java中类的行为由类的成员方法来实现。类的成员方法由方法的声明和方法体两部分组成。

修饰符，可选，用于指定谁有权限访问此方法。

返回值类型，必选，用于指定该方法的返回值数据类型；如果该方法没有返回值，则要用关键字 void 进行标示。方法的返回值只能有一个。

参数列表，可以有0到多个，多个参数之间要用逗号隔开，参数的写法形如：String[] args, int age 这样。

方法名，必选，这个……，好吧命名规则是方法名和变量名的首字母要小写，别丢我人，弄个大写方法名出来。

方法体，可选，这个……，

大括号，大括号不写的方法叫抽象方法。

2、属性和方法之间的关系

有句绕口令是这么说的：“状态影响行为，行为影响状态”。你有没有想过这问题，如果每个对象都是从同一个类中生成出来，每个对象如果都一摸一样，那么这个世界是不是太无趣了。好在，我们看到前面的例子中，小狗的大小属性影响了他叫的方式。通过设置狗大小的方法又改变了它的状态。这些属性和方法的细节上的不同导致了，多姿多彩的对象，我们后面还会讲到更多的技术，也会导致更多的多样性。

五、方法重载 overload

Java里可以提供同一个方法的多个不同参数的版本供我们调用，譬如上面的小白，它叫 bark() 的方法有两种，一种是很随意的叫，无拘无束的叫，还有一种是根据它心情的不同来叫，当然我还可以再定义一个方法可以让他根据主人的脸色来叫，我们也可以再定义一个方法，穿的参数是食物，那么它的叫声可能就是边吃边幸福的吼叫了…… 这样一个bark方法就带来了丰富多彩的变化。

在Java 中允许类定义中多个方法的方法名相同，只要它们的参数声明不同即可。这种情况下，该方法就被称为重载（overloaded ），这种方式就叫做方法重载（method overloading ）。方法重载是实现程序多样性的一个重要手段。也可以称作多态的一种表现方式。

重载规则：

1. 重载方法必须改变方法参数列表
2. 重载方法可以改变返回类型
3. 重载方法可以改变访问修饰符
4. 重载方法可以声明新的或更广的检验异常
5. 方法能够在同一个类或者一个子类中被重载

	public class lesson08_2 {

	static long max(long a,long b){
		System.out.println("max(long a,long b)");
		return a>b?a:b;
	}	

	static long max(long a,int b){
		System.out.println("max(long a,int b)");
		return a>b?a:b;
	}

	static int max(int a,int b){
		System.out.println("max(int a,int b)");
		return a>b?a:b;
	}

	static byte max(byte a,byte b){
		System.out.println("max(byte a,byte b)");
		return a>b?a:b;
	}

	public static void main(String[] args) {
		byte byte1 = 125;
		byte byte2 = 126;
		int int1 = 1;
		int int2 = 2;
		long long1 = 1000;
		long long2 = 2000;

		System.out.println(max(byte1,byte2));
		System.out.println(max(int1,int2));
		System.out.println(max(byte1,int2));
		System.out.println(max(int1,long2));
		System.out.println(max(long1,int2));
		System.out.println(max(long1,long2));
	}
}

上面的例子说明了参数声明不同的含义，那就是只要参数的个数，类型和顺序任意一项不同就算不同的参数声明，即使它们看起来很相似，甚至看起来可能会让虚拟机搞混。不过没关系，虚拟机很聪明，只要你按照规则走他就能分清。

六、构造函数

在Java中，对象是构造出来的，特意用了一个new关键字来标示这个创建的过程。

我们把上一讲的例子修改一下，看看创建对象的过程发生了什么。

public class Dog {

	// 定义了狗的个头大小的属性
	private int size=3;

	public Dog(int size){
		System.out.println("带参数的构造函数");
		this.size = size;
	}

	public Dog(){
		System.out.println("不带参数的构造函数");
		this.size=2;
	}

	// 定义狗叫的方法
	public void bark(){
		if(size<5){
			System.out.println("汪汪汪!");
		}else{
			System.out.println("嗷!嗷!");
		}
	}

	//定义main方法
	public static void main(String[] args) {

		//创建了名字叫小黄的狗对象
		Dog xiaoHang = new Dog(4);

		//调用它的叫方法
		xiaoHang.bark();

		//创建了名字叫大黄的狗对象
		Dog daHang = new Dog(6);

		//调用它的叫方法
		daHang.bark();

		//创建了名字叫小黑的狗对象
		Dog xiaoHei = new Dog();

		//调用它的叫方法
		xiaoHei.bark();
	}
}

我们看到创建对象的过程就是执行构造函数的过程，而且也看到构造方法也可以重载。

我们在这里明确的是说明构造函数或者说构造方法，它不是方法。它们之间的三大区别，为了让你记清楚，我做了个图：