一、用程序讲解小白的故事
小白是一条狗，它心情好的时候会恭喜人发财，它心情差的时候会对路人撒野，吓得路人落荒而逃。下面我们用面向对象的方式用程序讲述一下小白的故事。
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();
}
}
我们看到创建对象的过程就是执行构造函数的过程，而且也看到构造方法也可以重载。
我们在这里明确的是说明构造函数或者说构造方法，它不是方法。它们之间的三大区别，为了让你记清楚，我做了个图：
