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 ）。方法重载是实现程序多样性的一个重要手段。也可以称作多态的一种表现方式。





重载规则：

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

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();
}
}

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

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