## 面向对象的概念
面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。
#### 封装性
封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。
例如，用户使用电脑，只需要使用手指敲键盘就可以了，无须知道电脑内部是如何工作的，即使用户可能碰巧知道电脑的工作原理，但在使用时，并不完全依赖电脑工作原理这些细节。
#### 继承性
继承性主要描述的是类与类之间的关系，通过继承，可以在无须重新编写原有类的情况下，对原有类的功能进行扩展。
例如，有一个汽车的类，该类中描述了汽车的普通特性和功能，而轿车的类中不仅应该包含汽车的特性和功能，还应该增加轿车特有的功能，这时，可以让轿车类继承汽车类，在轿车类中单独添加轿车特性的方法就可以了。继承不仅增强了代码复用性，提高了开发效率，而且为程序的修改补充提供了便利。
#### 多态性
多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。
例如，当听到“Cut”这个单词时，理发师的行为是剪发，演员的行为是停止表演，不同的对象，所表现的行为是不一样的。
面向对象的思想光靠上面的介绍是无法真正理解的，只有通过大量的实践去学习和理解，才能将面向对象真正领悟。
## 类与对象
面向对象的编程思想力图在程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点，面向对象的思想中提出两个概念，即类和对象。其中，类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。接下来通过一个图例来描述类与对象的关系。
在图中，可以将玩具模型看作一个类，将一个个玩具看作对象，从玩具模型和玩具之间的关系便可以看出类与对象之间的关系。类用于描述多个对象的共同特征，它是对象的模板。对象用于描述现实中的个体，它是类的实例。从图可以明显看出对象是根据类创建的，并且通过一个类可以创建多个对象。
#### 类的定义
在面向对象的思想中最核心的就是对象，为了在程序中创建对象，首先需要定义一个类。类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称作属性，成员方法用于描述对象的行为，可简称为方法。接下来通过一个案例来学习如何定义一个类。
```java
public class Person {
int age; // 定义int 类型的变量age
// 定义speak() 方法
void speak() {
System.out.println("大家好，我今年" + age + "岁!");
}
}
```
例中定义了一个类。其中，Person是类名，age是成员变量，speak()是成员方法。在成员方法speak()中可以直接访问成员变量age。
#### 对象的创建与使用
应用程序想要完成具体的功能，仅有类是远远不够的，还需要根据类创建实例对象。在Java程序中可以使用new关键字来创建对象，具体格式如下:
```
类名 对象名称 = new 类名();
```
例如，创建Person类的实例对象代码如下:
```
Person p = new Person();
```
上面的代码中，“newPerson()”用于创建Person类的一个实例对象，“Personp”则是声明了一个Person类型的变量p。中间的等号用于将Person对象在内存中的地址赋值给变量p，这样变量p便持有了对象的引用。接下来的章节为了便于描述，通常会将变量p引用的对象简称为p对象。在内存中变量p和对象之间的引用关系如图
在创建Person对象后，可以通过对象的引用来访问对象所有的成员，具体格式如下:
```
对象引用.对象成员
```
接下来通过一个案例来学习如何访问对象的成员
```java
public class Example01 {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person();
p1.age = 18;
p1.speak();
p2.speak();
}
}
```
运行结果：
```
大家好，我今年18岁!
大家好，我今年0岁!
```
p1、p2分别引用了Person类的两个实例对象。从图3-3所示的运行结果可以看出，p1和p2对象在调用speak()方法时，打印的age值不相同。这是因为p1对象和p2对象是两个完全独立的个体，它们分别拥有各自的age属性，对p1对象的age属性进行赋值并不会影响到p2对象age属性的值。程序运行期间p1、p2引用的对象在内存中的状态如图所示。
在例中，通过“p1.age=18”将p1对象的age属性赋值为18，但并没有对p2对象的age属性进行赋值，按理说p2对象的age属性应该是没有值的。但所显示的运行结果可以看出p2对象的age属性也是有值的，其值为0。这是因为在实例化对象时，Java虚拟机会自动为成员变量进行初始化，针对不同类型的成员变量，Java虚拟机会赋予不同的初始值。
当对象被实例化后，在程序中可以通过对象的引用变量来访问该对象的成员。需要注意的是，当没有任何变量引用这个对象时，它将成为垃圾对象，不能再被使用。接下来通过两段程序代码来分析对象是如何成为垃圾的。
第一段程序代码:
```
{
Person p1=new Person();
……
}
```
上面的代码中使用变量p1引用了一个Person类型的对象，当这段代码运行完毕时，变量p1就会超出其作用域而被销毁，这时Person类型的对象就没有被任何变量引用，变成垃圾。
第二段程序代码:
```java
class Person {
void say() {
System.out.println("你好Java");
}
}
public class Example01 {
public static void main(String[] args) {
Person p = new Person();
p.say();
p = null;
p.say();
}
}
```
执行结果：
```
你好Java
Exception in thread "main" java.lang.NullPointerException
at Example01.main(Example01.java:12)
```
在例中，创建了一个Person类的实例对象，并两次调用了该对象的say()方法。第一次调用say()方法时可以正常打印，但在第10行代码中将变量p2的值置为null，当再次调用say()方法时抛出了空指针异常。在Java中，null是一种特殊的常量，当一个变量的值为null时，则表示该变量不指向任何一个对象。当把变量p2置为null时，被p2所引用的Person对象就会失去引用，成为垃圾对象，其过程如图所示。
#### 类的设计
在Java中，对象是通过类创建出来的。因此，在程序设计时，最重要的就是类的设计。接下来通过一个具体的案例来学习如何设计一个类。
假设要在程序中描述一个学校所有学生的信息，可以先设计一个学生类(Student)，在这个类中定义两个属性name、age分别表示学生的姓名和年龄，定义一个方法introduce()表示学生做自我介绍。根据上面的描述设计出来的Student类如例所示。
```java
public class Student {
String name;
int age;
public void introduce() {
// 方法中打印属性name 和age 的值
System.out.println("大家好，我叫" + name + "，我今年" + age + "岁!");
}
}
```
在例中的Student类中，定义了两个属性name和age。其中的name属性为String类型，在Java中使用String类的实例对象表示一个字符串，例如:
```java
String name = "李芳";
```
关于字符串的相关知识在本书的第6章将会进行详细地讲解，在此处可简单地将字符串理解为一连串的字符。
#### 类的封装
接下来针对上一个例中设计的Student类创建对象，并访问该对象的成员，如例所示
```java
public class Example {
public static void main(String[] args) {
Student student = new Student();
student.name = "easilyj";
student.age = -20;
student.introduce();
}
}
```
运行结果：
```
大家好，我叫easilyj，我今年-20岁!
```
在第6行代码中，将年龄赋值为一个负数-20，这在程序中不会有任何问题，但在现实生活中明显是不合理的。为了解决年龄不能为负数的问题，在设计一个类时，应该对成员变量的访问做出一些限定，不允许外界随意访问。这就需要实现类的封装。
所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问。为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。接下来通过一个案例来实现类的封装。
```java
class Student {
int age;
String name;
public String getName() {
return name;
}
public void setName(String name) {
name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
// 下面是对传入的参数进行检查
if (age <= 0) {
System.out.println("年龄不合法……");
} else {
age = age; // 对属性赋值
}
}
public void introduce() {
// 方法中打印属性name 和age 的值
System.out.println("大家好，我叫" + name + "，我今年" + age + "岁!");
}
}
public class Example {
public static void main(String[] args) {
Student student = new Student();
student.setName("easilyj");
student.setAge(-20);
student.introduce();
}
}
```
运行结果：
```
年龄不合法……
大家好，我叫easilyj，我今年0岁!
```
在例中的Student类中，使用private关键字将属性name和age声明为私有，对外界提供了几个公有的方法，其中getName()方法用于获取name属性的值，setName()方法用于设置name属性的值，同理，getAge()和setAge()方法用于获取和设置age属性的值。在main()方法中创建Student对象，并调用setAge()方法传入一个负数-30，在setAge()方法中对参数stuAge的值进行检查，由于当前传入的值小于0，因此会打印“年龄不合法”的信息，age属性没有被赋值，仍为默认初始值0。
## 构造方法
#### 构造方法的定义
在一个类中定义的方法如果同时满足以下三个条件，该方法称为构造方法，具体如下:
- 方法名与类名相同。
- 在方法名的前面没有返回值类型的声明。
- 在方法中不能使用return语句返回一个值。
接下来通过一个案例来演示如何在类中定义构造方法。
```java
class Person {
public Person() {
System.out.println("无参构造方法 ...");
}
}
public class Example {
public static void main(String[] args) {
Person person = new Person();
}
}
```
运行结果：
```
无参构造方法 ...
```
Person类中定义了一个无参的构造方法Person()。从运行结果可以看出，Person类中无参的构造方法被调用了。这是因为在实例化Person对象时会自动调用类的构造方法，“new Person()”语句的作用除了会实例化Person对象，还会调用构造方法Person()。
在一个类中除了定义无参的构造方法，还可以定义有参的构造方法，通过有参的构造方法就可以实现对属性的赋值。
```java
class Person {
int age;
public Person(int a) {
age = a;
}
public void speak() {
System.out.println("easilyj的岁数是：" + age);
}
}
public class Example {
public static void main(String[] args) {
Person person = new Person(20);
person.speak();
}
}
```
运行结果：
```
easilyj的岁数是：20
```
Person类中定义了有参的构造方法Person(inta)。代码中的“new Person(20)”会在实例化对象的同时调用有参的构造方法，并传入了参数20。在构造方法Person(int a)中将20赋值给对象的age属性。通过运行结果可以看出，Person对象在调用speak()方法时，其age属性已经被赋值为20。
#### 构造方法的重载
与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可以通过调用不同的构造方法为不同的属性赋值。接下来通过一个案例来学习构造方法的重载。
```java
class Person {
String name;
int age;
public Person(int a) {
age = a;
}
public Person(String name， int age) {
name = name;
age = age;
}
public Person(String name) {
name = name;
}
public void speak() {
System.out.println("我的名字是：" + name + "， 我的年龄是：" + age);
}
}
public class Example {
public static void main(String[] args) {
Person person = new Person("小海绵"， 20);
Person person1 = new Person("easilyj");
person.speak();
person1.speak();
}
}
```
运行结果：
```
我的名字是：小海绵， 我的年龄是：20
我的名字是：easilyj， 我的年龄是：0
```
Person类中定义了两个构造方法，它们构成了重载。在创建p1对象和p2对象时，根据传入参数的不同，分别调用不同的构造方法。从程序的运行结果可以看出，两个构造方法对属性赋值的情况是不一样的，其中一个参数的构造方法只针对name属性进行赋值，这时age属性的值为默认值0。
**细节**
在Java中的每个类都至少有一个构造方法，如果在一个类中没有定义构造方法，系统会自动为这个类创建一个默认的构造方法，这个默认的构造方法没有参数，在其方法体中没有任何代码，即什么也不做。
## this关键字
在上例中使用变量表示年龄时，构造方法中使用的是name，成员变量使用的是name，这样的程序可读性很差。这时需要将一个类中表示年龄的变量进行统一的命名，例如都声明为name。但是这样做又会导致成员变量和局部变量的名称冲突，在方法中将无法访问成员变量name。为了解决这个问题，Java中提供了一个关键字this，用于在方法中访问对象的其他成员。接下来将为大家详细地讲解this关键字在程序中的三种常见用法，具体如下:
- 通过this关键字可以明确地去访问一个类的成员变量，解决与局部变量名称冲突问题。具体示例代码如下:
```java
class Person {
int age;
public Person(int age) {
this.age = age;
}
public int getAge() {
return this.age;
}
}
```
在上面的代码中，构造方法的参数被定义为age，它是一个局部变量，在类中还定义了一个成员变量，名称也是age。在构造方法中如果使用“age”，则是访问局部变量，但如果使用“this.age”则是访问成员变量。
- 通过this关键字调用成员方法，具体示例代码如下:
```java
class Person {
public void openMouth() {
︙
}
public void speak() {
this.openMouth();
}
}
```
在上面的speak()方法中，使用this关键字调用openMouth()方法。注意，此处的this关键字可以省略不写，也就是说上面的代码写成“this.openMouth()”和“openMouth()”，效果是完全一样的。
- 构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this([参数1，参数2…])”的形式来调用其他的构造方法。
```java
class Person {
public Person() {
System.out.println("无参的构造方法被调用了……");
}
public Person(String name) {
this(); // 调用无参的构造方法
System.out.println("有参的构造方法被调用了……");
}
}
public class Test {
public static void main(String[] args) {
Person p = new Person("itcast"); // 实例化Person 对象
}
}
```
运行结果：
```
无参的构造方法被调用了……
有参的构造方法被调用了……
```
代码在实例化Person对象时，调用了有参的构造方法，在该方法中通过this()调用了无参的构造方法，因此运行结果中显示两个构造方法都被调用了。在使用this调用类的构造方法时，应注意以下几点。
1. 只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用。
2. 在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。
3. 不能在一个类的两个构造方法中使用this互相调用，下面的写法编译会报错。
## 垃圾回收
在Java中，当一个对象成为垃圾后仍会占用内存空间，时间一长，就会导致内存空间的不足。针对这种情况，Java中引入了垃圾回收机制。程序员不需要过多关心垃圾对象回收的问题，Java虚拟机会自动回收垃圾对象所占用的内存空间。
一个对象在成为垃圾后会暂时地保留在内存中，当这样的垃圾堆积到一定程度时，Java虚拟机就会启动垃圾回收器将这些垃圾对象从内存中释放，从而使程序获得更多可用的内存空间。除了等待Java虚拟机进行自动垃圾回收，也可以通过调用System.gc()方法来通知Java虚拟机立即进行垃圾回收。当一个对象在内存中被释放时，它的finalize()方法会被自动调用，因此可以在类中通过定义finalize()方法来观察对象何时被释放。接下来通过一个案例来演示Java虚拟机进行垃圾回收的过程。
```java
class Person {
public void finalize() {
System.out.println("对象被作为垃圾回收 ...");
}
}
public class Test {
public static void main(String[] args) {
Person p = new Person();
Person p2 = new Person();
// 下面将变量置为null，让对象成为垃圾
p = null;
p2 = null;
// 调用方法进行垃圾回收
System.gc();
for (int i = 0; i < 1000000; i++) {
// 为了延长程
}
}
}
```
运行结果：
```
对象被作为垃圾回收 ...
对象被作为垃圾回收 ...
```
Person类中定义了一个finalize()方法，该方法的返回值必须为void，并且要使用public来修饰。在main()方法中创建了两个对象p1和p2，然后将两个变量置为null，这意味着新创建的两个对象成为垃圾了，紧接着通过“System.gc()”语句通知虚拟机进行垃圾回收。从运行结果可以看出，虚拟机针对两个垃圾对象进行了回收，并在回收之前分别调用两个对象的finalize()方法。
需要注意的是，Java虚拟机的垃圾回收操作是在后台完成的，程序结束后，垃圾回收的操作也将终止。因此，在程序的最后使用了一个for循环，延长程序运行的时间，从而能够更好地看到垃圾对象被回收的过程。
## static关键字
**特点：**
- static是一个修饰符，用于修饰成员。（成员变量，成员方法）static修饰的成员变量称之为静态变量或类变量。
- static修饰的成员被所有的对象共享。
- static优先于对象存在，因为static的成员随着类的加载就已经存在。
- static修饰的成员多了一种调用方式，可以直接被类名所调用，（类名.静态成员）。
- static修饰的数据是共享数据，对象中的存储的是特有的数据。
#### 静态变量
可以直接通过**类名.静态变量名**调用。每次创建对象时，静态变量都是相同的，且一个地方修改了静态变量值，所有的对象的该变量值都会被修改，**不提倡这种写法**。
```java
public class Book {
String name = "Tom";
static String price = "100";
public static void main(String[] args) {
System.out.println(Book.price);
}
}
```
**成员变量和静态变量的区别：**
1.生命周期的不同：
成员变量随着对象的创建而存在随着对象的回收而释放。
静态变量随着类的加载而存在随着类的消失而消失。
2.调用方式不同：
成员变量只能被对象调用。
静态变量可以被对象调用，也可以用类名调用。（推荐用类名调用）
3.别名不同：
成员变量也称为实例变量。
静态变量称为类变量。
4.数据存储位置不同：
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据。
静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据
#### 静态方法
不需要创建对象，直接使用**类名.方法名**就可调用。
```java
public class Book {
String name = "Tom";
static String price = "100";
public static String hello() {
return "hello";
}
public static void main(String[] args) {
System.out.println(Book.hello());
}
}
```
**什么时候使用static来修饰**
1.静态变量：
当分析对象中所具备的成员变量的值都是相同的。这时这个成员就可以被静态修饰。
只要是数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，是静态的。
2.静态函数：
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中特有的数据。
简单来说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，但是非静态需要被对象调用，而仅创建对象是没有意义的。
#### 静态代码块
随着类的调用或创建实例而执行，而且只执行一次。用于给类进行初始化。
```java
public class Book {
private static final String name;
private static final String age;
static {
name = "Tom";
age = "20";
}
public static void main(String[] args) {
System.out.println(name + " : " + age);
}
}
```
执行结果：
```java
Tom : 20
```
**静态使用时需要注意的事项：**
- 静态方法只能访问静态成员。（非静态既可以访问静态，又可以访问非静态）
- 静态方法中不可以使用this或者super关键字。
- 主函数是静态的。
