java-10方法带参

声明

Statement

文章用于本人个人学习记录，目前大一正处于学习之阶段，文章内容如引起不适请见谅。

本章核心内容

• 方法代参
• 方法参数传递
• 方法重载
• 面向对象和对象过程的区别

方法代参

1.构造方法带参

减少创建多个对象，减少代码的冗余

public class 类名{
    //成员变量
    private int id;
    private int age;
    private String name;
    
    //如果只定义了带参数的构造方法，会导致不会生成默认的无参构造方法
    //导致不能使用 类名 对象名 = new 类名();  定义需要代对应参数
    public 类名(){
        
    }
    
    public 类名(int id,int age,String name){
        this.id=id;
        this.age=age;
        this.name=name;
    }
}

创建对象时，输入的参数列表要与构造参数的参数类别一一对应

如：类名 object = new 类名(101,18,简-Jane);

2.方法带参

语法

访问修饰符 返回值类型 方法名(数据类型1 变量名1，数据类型2 变量名2，……){
    [return 返回值;]
}
//带参方法调用
对象名.方法名(参数类表);

return关键字的作用：给出方法的执行结果，结束代码

*如果一个带参的方法返回类型不为void，要给每一个分支情况给与一个返回值*

public int calculate(){
    switch(operator){
        case "+":
            return n1+n2;
        case "-":
            return n1-n2;
        case "*":
            return n1*n2;
        case "/":
            return n1/n2;
            
        //没有default 如operator有其他case，方法无返回值，会报错
        default: 
            return 0;
    }
}

3.对象数组

public class Student{
    private int id;
    private int age;
    private String name;
    
    public Student(){}
    
    public Student(int id,int age,String name){
        this.id=id;
        this.age=age;
        this.name=name;
    }
}
public studentTest(){
    public static void main(String[] args) {
        Student[] students = new Student[2];
        students[0] = new Student(01,18,"张三");
        students[1] = new Student(02,18,"李四");
    }
}

4.引用数据类型作为方法的参数

对象可以作为方法的参数被对象调用，当对象没有传入参数时为空，表示为null。

主要出现在一类对象对其他一类对象进行操作

如：老师要录入学生的成绩，要调用student中的参数

Teacher t1 =new Teacher();
//
……获取学生学号，年龄，姓名，用id,age,name保存数据
//
t.addStu(new Stu(id,age,name))
public Teacher(){
    ……
    public Stu[] stus={};
    public addStu(Stu stu){
        stus=Arrays.copyof(stus,stus.length+1);//让stus扩容
        stus[stus.length-1]=stu;//添加学生到末尾
    }
}

5.方法参数传递规则

方法内部改变输入参数，不会改变基本数据类型参数，如：int，double……

改变引用数据类型参数，会改变原先数据，如：String，object

个人认为

前者本质上传入的是数据的拷贝，所以形式上只是一个副本，副本改变原先值不改变

后者传入一个对应的地址，会将地址进行传递，方法通过地址就能改变传入的数据

---

方法重载

1.概念

在同一个类中，方法名相同，参数列表不同的多个方法构成方法重载

2.示例

public class calculate{
    public int sum(int a,int b){
        return a+b;
    }
    public int sum(int a,int b,int c){
        return a+b+c;
    }    
}
public class calculate{
    public int sum(int a,int b){
        return a+b;
    }
    public double sum(double a,double b){
        return a+b;
    }    
}

3.误区

• 1.参数类表相同，返回值不同，会报错

public class calculate{
    public int sum(int a,int b){
        return a+b;
    }
    public double sum(int a,int b){
        return a+b;
    }    
}

• 2.换汤不换药，方法重复

public class calculate{
    public int sum(int a,int b){
        return a+b;
    }
    public int sum(int c,int d){
        return c+d;
    }    
}

4.构造方法也可以重载

通过this可以调用其他构造函数

如下文的：this(1,18,100.0);

*this()调用构造方法必须是这个构造方法的第一句语句*

---

public class Stu{
    int id;
    int age;
    double score;
    
    public Stu(){
//        this.id=1;
//        this.age=18;
//        this.score=100.0;
        this(1,18,100.0);
    }
    public Stu(int id,int age,double score){
        this.id=id;
        this.age=age;
        this.score=score;
    }
}

面向过程和面向对象的区别

*Procedure Oriented Programming (POP)*

*vs*

*Object Oriented Programming (OOP)*

示例

POP

import java.util.Scanner;
/**
 * Procedure Oriented Programming 面向过程编程
 */
public class POP {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("1.学生成绩管理");
            System.out.println("2.学生选课管理");
            System.out.println("3.退出系统");
            System.out.println("请选择菜单编号：");
            int number = sc.nextInt();
            if(number == 1){
                outer:
                while (true){
                    System.out.println("1.增加成绩");
                    System.out.println("2.修改成绩");
                    System.out.println("3.删除成绩");
                    System.out.println("4.查询成绩");
                    System.out.println("5.返回主菜单");
                    System.out.println("请选择菜单编号：");
                    int order= sc.nextInt();
                    switch (order){
                        case 1:
                            System.out.println("你选择了增加成绩");
                            break;
                        case 2:
                            System.out.println("你选择了修改成绩");
                            break;
                        case 3:
                            System.out.println("你选择了删除成绩");
                            break;
                        case 4:
                            System.out.println("你选择了查询成绩");
                            break;
                        case 5:
                            break outer;
                    }
                }
            } else if(number == 2){
                System.out.println("你选择了学生选课管理");
            } else {
                System.out.println("感谢使用XXX系统");
                break;
            }
        }
    }
}

OOP

分析：

1. 该过程涉及的对象有两类，菜单和用户
2. 用户有执行增删改查的行为

public class Menu {
    public int order; //编号
    public String name; //名称
    public Menu(int order, String name){
        this.order = order;
        this.name = name;
    }
    public void show(){
        System.out.println(order + "." + name);
    }
}
public class User {
    public void addScore(){
        System.out.println("你选择了增加成绩");
    }
    public void deleteScore(){
        System.out.println("你选择了删除成绩");
    }
    public void updateScore(){
        System.out.println("你选择了修改成绩");
    }
    public void searchScore(){
        System.out.println("你选择了查询成绩");
    }
}
import java.util.Scanner;
/**
 * Object Oriented Programming 面向对象编程
 */
public class OOP {
    public static Menu[] mainMenus = {
            new Menu(1, "学生成绩管理"),
            new Menu(2, "学生选课管理"),
            new Menu(3, "退出系统")
    };
    public static Menu[] secondMenus = {
            new Menu(1, "增加成绩"),
            new Menu(2, "修改成绩"),
            new Menu(3, "删除成绩"),
            new Menu(4, "查询成绩"),
            new Menu(5, "返回主菜单")
    };
    public static Scanner sc = new Scanner(System.in);
    public static User user = new User();
    public static void main(String[] args) {
        gotoMain();
    }
    //去主菜单
    public static void gotoMain(){
        showMenus(mainMenus);//显示主菜单
        int number = sc.nextInt();
        if(number == 1){
            gotoSecond();
        } else if(number == 2){
            System.out.println("你选择了学生选课管理");
            gotoMain(); //去主菜单
        } else {
            System.out.println("感谢使用XXX系统");
        }
    }
    //去二级菜单
    public static void gotoSecond(){
        showMenus(secondMenus);//显示二级菜单
        int order = sc.nextInt();
        switch (order){
            case 1:
                user.addScore();//用户增加成绩
                gotoSecond();
                break;
            case 2:
                user.updateScore();//用户修改成绩
                gotoSecond();
                break;
            case 3:user.deleteScore();//用户删除成绩
                gotoSecond();
                break;
            case 4:
                user.searchScore();//用户查询成绩
                gotoSecond();
                break;
            case 5:
                gotoMain();
                break;
        }
    }
    public static void showMenus(Menu[] menus){
        for(int i=0; i<menus.length; i++){
            menus[i].show();
        }
        System.out.println("请选择菜单编号：");
    }
}

对比

面向过程侧重在过程中的实现上，面向对象侧重在对象上，需要利用对象的行为组装完成过程的组装