第3章 类与对象

3.1 创建类和对象

1. 类的定义
   一个Bird类的定义如下：

//类名
public class Bird {
	//数据成员
	String bread;
	boolean isMale;
	String coloe;
	double weight;
	int numChirps;
	//成员方法
	void chirp() {
		numChirps++;
		System.out.println("What's up? buddy " + numChirps);
	}
	void fly() {
		System.out.println("I can fly");
	}
	void strike() {
		System.out.println("beat you, beat you...");
	}
}

一个类由两部分组成：数据成员和成员方法。类的定义格式如下：

class ClassName {
数据成员
成员方法
}

2. 对象的创建
   定义的类只是一个抽象的概念，属于一种自定义的数据类型，如同一个空的模板，类只有在创建了实例（对象），才能调用类的数据成员和成员方法，从而展现类的特征和行为。
   在创建对象的过程中，通过new关键字为对象分配内存。
   创建对象和调用类方法的代码片段，如下：

Bird red = new Bird();	//创建red对象
Bird white = new Bird();	//创建white对象
red.chirp();	//调用Bird方法

3. 定义main()方法
   main()方法是程序的入口，能让程序运行起来。
   定义格式，如下：

public static void main(String[] args){
……
}

3.2 初始化对象

对象的初始化有两种方式：
①通过赋值语句对属性进行赋值

red.breed = “AngryBird”;
red.isMale = true;
red.color = “red”;

②通过构造方法在创建对象的同时为属性赋值
构造方法（constructor）专门用于对象的初始化，它是一种以类名命名的特殊方法，没有返回值。构造方法的定义格式，如下：

public class ClassName{
ClassName(){} //无参构造函数
ClassName([arguments]){} //有参构造函数
}

【示例】使用构造方法初始化对象

public class Demo {
	public static void main(String[]args) {
		//创建两个对象
	    Person p1 = new Person("Jack", '男');
	    Person p2 = new Person("Erin", '女');
	    //访问数据成员
	    System.out.println("Erin的性别为"+p2.gender);
	}
}


class Person{
	String name;
	char gender;
	public Person(String nm, char gen) {
		name = nm;
		gender = gen;
	}
}

构造方法的特点总结，如下：

1. 构造方法名和所属类名一致
2. 专门用于对象的初始化
3. 没有返回值，且没有修饰符void
4. 如果没有声明构造方法，则系统会自动声明一个无参的构造方法
5. 如果有声明构造方法，则系统不会再声明构造方法

3.3 传递方法参数

方法中的参数既可以是基本数据类型，也可以是引用数据类型。
基本数据类型的参数采用值传递(passing-by-value)的方式，即对形参的任何改动都不会影响到实参。
引用类型的参数采用引用传递(passing-by-reference)的方式，即对形参的改动会影响到实参。
实参：调用方法时传递给方法的实际参数；
形参：定义方法时使用的参数。
【示例】测试参数传递

public class Test01 {
	public static void main(String[]args) {
		int num = 10;
		Person p = new Person("Erin", 16);
		editValue(num);	//修改基本数据类型
		editReference(p);	//修改引用类型
		System.out.println(num);
		System.out.println(p);
	}
	//修改基本数据类型的参数
	static void editValue(int num) {
		num++;
	}
	//修改引用类型的参数
	static void editReference(Person p) {
		p.name = "Jack";
		p.age = 18;
	}
}

class Person {
	String name;
	int age;
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return this.name+","+this.age;
	}
}

运行结果，如下图所示：

PS：

值传递：指传递的是一个拷贝的数据，即形参只是实参的一个拷贝。
引用传递：指传递的是本身，即形参和实参都指向同一个内存地址。
注意：String虽然属于引用类型，但采用值传递方式。这是因为String对象在创建后就不能在更改了。对String对象的值进行更改，会产生一个新的String对象，而原String对象的值不变。

3.4 toString()方法

Object是所有类的父类，toString()方法位于Object类中，所以Java中的所有类都默认继承了toString()方法。
当使用System.out.println()方法输出一个对象时，默认会调用该对象的toString()方法。
当直接调用默认的toString()方法时，返回结果的形式为：
对象类的名字@对象的地址
要想修改返回结果的形式，可以通过重写toString()方法，实现输出自己想要的内容。
注意事项：
1）toString()必须为public。
2）返回类型为String。
3）方法名称必须为toString，且没有参数。
4）在方法体中不要使用输出方法System.out.println()。

3.5 类的使用

1. static数据
   介绍：static数据也称为类数据，它不属于某个对象，而是所有对象共享的，不能通过某个对象来引用。
   生命周期：从创建开始到程序运行结束。
   访问：直接通过类名访问。格式为：类名.staticValue

2. static方法
   static方法和static数据类似，最常用的main()方法就是一个static方法。

3. final关键字
   final修饰符可以用在数据成员、方法、对象和类之前，在给定数值后就不能再做任何更改。
   final修饰符放在类、方法和变量之前的意义如下：
   1）final在类之前：表示该类是终结类，不能再被继承。
   2）final在方法之前：表示该方法是终结方法，该方法不能被任何派生的子类覆盖。
   3）final在变量之前：表示变量的值在初始化之后就不能再改变，相当于定义了一个常量。

4. 方法重载
   方法重载：指在同一个类中可以存在多个重名的方法，但它们的参数表不能相同，参数表指参数个数和参数类型。
   常用到的地方有println()方法和构造方法。

5. this指针
   this指针：存在于方法内部，指向调用该方法的当前对象。
   this指针只能在方法内部使用，它是每个方法内置的。
   this指针的3个用法，如下：
   1）用法1：代替对象，访问对象的数据。
   【示例1】在Product类的构造方法中把隐藏的this指针显示地写出来

//Product.java类
public class Product {
	int ID;
	String name;
	String categories;
	double productPrice;
	
	Product(int id, String nm, String categ, double price){
		this.ID = id;
		this.name = nm;
		this.categories = categ;
		this.productPrice = price;
	}
	Product(){}
}
//Samples.java类
public class Samples {
	public static void main(String[]args) {
		//创建对象
		Product iphone = new Product();
		Product ipad = new Product(10, "ipad2", "computer", 5000);
		Product macbook = new Product(11, "apple", "computer", 9999);
		//输出信息
		System.out.println("ipad price is: " + ipad.productPrice);
		System.out.println("macbook price is: " + macbook.productPrice);
	}
}

在上例中，当系统自动调用构造方法生成对象ipad时，构造方法里的this指针便指向了ipad，此时，this.id等同于ipad.id，this.name等同于ipad.name。

2）用法2：作为返回值使用。
【示例2】将this作为对象返回

//Product.java
public class Product {
	int ID;
	String name;
	String categories;
	double productPrice;
	int i;
	
	Product(int id, String nm, String categ, double price){
		this.ID = id;	//this指针指向了调用此构造方法的对象
		this.name = nm;
		this.categories = categ;
		this.productPrice = price;
	}
	Product(){}
	
	Product increment() {
		i++;
		return this;
	}
	void print() {
		System.out.println("i = " + i);
	}
}
//Samples.java
public class Samples {
	public static void main(String[]args) {
		Product ipad = new Product();
		ipad.increment().increment().increment().print();
	}
}

ipad.increment()返回一个this指针，相当于返回一个Product对象，变量i值增加1。

3）用法3：调用构造方法。
【示例3】在不带参数的构造方法中调用带参数的构造方法

//Product.java
public class Product {
	int ID;
	String name;
	String categories;
	double productPrice;
	
	Product(int id, String nm, String categ, double price){
		this.ID = id;	//this指针指向了调用此构造方法的对象
		this.name = nm;
		this.categories = categ;
		this.productPrice = price;
	}
	Product(){
		//this指针调用带参数的构造方法
		this(2, "iphone", "cellphone", 3300);
		System.out.println("in Product()");
	}
}
//Samples.java
public class Samples {
	public static void main(String[]args) {
		Product phone = new Product();
		System.out.println("product " + phone.ID + ",name " + phone.name + ",categories: " + phone.categories + ",productPrice " + phone.productPrice);
	}
}

6. 对象回收
   Java通过new分配内存空间，但无需考虑释放空间的问题。
   Java之所以不需要手动释放对象空间，是因为Java提供了垃圾回收器（garbage collector），由它负责释放不再使用的内存资源。

7. 包
   Java中的包类似于Windows系统的文件夹。
   通过import语句导入包，导入语句必须放在文件首。

8. 访问修饰符
   访问控制权限分为不同等级，从最大权限到最小权限依次为：
   public → protected → 包访问权限（没有关键字）→ private
   对类的访问控制只提供了public（公共类）及包（默认类）两种权限，对于类成员的访问控制权限有以下几种：
   1）公有（public）：可以被其他任何对象访问。
   2）保护（protected）：只可被同一类及其子类的对象访问。
   3）包访问权限：不加任何修饰符，默认访问权限，仅允许同一个包内的成员访问。
   4）私有（private）：只能被这个类本身方法访问，在类外不可见。

3.6 Java基础类库

3.7 Java注释