面向对象编程-3

面向对象编程(基础部分)

方法重载(OverLoad)

java 中允许同一个类中有多个同名方法的存在，但要求形参列表不一致。

★方法重载使用细节

方法名：必须相同；

形参列表：必须不同（形参类型、个数、顺序，至少有一样不同，参数名无要求）；

public class Test {
    public static void main(String[] args) {

    }
}

/* 出错信息：
java: 已在类 Calculator 中定义了方法 calculate(int,int)
方法重载对参数名无要求，因此下面两个方法不构成重载，实际上就是同一个方法
 */
class Calculator {
    public int calculate(int n1, int n2) {
        return n1 + n2;
    }

    public int calculate(int a1, int a2) {
        return a1 + a2;
    }
}

返回类型：无要求。

public class Test {
    public static void main(String[] args) {

    }
}

/* 出错信息：
java: 已在类 Calculator 中定义了方法 calculate(int,int)
方法重载并不关心返回类型，所以下面其实是同一个方法，并没有构成方法重载
 */
class Calculator {
    public int calculate(int n1, int n2) {
        return n1 + n2;
    }

    public double calculate(int n1, int n2) {
        return n1 + n2;
    }
}

在判断是否是方法重载时，可抹掉返回类型、抹掉形参名，只看方法名、形参类型、形参顺序、形参个数，看是否构成方法重载。

可变参数

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

基本语法：

1 2	访问修饰符返回数据类型方法名(数据类型...形参名){ }

public class Test {
    public static void main(String[] args) {
        Methods method = new Methods();
        System.out.println(method.sum());
    }
}

class Methods {
    /*
    计算两数之和
    public int sum(int n1, int n2) {
        return n1 + n2;
    }

    计算三数之和
    public int sum(int n1, int n2, int n3) {
        return n1 + n2 + n3;
    }

    计算四数之和
    public int sum(int n1, int n2, int n3, int n4) {
        return n1 + n2 + n3 + n4;
    }
    */

    /*
    上述的三个方法，名称相同，功能相同，只是参数个数不同，因此可以用可变参数进行优化：
    1. int... 表示接收的是可变参数，类型是 int，即可以接收 0 到多个 int；
    2. 使用可变参数时，可以当作数组来使用
     */
    public int sum(int... nums) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }
}

可变参数细节

可变参数的实参可以为 0 个或者任意多个；

可变参数的实参可以为数组；

public class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        Methods method = new Methods();
        //输出为："可变参数长度为：3"
        method.foo(arr);
    }
}

class Methods {
    public void foo(int... nums) {
        System.out.println("可变参数长度为：" + nums.length);
    }
}

可变参数的本质就是数组；
可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数放在最后；
一个形参列表中只能出现一个可变参数。

★作用域

在 java 编程中，主要的变量就是属性（成员变量）和局部变量。
全局变量：即属性，作用域为整个类体，所以在成员方法中可以使用全局变量；
局部变量：在成员方法中或代码块中定义的变量，只能作用于定义其的代码块内。
注意：全局变量可以不赋值，直接使用，因为有默认值；局部变量必须赋值后才能使用，因为没有默认值。
代码块内定义的局部变量会覆盖同名的全局变量。

public class Test {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.name = "Snowball";
        c.cry();
    }
}

class Cat {
    //name 和 age 是全局变量
    String name;
    int age;

    public void cry() {
        //action 是局部变量
        String action = "running";
        System.out.println("在 cry() 中使用属性 name：" + name + " is crying");
        System.out.println("在 cry() 中使用局部变量 action：" + "It is " + action);
    }
}

作用域使用细节

属性和局部变量可以重名，访问时遵循就近原则；
在同一个作用域中，比如在同一个成员方法中，两个局部变量不能重名；
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
局部变量生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁，即生命周期在一次方法的调用过程中。
全局变量可以被本类使用，也可以被其他类使用（通过对象调用）；
局部变量只能在本类中的对应的方法中使用。
全局变量（即属性）可以加访问修饰符；
局部变量不可以加访问修饰符。

★构造方法/构造器

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。
它有几个特点：
1. 方法名和类名相同；
2. 没有返回值，也不能写 void；
3. 在创建对象时，系统会自动调用该类的构造器以完成对对象的初始化。

基本语法：

1
2
3

[修饰符] 方法名(形参列表){
	方法体;
}

注意：

构造器的修饰符可以默认；
构造器没有返回值，也不能写 void；
方法名和类名必须一致；
形参列表和成员方法的形参列表遵循一样的规则；
构造器的调用由系统完成。

public class Test {
    public static void main(String[] args) {
        //当 new 一个 Person 对象时，直接指定对象的名称和年龄
        Person p = new Person("小明", 10);
        p.printInfo();
    }
}

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void printInfo() {
        System.out.println(this.name + "的年龄为 " + this.age + " 岁。");
    }
}

★构造器细节

一个类可以定义多个不同的构造器，即构造器的重载；
构造器名和类名要相同；
构造器没有返回值；
构造器是对对象进行初始化，而不是创建对象；
在创建对象时，系统自动调用该类的构造方法；
如果程序员没有定义构造器，系统会自动给类生成一个默认的无参构造器(也叫默认构造器)，比如 Person (){}；
一旦定义了自己的构造器，默认的构造器就被覆盖了，就不能再使用默认的无参构造器，除非自己再显式地定义一下；
在创建对象时，会先调用父类的构造器，然后再调用自己的构造器。

★对象创建流程

![](../../../../../Running Noob/计算机/Typora笔记/笔记-git仓库/Java-notebook/img/Java/C7-10.jpg)

注意：对象的初始化分为三步：默认初始化 -> 显式初始化 -> 构造器初始化。

★this

Java 虚拟机会给每个对象分配 this，代表当前对象。
简单地说，哪个对象调用，this 就代表哪个对象。

★this使用细节

this 关键字可以用来访问本类的属性、方法、构造器；
this 用于区分当前类的属性和局部变量；
访问成员方法的语法：**this.方法名(参数列表)**；

访问构造器的语法：this(参数列表)；（只能在构造器中使用，即只能在构造器中访问另外一个构造器）

public class Test {
    public static void main(String[] args) {
        Person p = new Person("小明", 10);
        System.out.println("name = " + p.name + " age = " + p.age);
        /* 输出为：
        Person(String name) 构造器被调用，name = 小张
		Person(String name, int age) 构造器被调用，name = 小明 age = 10
		name = 小张 age = 10 */
    }
}

class Person {
    String name;
    int age;

    Person(String name) {
        this.name = name;
        System.out.println("Person(String name) 构造器被调用，name = " + name);
    }

    Person(String name, int age) {
        this("小张");
        this.age = age;
        System.out.println("Person(String name, int age) 构造器被调用，name = " + name + " age = " + age);
    }
}

注意：’this()’ 调用必须是构造函数主体中的第一条语句。

this 不能在类定义的外部使用，只能在类定义的方法中使用。