Java SE知识点三： 方法，类和对象

1. 方法

1.1 什么是方法

方法其实类似于 C语言 中的函数，能够被重复使用从而来减少代码量。

比如来写一个打印 n的阶乘的方法：

    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ret = fact(n);
        System.out.println(ret);
    }

    //方法 fact,与C中的函数类似
    // 1! + 2! + 3! + 4! + 5! + ..... + n! (阶乘的和)
    public static int fact(int n){
        int m = 1, sum = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                m *= j;
            }
            sum += m;
            m = 1;
        }
        return sum;
    }

从上述代码，不难看出方法也有返回值，传参，出了Java和C的写法不同，主要的要素都是相同的。当然，方法也可以没有返回值，比如 void。

1.2 方法的重载

在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。

重载的特点：

1. 方法名必须相同

2. 参数列表必须不同（包括参数类型，个数，顺序等等）

3. 返回值类型是否相同无关

    public static void main2(String[] args){
        int a = add(1, 2); // 调用add(int, int)
        double b = add(1.5, 2.5); // 调用add(double, double)
        double c = add(1.5, 2.5, 3.5); // 调用add(double, double, double)
        System.out.println(a + b + c);
    }

    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(double x, double y) {
        return x + y;
    }
    public static double add(double x, double y, double z) {
        return x + y + z;
    }

上述代码中的方法都是add()，但是它们或者参数不同，或者数量不同，因此可以构成方法的重载

因此这样的情况是可以运行的。

2. 类 和 对象

2.1 什么是类，对象

类 是Java中的关键部分，如果是和 C语言中哪部分比较像，我觉得是结构体 struct。

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(比如狗的外观，样貌等)，哪些行为/功能(吃饭，睡觉，玩儿等等)，描述完成后通过对类进行实例化计算机就可以识别了。

关于对象，大家可能听说过，Java是一门面向对象的语言，而C语言是面向过程的语言。我们可以拿洗衣服来举例：

C语言就像是纯手洗，拿衣服--放进盆中--倒入洗衣粉--自己亲手洗--拧干。

Java就像是用全自动洗衣机来洗，只需要 放衣服和洗衣粉--洗衣机洗衣服，甩干。

所以，面向对象其实是一种解决问题的思想，依靠对象之间的交互来完成一件事。C语言更像是亲力亲为一件事，Java更像是有一个人或者机器来帮助你完成一件事，二者都有用处，并无好坏之分。

2.2 类的使用

类的定义格式：class + 类名 { 内容 }

class WashMachine{
    public String brand; // 品牌
    public String type; // 型号
    public double weight; // 重量
    public double length; // 长
    public double width; // 宽
    public double height; // 高
    public String color; // 颜色

    //成员方法：可不加static
    public void washClothes(){ // 洗衣服
        System.out.println("洗衣功能");
    }
    public void dryClothes(){ // 脱水
        System.out.println("脱水功能");
    }
    public void setTime(){ // 定时
        System.out.println("定时功能");
    }
}

上述代码就是一个定义好的类，从内容可以看出是关于洗衣机的。

其中包括了 成员方法 和 成员变量，成员变量是一种变量，只是存在于类中；而成员方法也是存在于类中才称作成员方法。其中成员方法中可以传入参数。

2.3 类的实例化

我们再定义一个狗类：

class PetDog {
    // 狗的属性
    public String name;//名字
    public String color;//颜色

    // 狗的行为
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}

也是一个很简单的类，当然可以在里面添加很多东西，比如成员变量可以添加 品种，年龄等等。

那么，写好的类怎么实现，这就要涉及类的实例化。

class PetDog {
    // 狗的属性
    public String name;//名字
    public String color;//颜色

    // 狗的行为
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}


//public 修饰的类的名字和文件名相同
public class Dog {
                   //在main方法中可以实例化类
    public static void main(String[] args){

        //通过new关键字，实例化了一个PetDog对象
        PetDog dog = new PetDog();
        //dog是一个引用，指向了PetDog
        //通过对象的引用，访问其属性
        dog.name = "阿黄";
        dog.color = "黄色";
        System.out.println(dog.name);
        System.out.println(dog.color);

        //调用成员方法
        dog.barks();
        dog.wag();

        //可以再实例化一个dog2
        PetDog dog2 = new PetDog();
        dog2.name = "小黑";
        dog2.color = "黑色";
        System.out.println(dog2.name);
        System.out.println(dog2.color);
        dog2.wag();
        dog2.barks();
    }
}

上述就是一个类的构建和实例化，用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

new 关键字用于创建一个对象的实例 .

使用 . 来访问对象中的属性和方法 .

同一个类可以创建多个实例 .

2.4 this 引用

为什么会提到 this 这个关键词，那是因为有时候会出现以下情况：

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

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

public class TestDate {
    public static void main(String[] args) {
        // 构造三个日期类型的对象 d1 d2 d3
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();
        // 对d1，d2，d3的日期设置
        d1.setDay(2020, 9, 15);
        d2.setDay(2020, 9, 16);
        d3.setDay(2020, 9, 17);
        // 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

在上述代码中，我们在类的成员方法中传入三个参数，year，moon 和 day，然后赋值，再实例化对象，一切都没有问题。但是如果传入的参数名字和成员变量名字相同时，就会出现问题。

public void setDay(int year, int month, int day){
    year = year;
    month = month;
    day = day;
}

比如像这样，这时候系统就会分不清到底是谁给谁赋值，谁是成员变量，就会报错。

这个时候，this 关键字就可以发挥作用了。

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

    //this 避免 形参名不小心与成员变量名相同
    public void setDay(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(this.year + "/" + this.month + "/" + this.day);
    }
}

public class Class_6_lei {
    public static void main(String[] args) {
        // 构造三个日期类型的对象 d1 d2 d3
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();
        // 对d1，d2，d3的日期设置
        //this引用的是调用成员方法的对象
        d1.setDay(2020, 9, 15);
        d2.setDay(2020, 9, 16);
        d3.setDay(2020, 9, 17);
        // 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

可以看到，使用 this. 就可以消除这种问题了，因为 this 引用的是调用成员方法的对象，所以可以实例化多个对象，this 也可以分辨出来，即哪个对象调用就是哪个对象的引用类型。

但需要注意的是，this 只能在类的成员方法中使用。

2.5 对象的初始化

如何初始化对象呢，这里有三种方法：1.构造方法 2.默认初始化 3.就地初始化

2.5.1 构造方法

比如我们先创建一个学生类，然后生成一个构造方法（IDEA中鼠标右键可以一键生成）

class Student{
    public String name;  // private修饰的成员变量，只能在该类中进行修改
    public int age;

    public Student(){
        this("lwb",25); //构造方法中，可以通过this调用其他构造方法来简化代码
        System.out.println("不带参数的构造方法");
    }

    public Student(int age) {  //鼠标右键一键生成构造方法
        this.age = age;
        System.out.println("带有一个参数的构造方法");
    }

    //构造方法
    public Student(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("带有两个参数的构造方法");
    }

    @Override //对象的打印 鼠标右键--生成--toString()
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}'; //可以自己编辑内容
    }

    //成员方法 区别：void
    public void Study(){
        System.out.println("姓名：" + this.name + "  " + "年龄：" + this.age + "  正在学习");
    }
}

可以看到，上述代码中一共有三个构造方法，分别是：不带参数，带一个参数和带两个参数。

而且因为三个构造方法还满足了方法的重载：名字相同，参数列表不同，因此构成了方法重载。

另外，如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

还有一点是，构造方法中，可以通过this调用其他构造方法来简化代码，比如代码中的，不带参数的构造方法中用 this () 调用了带有两个构造方法中的参数，简化了代码，这样在main方法中就可以不用在给参数赋值了。

2.5.2 默认初始化

当局部变量没有初始化的时候，系统是会报错的，比如：

public static void main(String[] args) {
    int a;
    System.out.println(a); // Error:(26, 28) java: 可能尚未初始化变量a
}

但是成员变量没有初始化时，系统会默认初始化，比如：

class Date_1{
    public int year;
    public int month;
    public int day;
    public Date(int year, int month, int day) {
        // 成员变量在定义时，并没有给初始值
        System.out.println(this.year);
        System.out.println(this.month);
        System.out.println(this.day);
    }
}


public class Date {
    public static void main(String[] args) {
        Date d = new Date(2021,6,9);
    }
}

系统会根据变量的类型默认初始化：

比如：int 类型会初始化为 0； boolean 类型会初始化为 false 等等。

2.5.3 就地初始化

就地初始化很简单，就是在声明成员变量时就定义好初始值：

class Date_1{
    public int year = 1900;
    public int month = 1;
    public int day = 1;    
}

这样做的缺点很明显，没有构造方法，或者在main方法中通过 new 关键字创建方便。

小结：

这次主要写了 Java 中的关键部分，类和对象。下面会写到与类相关的更重要的内容，封装，继承，多态 以及接口。这些也是和C语言不同的部分。