java_方法重载、可变参数、作用域

方法重载

基本介绍

java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！
比如：System.out.println(); out 是 PrintStream 类型

重载的好处

1. 减轻了起名的麻烦
2. 减轻了记名的麻烦

案例

public class OverLoad01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        // System.out.println(100);
        // System.out.println("hello,world");
        // System.out.println('h');
        // System.out.println(1.1);
        // System.out.println(true);
        //
        MyCalculator mc = new MyCalculator();
        System.out.println(mc.calculate(1, 2));
        System.out.println(mc.calculate(1.1, 2));
        System.out.println(mc.calculate(1, 2.1));
    }
}
class MyCalculator {
    //下面的四个 calculate 方法构成了重载
    //两个整数的和
    public int calculate(int n1, int n2) {
        System.out.println("calculate(int n1, int n2) 被调用");
        return n1 + n2;
    }

    //没有构成方法重载, 仍然是错误的，因为是方法的重复定义
    // public void calculate(int n1, int n2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // int res = n1 + n2;
    // }

    //看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了
    // public int calculate(int a1, int a2) {
    // System.out.println("calculate(int n1, int n2) 被调用");
    // return a1 + a2;
    // }

    //一个整数，一个 double 的和
    public double calculate(int n1, double n2) {
        return n1 + n2;
    }

    //一个 double ,一个 Int 和
    public double calculate(double n1, int n2) {
        System.out.println("calculate(double n1, int n2) 被调用..");
        return n1 + n2;
    }

    //三个 int 的和
    public int calculate(int n1, int n2,int n3) {
        return n1 + n2 + n2;
    }
}

注意事项和使用细节

练习题

public class OverLoadExercise {
    //编写一个 main 方法
    public static void main(String[] args) {
    
        Methods method = new Methods();
        method.m(10);
        method.m(10,20);
        method.m("您好 Hello");

        // 测试  筛选最大值
        System.out.println(method.max(10,24));
        System.out.println(method.max(10.0,21.4));
        System.out.println(method.max(10.0,1.4,30.0));
    }
}

class Methods {

/*定义三个重载方法 max()，第一个方法，返回两个 int 值中的最大值，
第二个方法，返回两个 double 值中的最大值，
第三个方法，返回三个 double 值中的最大值，并分别调用三个方法 */

    public int max(int n1,int n2){
        return n1>n2 ? n1; n2;
    }
    
    public double max(double n1,double n2) {
        return n1>n2 ? n1; n2;
    }

    public double max(double n1,double n2,double n3) {
        System.out.println("max(double n1, double n2, double n3)");
        double max1 =  n1>n2 ? n1; n2;
        return max1>n3?max1;n3;
    }

    public double max(double n1,double n2,int n3) {
        System.out.println("max(double n1, double n2, int n3)");
        double max1 = n1>n2 ? n1; n2;
        return max1>n3?max1;n3;
    }

    /* 编写程序，类 Methods 中定义三个重载方法并调用。方法名为 m。
    三个方法分别接收一个 int 参数、两个 int 参数、一个字符串参数。分别执行平方运算并输出结果，
    相乘并输出结果，输出字符串信息。在主类的 main ()方法中分别用参数区别调用三个方法 */

    public void m(int n) {
        System.out.println("平方=" + (n*n));
    }

    public void m(int n1,int n2) {
        System.out.println("相乘=" + (n1*n2));
    }

    public void m(String str) {
        System.out.println("传入的str = " + str);
    }
}

可变参数

基本概念

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

基本语法

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

案例

看一个案例 类 HspMethod，方法 sum 【可以计算 2 个数的和，3 个数的和 ， 4. 5， 。。】

public class VarParameter01 {
  
    //编写一个 main 方法
    public static void main(String[] args) {
        HspMethod m = new HspMethod();
        System.out.println(m.sum(1, 5, 100)); //106
        System.out.println(m.sum(1,19)); //20
    }
}

class HspMethod {
    //可以计算 2 个数的和，3 个数的和 ， 4. 5， 。。
    //可以使用方法重载
    // 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;
    // }
    // public int sum(int n1, int n2, int n3, int n4) {
        //4 个数的和
        // return n1 + n2 + n3 + n4;
    // }

    //..... 
    //上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化
    //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 class VarParameterDetail {
    public static void main(String[] args) {
        int[] arr = {1,2,34};
        T t1 = new T();
        t1.f1(arr);
    }
}

class T {


    //
    public void f1(int... sum){
        System.out.println(sum.length);
    }

    // 细节：可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
    public void f2(String str, double... nums) {

    }
    // 细节：一个形参列表中只能出现一个可变参数
    // 下面的写法是错误的
    public void f3(int... nums1,int... nums2) {

    }


}

练习

public class VarParameterExercise {
    public static void main(String[] args) {
        HspMethod hm =  new HspMethod();
        System.out.println(hm.showScore("milan",90.1,80.0));
        System.out.println(hm.showScore("jerry",90.1,80.0,10,30.5,70));

    }
}

class HspMethod {
    public String showScore(String name,double... scores) {

        double totalScore = 0;
        for(int i = 0;i<scores.length;i++) {
            totalScore += scores[i];
        }
        return name + "有 " + scores.length + " 门课的成绩总分为 " + totalScore;
    }
}

作用域

基本介绍

public class VarScope {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        cat1.hi();
        cat1.cry();
        cat1.eat();
    }
}

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);
        //System.out.println("在 eat 中使用 cry 的变量 name=" + name);//错误
    }
}

注意事项和使用细节

public class VarScopeDetail {

    //编写一个 main 方法
    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 = "hsp";//可以
    }
}