Java巩固——面向对象基础

写在前面

每一位正在学习或者已经学习Java的小伙伴都清楚一个事实——Java是一门面向对象的程序设计语言。这里简单地解释一下面向对象。
从形式上说，使用面向对象的程序设计语言进行编写代码时，所有的代码逻辑都是以对象为主。相比于强调怎么做的面向过程，面向对象更加强调都有谁以及谁做了什么。
在写这篇文章之前，我看到一个很好的例子，文章里面说，面向过程写出来的程序就是一碗蛋炒饭，鸡蛋的香味和米饭紧密相连，如果你很不幸地对鸡蛋过敏，那么你将不能吃大米饭。你懂的，米粒和鸡蛋融合在了一起，即使把一些大块的鸡蛋去掉，米粒上还是有鸡蛋的。

相对的，面向对象写出来的程序就是一份盖浇饭，这意味着大米和菜是两个独立的个体，如果你对鸡蛋过敏，那么你就可以不加西红柿鸡蛋，你完全可以吃红烧茄子、或者吃点回锅肉也是不错的。这里的重点的是，即使你的米饭里面加了西红柿鸡蛋，你也完全可以将它给去掉（至于去掉鸡蛋之后，米饭残留的汤汁儿是否有影响…博主也不知道，略去）。
下面正式带大家走进Java面向对象的殿堂。

对象的模板——类

Java中所有的对象都是根据类创建的，没有类你完全不可能创建对象，也就是说，类是Java实现面向对象的关键。

什么是类

什么是类？就像标题说的，类是对象的模板。既然是模板，那么类一定会是对象的一种描述，简单来说：

类是对象的描述，在类中描述了对象的固有属性和行为
固有属性就是指对象有什么
行为就是指对象可以做什么

以学生为例，如何描述一个学生呢？从两个方面看：

1. 从学生的属性来看，一个学生有自己的名字(name)，有年龄(age)，性别sex)，以及最重要的——TA的学习成绩
2. 从学生的行为来看，一个学生可以看书学习(study)，跑步(run)等等。

这些属性和行为组合在一起，便形成了一个学生类。

定义类

语句格式

class name{
// 域
// 构造器
// 方法
}

在Java中，类由三个部分组成：

1. 域，也叫成员变量
2. 构造器——用于构造对象
3. 方法

这几个部分和对象有下面的这种对应关系：

我们可以定义一下学生类:

class Student{
	//域
	String name;
    int age;
    String sex;		
    double chinese;
    double math;
    double english;
	//构造器
    public Student() {
    }
    public Student(String n, int a, String s, double c, double m, double e) {
        name = n;
        age = a;
        sex = s;
        chinese = c;
        math = m;
        english = e;
    }
	//方法
    public void run(){
        System.out.println(name + "is running");
    }
    public void study(){
        System.out.println(name + "is studing");
    }
}

在了解了类的整体组成之后，接下来，详细了解类的各个部分。

域(field)

域描述了对象的属性

域，又称为成员变量，他对应着对象的属性。从技术上讲，类的域部分就是定义变量。格式如下

modifier type name;

这一部分在上一篇文章中已经有所描述。这里需要注意的是：

1. 每一个成员变量都有相对应的访问权限，它可以限制该成员变量的作用域
2. 在定义成员变量的时候最多只能做初始化操作，如下所示：

class Test{
	int age = 1;	// oK
	age++;			//error，只能在方法中进行
	int m = age;	//OK
	int n = m++;	//OK
}

也就是说，在类中，你不能对成员变量做其他操作，除了最基本的赋值操作。
3. 如果不对成员变量做初始化操作，成员变量也有初始值。根据类型的不同，变量的初始值也不一样。简单来说——数值类型的成员变量初始值为0，布尔类型的成员变量初始值为false，引用类型的成员变量初始值为null。

方法(method)

方法对应着对象的行为。在方法中，可以对成员变量进行各种操作而不仅限于赋值。
Java中定义方法的形式类似于C语言中定义函数：

修饰符   返回值类型  方法名(参数列表){
	// 方法体
}

和C语言类似，方法也有相同的规定：

1. 方法的修饰符可以限制方法的使用范围和访问权限
2. 如果没有返回值类型，那么需要使用void声明
3. 方法名遵循变量的命名规范
4. 参数列表列出来方法的若干个参数，也可以没有参数

看一个例子：

	public void run(){
        System.out.println(name + "is running");
    }
    public void study(){
        System.out.println(name + "is studing");
    }

构造器(constructor)

本质上讲，构造器是一种特殊的方法——专用于构造对象。和方法不同的是，构造器没有返回值。

修饰符   构造器名(参数列表){
}

构造器的特殊性不仅体现在定义的形式不同，还有其他几个方面：

1. 构造器的名字必须和类名一致
2. 一个类可以声明多个构造器
3. 构造器只在构造对象的时候出现，不能和对象一样随时进行调用。

看一个例子：
Student类的构造器

public Student() {
    
}
public Student(String n, int a, boolean s, double c, double m, double e) {
        name = n;
        age = a;
        sex = s;
        chinese = c;
        math = m;
        english = e;
}

在了解类之后，下面来看看怎么创建对象。

创建对象

前面说，类是对象的模板，没有类就不能创建对象。那么，对象怎么创建？答案是使用new关键字和构造器。

new construcor

比如，我们要创建一个Student类的对象，那么只需要在方法中写一条创建对象的语句就行了：

public class StudentTest {
    public static void main(String[] args) {
        new Student();
    }
}

所有的对象都存储在堆里，使用这条语句创建对象之后，将会在堆里面创建一个Student类型的对象。
我们可以创建多个对象。

public class StudentTest {
    public static void main(String[] args) {
        new Student();
        new Student();
    }
}

但是，这就会引出一个问题——我应该如何引用一个指定的对象呢？
这个问题的答案就是——变量，使用引用类型的变量可以解决这个问题。

引用类型

在上一篇文章中，说过变量的类型有两种：基本数据类型和引用类型，我在这里介绍一下引用类型。

引用类型的变量，用于存储引用值。

与基本数据类型不同，引用类型没有固定的关键字，任何一个类都可以视为一个引用类型。常用的String、我们自定义的Student等都是引用类型。
声明一个引用类型变量也很简单：

Student student; //声明Student类的变量

有了变量，我们就可以存储对象了。

Student student = new Student();	//这个过程也称为创建类的实例

在这里使用new关键字会在堆里面创建一个对象，而变量student会把这个对象的引用值保存，以便将来使用。

最后，需要注意的是，Java的强类型原则对于引用类型也同样适用。简单地讲，就是一个Student类的对象只能用一个Student类型的变量进行存储。

使用对象

在拥有对象变量之后，我们就可以引用特定的对象，并通过.调用相应的属性和方法。

public class StudentTest {
    public static void main(String[] args) {
        Student student = new Student("李明",18,false,90,80,70);
        student.english = 88;
        System.out.println(student.name + "的英语成绩进步了，考了" + student.english);
        student.run();
    }
}

可以看到在调用方法的时候，()也必须存在。

方法重载

方法重载：指在同一个类中，定义多个同名方法

话不多说，先看一个例子：

	public void study() {
        System.out.println(name + "is studing");
    }
    public void study(String s){
        System.out.println(name + "is studing " + s);
    }

这是Student类实现方法重载的一个示例。也许有人觉得，这个和构造器有一定的相似，一个无参，一个有参数。方法重载只能这样吗？
当然不是，再来一个例子

int sum(int a,int b){
	return a + b;
}
float sum(float a, float b, float c){
	return a + b + c;	
}
double sum(int a, double b){
	return a + b;

这也是方法重载的一个实例，它有不同的返回值类型、不同的参数个数、不同的参数类型。那么，只要返回值类型、参数个数、参数类型不同，就可以实现方法重载吗？答案是NO🙅‍。下面我来讲讲我对方法重载的认识。

实现方法重载的标准

实现方法重载最重要的一点就是——如何识别出不同的方法。 也就是说，在对象调用方法的使用，编译器是怎么知道调用的是哪一个方法。在Java中，方法的不同是通过方法签名进行分辨。

方法签名： 由方法名和方法参数构成

只要方法签名不同，那么编译器就认为两个方法并不相同。

所以，实现方法重载只需要保证方法参数不同即可。更直白的说，就是只要保证方法的参数类型和参数个数不同，那么方法就可以实现方法的重载。