Java面向对象（方法、方法重载，方法可变参数）

1 方法(类成员之二)

1.1 语法

[访问权限修饰符] [修饰符] 返回值类型 方法名([类型] 参数, [类型] 参数, ...){
    // 方法体
}

• 访问权限修饰符：private(私有)，默认(同包)，protected(子类)，public(公共)；
• 修饰符: static (静态)，final(最终)，native(底层基于C或C++实现重写)，abstract(抽象方法)，synchronized(线程锁)；
• 返回值类型：
  (1)无返回值类型：void；
  (2)有返回值类型：基本类型(8种)，引用类型(无数)；在方法的方法体中，必须要使用 return 返回值，返回值的类型要与定义方法的返回值类型要一致。
• 方法名：标识符的定义规则，首字母小写，其它单词首字母要大写：showMyInfos()；
• 类型：基本类型(8种)，引用类型(无数)；
• 参数：局部变量
  常规类型：固定参数 showMyInfos(int a)，showMyInfos(int[] array)，showMyInfos(String str) 等等；
  特殊类型：可变参数 showMyInfos(int … a)，调用形式 showMyInfos(11, 12, 14)，处理方式相当于 showMyInfos(int[] array)。

1.2 练习

（1）创建一个计算器类，实现两位数求和：CalcTest.java

/**
 * @author zc
 * @date 2021/10/20 11:43
 * 计算器测试类：CalcTest
 * main(String[] args)：程序运行主入口
 */
public class CalcTest {
    public static void main(String[] args) {
        // 创建一个 Calc 实例化对象 calc
        Calc calc = new Calc();
        // 给 calc 属性 n1 赋值
        calc.n1=10;
        // 给 calc 属性 n2 赋值
        calc.n2=8;

        // 调用 add() 方法，无返回值
        calc.add();

        // 调用 add2() 方法，有返回值需要接收再打印
		int he = calc.add2();
		System.out.println("两数和:" + he);

        // 调用方法 add3(int a ,int b)，a、b 参数实参(有值的参数)，无返回值
        int a = 10;
        int b = 5;
        calc.add3(a,b);

        // 调用方法 add4(int a ,int b)，a、b 参数实参(有值的参数)，有返回值需要接收再打印
        int he2 = calc.add4(a, b);
        System.out.println("两数和:" + he2);
    }

}

/**
 * 计算器的类
 * add()：无返回值，实现属性两位数 n1 n2 求和
 * add2()：有返回值，实现属性两位数 n1 n2 求和
 * add3(int a ,int b)：有参无返回值，实现两位数 a b 求和
 * add4(int a,int b)：有参有返回值，实现两位数 a b 求和
 */
class Calc {
    /**
     * 属性：n1,n2 求和的两数
     */
    int n1;
    int n2;

    /**
     * 无返回值，实现属性两位数 n1 n2 求和
     * void 在方法体实现功能
     */
    public void add() {
        System.out.println("两数的和:" + (n1 + n2));
    }

    /**
     * 有返回值，实现属性两位数 n1 n2 求和
     * @return 返回两数之和
     */
    public int add2() {  //无参有返回值的方法 ,返回了两数的和
        return n1+n2;
    }

    /**
     * 有参无返回值，实现两位数 a b 求和
     * @param a 待相加数
     * @param b 待相加数
     */
    public void add3(int a ,int b) {
        System.out.println("两数的和:" + (a + b));
    }

    /**
     * 有参有返回值，实现两位数 a b 求和
     * @param a 待相加数
     * @param b 待相加数
     * @return 返回两数之和
     */
    public int add4(int a,int b) {
        return a + b;
    }

}

程序运行如下：

两数的和:18
两数和:18
两数的和:15
两数和:15

（2）创建一个圆类，定义一个圆的半径属性，求圆的周长和面积：CircleTest.java
使用数学类工具包 java.lang.Math，半径 π：Math.PI；r 的平方：Math.pow(r, 2)。

/**
 * @author zc
 * @date 2021/10/20 14:26
 * 圆类测试：CircleTest
 * main(String[] arg)：主程序运行入口
 */
public class CircleTest {

    public static void main(String[] args) {
        // 新建一个 Circle 圆类的实例化对象 circle
        Circle circle = new Circle();
        // 给圆 circle 的属性 radius 半径赋值
        circle.radius = 1.2;
        // 调用方法 getLen() 获取圆的周长，无返回值
        circle.getLen();
        // 调用方法 getArea() 获取圆的面积，有返回值接收再打印
        double area = circle.getArea();
        System.out.println("圆的面积:" + area);

    }

}

/**
 * 圆类：Circle
 * radius：属性，圆的半径
 * getLen()：方法，无返回值，输出圆的周长
 * getArea()：方法，有返回值，返回圆的面积
 */
class Circle {
    /**
     * 属性：radius 半径
     */
    double radius;

    /**
     * 根据属性半径 radius 求圆的周长
     */
    public void getLen() {
        double len = Math.PI * radius * 2;
        System.out.println("周长:" + len);
    }

    /**
     * 根据属性半径 radius 求圆的面积
     * @return 返回面积
     */
    public double getArea() {
        // Math.pow(radius,2);  radius 的平方
        double area = Math.PI * Math.pow(radius, 2);
        return area;
    }

}

程序运行结果：

周长:7.5398223686155035
圆的面积:4.523893421169302

小数点四舍五入法请看 Java基础语法（浮点数四舍五入）

2 方法重载

2.1 特点

方法重载的特点是两必一可：

1. 在同一个类中，方法名必须相同；
2. 方法的参数列表必须不同：
   (1)参数的类型不同；
   (2)参数的个数不同；
   (3)参数的顺序不同。
3. 与方法的返回值类型无关：
   方法的返回值类型可以相同也可以不同。

2.2 练习

1、方法重载比较两数，三数大小，输出最大值：MaxTest.java

/**
 * @author zc
 * @date 2021/10/20 16:17
 * 比较比较两数,三数大小，求出最大值，测试类：MaxTest
 * main(String[] args)：程序运行主入口
 */
public class MaxTest {
	public static void main(String[] args) {
        Max m = new Max();

        int max1 = m.getMax(1, 3);
        System.out.println("最大值:" + max1);

        double max2 = m.getMax(4.5, 4);
        System.out.println("最大值:" + max2);

        double max3 = m.getMax(4.5, 4, 5.0);
        System.out.println("最大值:" + max3);
    }
}

/**
 * 类 Max：比较两数,三数大小
 * getMax(int a,int b)：方法，比较两数 a b 大小，返回最大的数
 * getMax(double a, double b)：方法，比较两数 a b 大小，返回最大的数
 * getMax(double a, double b, double c)：比较三数 a b c 大小，返回最大的数
 */
class Max {
    /**
     * 比较两数 a b 大小，返回最大的数
     * @param a 待比较的数，int 整型
     * @param b 待比较的数，int 整型
     * @return 返回 a b 中最大的数, int 整型
     */
    public int getMax(int a, int b) {
        return a > b ? a : b;
    }

    /**
     * 比较两数 a b 大小，返回最大的数
     * @param a 待比较的数，double 浮点型
     * @param b 待比较的数，double 浮点型
     * @return 返回 a b 中最大的数, double 浮点型
     */
    public double getMax(double a, double b) {
        return a > b ? a : b;
    }

    /**
     * 比较三数 a b c 大小，返回最大的数
     * @param a 待比较的数，double 浮点型
     * @param b 待比较的数，double 浮点型
     * @param c 待比较的数，double 浮点型
     * @return 返回 a b c 中最大的数, double 浮点型
     */
    public double getMax(double a, double b, double c) {
        //return (a > b) ? (a > c ? a : c) : (b > c ? b : c);
        return getMax(a, b) > c ? getMax(a, b) : c;
    }
}

程序运行输出：

最大值:3
最大值:4.5
最大值:5.0

2.3 任意类型作为方法的返回值

代码中释义：ReturnTest.java

/**
 * @author zc
 * @date 2021/10/20 16:50
 * 任意类型作为方法的返回值,测试类：ReturnTest
 * main(String[] args)：程序运行主入口
 */
public class ReturnTest {

    public static void main(String[] args) {
        // 1、直接操作汽车类 Car
        // 新建一个汽车类 Car 实例化对象 car
		Car car = new Car();
		// 给 car 属性 brand 赋值
        car.brand="奔驰";
        // 给 car 属性 color 赋值
        car.color="红色";
        // 调用方法 show() 展示汽车 car 属性信息
        car.show();

        System.out.println("==================");

        // 2、借助工厂生产汽车类 Factory 来生产汽车类 Car
        // 新建一个工厂生产汽车类 Factory 实例化对象 factory
        Factory factory = new Factory();
        // 调用方法 getCar() 获取 生产汽车类 Car 实例化对象 c1
        Car c1 = factory.getCar();
        // 需要自己给 c1 属性 brand 赋值
        c1.brand="宝马";
        // 需要自己给 c1 属性 color 赋值
        c1.color="粉红色";
        // 调用方法 show() 展示汽车 c1 属性信息
        c1.show();

        System.out.println("==================");
        // 调用方法 getCar("红旗H5", "黑色") 获取 生产汽车类 Car 实例化对象 c1,已经生产好
        Car c2 = factory.getCar("红旗H5", "黑色");
        // 直接展示汽车 c2 属性信息
        c2.show();
    }
}

/**
 * 工厂生产汽车类 Factory：创建汽车类 Car 的实例化对象
 * getCar()：方法，创建汽车类 Car 的一个实例化对象，并返回这个对象。
 * getCar(String bread,String color)
 */
class Factory{

    /**
     * 创建汽车类 Car 的一个实例化对象
     * @return 返回 Car 类型的一个实例化对象
     */
    public Car getCar() {
        Car c = new Car();
        return c;
    }

    /**
     * 创建汽车类 Car 的一个实例化对象,并为这个对象赋值属性
     * @param bread 对Car属性赋值
     * @param color 对Car属性赋值
     * @return 返回操作后的这个 Car 类型对象
     */
    public Car getCar(String bread,String color) {
        Car c = new Car();
        c.brand = bread;
        c.color = color;
        return c;
    }
}

/**
 * 汽车类 Car
 * brand：属性，汽车品牌
 * color：属性，汽车颜色
 * show()：方法，展示汽车属性
 *
 */
class Car{
    /**
     * 汽车品牌
     */
    String brand;

    /**
     * 汽车颜色
     */
    String color;

    /**
     * 展示汽车属性
     */
    public void show() {
        System.out.println("品牌："+brand+",颜色："+color);
    }

}

运行结果：

品牌：奔驰,颜色：红色
==================
品牌：宝马,颜色：粉红色
==================
品牌：红旗H5,颜色：黑色

2.4 任意类型(引用类型)作为方法参数

代码中释义：StudentTest.java

/**
 * @author zc
 * @date 2021/10/20 17:14
 * 任意类型(引用类型)作为方法参数,测试类：StudentTest
 * main(String[] args)：程序运行主入口
 */
public class StudentTest {
    
    public static void main(String[] args) {
        // 创建一个学生管理类 Manager 实例化对象 manager
        Manager manager = new Manager();
        // 创建一个学生类 Student 实例化对象 student
        Student student = new Student();
        // 将这个学生 student 交给 manager 管理来显示这个学生信息
        manager.test(student);

        // 为当前学生 student 属性 name 赋值
        student.name = "张三";
        // 学生自己展示自己的信息
        student.show();
    }
}

/**
 * 学生管理类 Manager
 * test(Student stu)：展示学生信息
 */
class Manager{

    /**
     * 展示学生信息
     * @param stu 传入学生对象
     */
    public void test(Student stu) {
        // 为当前学生 stu 属性 age 赋值
        stu.age = 20;
        // 调用学生信息显示方法 show()
        stu.show();
    }
}

/**
 * 学生类 Student
 * name：属性，学生姓名
 * age：属性，学生年龄
 * show()：方法，打印学生属性信息
 */
class Student{
    /**
     * 属性，学生姓名
     */
    String name;
    /**
     * 属性，学生年龄
     */
    int age;

    /**
     * 方法，打印学生属性信息
     */
    public void show() {
        System.out.println("姓名："+name+"，年龄："+age);
    }
}

2.5 数组作为参数或返回值

代码中释义：ArrayTest.java

import java.util.Arrays;

/**
 * @author zc
 * @date 2021/10/21 15:01
 * 将数组作为参数或返回值，测试类 ArrayTest
 * main(String[] args)：主程序运行入口
 * getMaxArray(int[] num)：输出数组 num 中的最大值
 * getSortArray(int[] num)：返回排序后的数组
 */
public class ArrayTest {

    /**
     * 主程序运行入口
     * @param args 系统参数
     */
    public static void main(String[] args) {
        int[] num = {13,25,23,18,24};
        System.out.println("原数组:" + Arrays.toString(num));
        System.out.println("--------------------------");
        getMaxArray(num);
        System.out.println("--------------------------");
        int[] sort = getSortArray(num);
        System.out.println("排序后:"+Arrays.toString(sort));
    }

    /**
     * 输出数组中的最大值
     * @param num 整型数组 int
     */
    public static void getMaxArray(int[] num) {
        int max = num[0];
        for(int i =1;i<num.length;i++) {
            if(max<num[i]) {
                max = num[i];
            }
        }
        System.out.println("最大值:" + max);
    }

    /**
     * 数组排序排序，从小到大
     * @param num 整型数组 int
     * @return 返回排序后的数组
     */
    public static int[] getSortArray(int[] num) {
        // 冒泡排序，从小到大
        for(int i = 0; i < num.length - 1; i++) {
            for(int j = 0; j < num.length - 1 - i; j++) {
                if(num[j] > num[j + 1]) {
                    int temp = num[j];
                    num[j] = num[j + 1];
                    num[j + 1] = temp;
                }
            }
        }
        return num;
    }

}

运行结果：

原数组:[13, 25, 23, 18, 24]
--------------------------
最大值:25
--------------------------
排序后:[13, 18, 23, 24, 25]

3 方法可变参数

1、语法：

[访问权限修饰符] [修饰符] 返回值类型 方法名(类型... 参数名) {
   // 方法体
}

2、特点：

1. 可变参数的方法与同名方法（除了数组参数的同名方法）构成重载；
2. 可变参数在参数列表中只能出现一次；
3. 如果有可变参数和固定参数，可变参数必须放在最后。

3、使用场景：

• 当参数的类型相同，个数不确定时可以使用可变参数。

4、代码释义：CalcTest.java

• 可变参数方法 add(int… num) 与 add(int a, int b)、add(int a, int b, int c) 构成重载。

/**
 * @author zc
 * @date 2021/10/21 15:21
 * 可变参数的测试类：CalcTest
 * main(String[] args)：主程序运行入口
 */
public class CalcTest {
    public static void main(String[] args) {
        // 创建计算器类 Calc 实例化对象 calc
        Calc calc = new Calc();
        // 调用可变参数方法 add(int... num) 求和
        calc.add(1,2,3,4,5);
    }
}

/**
 * 计算器类 Calc
 * add(int a, int b)：打印 a b 两数之和
 * add(int a, int b, int c)：打印 a b c 三数之和
 * add(int... num)：打印可变参数 num 中所有元素之和
 */
class Calc{

    /**
     * 打印 a b 两数之和
     * @param a 待相加的数，int 整型
     * @param b 待相加的数，int 整型
     */
    public void add(int a, int b) {
        System.out.println(a + b);
    }

    /**
     * 打印 a b c 三数之和
     * @param a 待相加的数，int 整型
     * @param b 待相加的数，int 整型
     * @param c 待相加的数，int 整型
     */
    public void add(int a, int b, int c) {
        System.out.println(a + b + c);
    }

    /**
     * 打印可变参数 num 中所有元素之和
     * @param num 可变参数，int 整型
     */
    public void add(int... num) {
        int sum = 0;
        for(int i = 0; i < num.length; i++) {
            sum += num[i];
        }
        System.out.println("可变参数中" + num.length + "个数的和为:" + sum);
    }
}

运行结果：

可变参数中5个数的和为:15

4 值类型(基本)和引用类型(类，数组)作为方法参数的区别

• 值类型(基本数据类型)不会保留修改；
• 引用类型(类，数组)会保留修改。

/**
 * @author zc
 * @date 2021/10/21 15:41
 */
public class Test1 {
    public static void main(String[] args) {
        int i=10,j=8;
        // 值类型，不会保留修改
		System.out.println("值类型交换前：i="+i+",j="+j);
		change(i,j);
		System.out.println("值类型交换后：i="+i+",j="+j);
        System.out.println("---------------------------------");
        // 引用类型，会保留修改
        Swap s = new Swap();
        s.i = 10;
        s.j = 8;
        System.out.println("引用类型交换前：i="+s.i+",j="+s.j);
        change(s);
        System.out.println("引用类型交换后：i="+s.i+",j="+s.j);
    }

    /**
     * 值类型两个参数交换
     * @param i 待交换的数，int 整型
     * @param j 待交换的数，int 整型
     */
    public static void change(int i,int j) {
        int temp = i;
        i = j;
        j = temp;
        //System.out.println("i="+i+",j="+j);
    }

    /**
     * 引用类型 Swap 作为方法参数
     * @param s Swap 实例化对象
     */
    public static void change(Swap s) {
        int temp = s.i;
        s.i = s.j;
        s.j = temp;
    }

}

/**
 * 引用类型 Swap
 */
class Swap{
    int i;
    int j;
}

运行结果：

值类型交换前：i=10,j=8
值类型交换后：i=10,j=8
---------------------------------
引用类型交换前：i=10,j=8
引用类型交换后：i=8,j=10