Java是一门纯面向对象的语言（Object Oriented Program，简称OOP），在面向对象的世界里，一切皆为对象。

1、面向对象及面向过程

面向对象和面向过程

• 面向过程注重的是过程，解决每一个问题的方法可能都有所不同，这样写代码，将来扩展或者维护起来会比较麻烦。
• 面向对象只关注对象，不关注过程，通过对象之间的交互来完成。

注：面向过程和面向对象并不是一门语言，而是解决问题的方法，并没有好坏之分，都有其专门的应用场景。

2、类定义和使用

类是用来对一个实体（对象）来进行描述的。

2.1 类的定义格式

在Java中定义类时需要用到class关键字，具体语法如下：

//创建类
class ClassName {
    field;   //字段（属性）或者成员变量
    method;  //行为或者成员方法
}
1
2
3
4
5

class为定义类的关键字，ClassName为类的名字，{ }中为类的主体。
类中包含的内容称为类的成员，属性主要是用来描述类的，称之为类的成员属性或者类的成员变量。方法主要说明类具有那些功能，称之为类的成员方法。
例：

//创建一个学生类
class Student {
    //属性
    public String name;
    public int age;
    public int height;
    //行为
    public void attribute() {
        System.out.println(name +"年龄：" + age);
        System.out.println(name +"身高：" + height);
    }
    public void eat() {
        System.out.println(name + "正在吃饭！");
    }
    public void learn() {
        System.out.println(name + "边吃边学习！");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

采用Java语言将学生类在计算机中定义完成，经过Javac编译之后形成.class文件，在JVM的基础上计算机就可以识别了。
注：

• 类名采用大驼峰定义
• 方法名/变量用小驼峰定义
• 一般一个文件中只定义一个类
• main方法所在的类一般要用public修饰（注：Eclipse默认会在public修饰的类中找main方法）
• public修饰的类必须要和文件名相同
• 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改，如下图，这样修改可以把整个工程中的名称修改掉

3、类的实例化

3.1 什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是Java语言自带的内置类型，而类是用户自定义的新的类型，比如上述的Student类。有了这些自定义的类型之后，就可以使用这些类来定义实例（或者称为对象）。
用类类型创建对象的过程，称为类的实例化，在Java中采用new关键字，配合类名来实例化对象。

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();//通过new实例化对象
        stu.name = "张三";
        stu.age = 18;
        stu.height = 180;
        stu.attribute();
        stu.eat();
        stu.learn();
    }
}
1
2
3
4
5
6
7
8
9
10
11

输出结果：

注意：

• new关键字用于创建一个对象的实例
• 使用.来访问对象中的属性和方法
• 同一个类可以创建多个实例

3.2 类和对象的说明

1. 类就像一个模型，用来对一个实体进行描述，限定了有哪些成员
2. 类是一种自定义的类型，可以用来定义变量
3. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

对象的存储方式：

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student();
        Student stu3 = new Student();  
    }
}
1
2
3
4
5
6
7

当成员变量没有初始化的时候，默认值就是对应的初始值，比如：引用类型 -> null;int -> 0;float -> 0.0f;boolean -> false;char -> '\u0000'

4、this引用

我们看一个日期类的代码：

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDate(int y,int m, int d) {
        year = y;
        month = m;
        day = d;
    }
    public void printDate() {
        System.out.println(year + "-" + month + "-" + day);
    }

    public static void main(String[] args) {
        //构造三个日期类型的对象
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();

        //对d1,d2,d3的日期设置
        d1.setDate(2020,8,6);
        d2.setDate(2021,8,6);
        d3.setDate(2022,8,6);

        //打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

以上代码定义了一个日期类，然后main方法中创建了三个对象，并通过Date类中的成员方法对对象进行设置和打印，逻辑简单，没有问题。
但是要思考两个问题：
1、形参名不小心与成员变量名相同：

public void setDate(int year,int month, int day) {
    year = year;
    month = month;
    day = day;
}
1
2
3
4
5

那函数体中到底是谁给谁赋值？
局部变量优先，只是形参自己给自己赋值了，根本没有赋值到成员变量中。
2、三个对象都在调用setDate和printDate函数，但是这两个函数中没有任何有关对象的说明，setDate和printDate函数如何知道打印的是哪个对象的数据呢？

4.2 什么是this引用

**this引用指向当前对象（成员方法运行时调用该成员方法的对象），在成员方法中所有成员变量的操作，都是通过该引用去访问。**只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

public void setDate(int year,int month, int day) {
    this.year = year;
    this.month = month;
    this.day = day;
}
1
2
3
4
5

4.3 this引用的特性

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
2. this只能在成员方法中使用（静态成员方法除外）
3. 在成员方法中，this只能引用当前对象，不能再引用其他对象
4. this是成员方法的一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收