面向对象基础——可变参数（笔记）

基本概念

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现

基本语法

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

举例：计算n个数的和

public class test {
    public static void main(String[] args) {
        HspMethod m = new HspMethod();
        System.out.println(m.sum(1, 5, 100)); //106 
    }
}
class HspMethod {
//可以计算 2 个数的和，3 个数的和...。使用方法重载
// public int sum(int n1, int n2) {//2 个数的和
//	return n1 + n2;
// }
// public int sum(int n1, int n2, int n3) {//3 个数的和
//	return n1 + n2 + n3;
// }
//上面的两个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化

//1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
//3. 遍历 nums 求和即可
    public int sum(int... nums) {
//        System.out.println("接收的参数个数=" + nums.length);
        int res = 0;
        for (int i = 0; i < nums.length; i++) {
            res += nums[i];
        }
        return res;
    }
}

注意事项和使用细节

public void f1(int... nums) {}
public void f2(String str, double... nums) {}

变量作用域

基本使用

public class test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.hi();//num=1    address= 北 京 的 猫    weight=0.0
        cat.cry();//在 cry 中使用属性 age=10
        cat.eat();//在 eat 中使用属性 age=10
    }
}
class Cat {
//全局变量：也就是属性，作用域为整个类体 Cat 类：cry eat  等方法使用属性
//属性在定义时，可以直接赋值
    int age = 10; //指定的值是 10
    //全局变量(属性)可以不赋值，直接使用，因为有默认值，
    double weight;    //默认值是 0.0
    public void hi() {
//局部变量必须赋值后，才能使用，因为没有默认值
        int num = 1;
        String address = " 北 京 的 猫 ";
        System.out.println("num=" + num);
        System.out.println("address=" + address);
        System.out.println("weight=" + weight);//属性
    }
    public void cry() {
//1. 局部变量一般是指在成员方法中定义的变量
//2. n  和	name 就是局部变量
//3. n  和 name 的作用域在 cry 方法中
        int n = 10;
        String name = "jack";
        System.out.println("在 cry 中使用属性 age=" + age);
    }
    public void eat() {
        System.out.println("在 eat 中使用属性 age=" + age);
    }
}

注意事项和细节使用

public class test {
    public static void main(String[] args) {
        Person p1 = new Person();
        /*属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
		局部变量，生命周期较短，伴随着它的代码块的执行而创建，
		伴随着代码块的结束而销毁。即在一次方法调用过程中*/
        p1.say();//当执行say方法时，say方法的局部变量比如name,会创建，当say执行完毕后
        //name局部变量就销毁,但是属性(全局变量)仍然可以使用
        T t1 = new T();
        t1.test(); //第1种跨类访问对象属性的方式
        t1.test2(p1);//第2种跨类访问对象属性的方式
    }
}
class T {
    //全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
    public void test() {
        Person p1 = new Person();
        System.out.println(p1.name);//jack
    }

    public void test2(Person p) {
        System.out.println(p.name);//jack
    }
}
class Person {
    //细节: 属性可以加修饰符(public protected private..)
    //      局部变量不能加修饰符
    public int age = 20;
    String name = "jack";
    public void say() {
        //细节 属性和局部变量可以重名，访问时遵循就近原则
        String name = "king";
        System.out.println("say() name=" + name);
    }
    public void hi() {
        String address = "北京";
        //String address = "上海";//错误,重复定义变量
        String name = "jxl";//可以
    }
}