java方法和方法的重载

Love The Way You Lie 2022-11-15 11:59 144阅读 0赞

[java面向对象基础][java]

### 文章目录 ###

*  java方法和方法的重载
 *   *   *  带参方法
         *   *   *  带参方法的定义和调用
                 *  带参方法使用注意事项
                 *  带参方法的应用
                 *  基本数据类型和引用数据类型传参时的区别
                 *  方法传参-对象数组
         *  构造方法
         *   *   *  构造方法的格式如下:
                 *  this的其他用法
         *  方法重载
         *   *   *  成员变量和局部变量

# java方法和方法的重载 #

### 带参方法 ###

##### 带参方法的定义和调用 #####

之前定义的方法大部分都是无参方法，但是有些方法的执行是需要前提条件的，那么参数就是将这些前提条件传送过来  
定义带参数的方法:

> <访问修饰符> 返回值类型 <方法名称> (<形式参数列表>)\{  
> //方法的主体  
> \}

调用带参数的方法

> 对象名.方法名(参数1,参数2,参数3…参数n);

定义榨汁机的类，输出详细信息

package Kind.dh;
    
    //定义榨汁机类
    public class MethodWithParameters { 
        //属性:颜色 价格
        public String color;
        public double price;
    
        public void showInfo() { 
            System.out.println("这是一台" + color + "的榨汁机，价格为:" + price + "元");
        }
    
        //方法:榨汁-前提:水果 杯数-形式参数(形参):参数类型 参数名称
        public void zhazhi(String fruit, int num) { 
            System.out.println(num + "杯" + fruit + "汁");
        }
    }

package instance.dh;
    
    import Kind.dh.MethodWithParameters;
    
    import java.util.Scanner;
    
    public class MethodWithParametersTest { 
        public static void main(String[] args) { 
            //创建对象
            MethodWithParameters methodWithParameters = new MethodWithParameters();
            Scanner input = new Scanner(System.in);
            System.out.println("请输入您的榨汁机的颜色:");
            methodWithParameters.color = input.next();
            System.out.println("请输入您的榨汁机的价格:");
            methodWithParameters.price = input.nextDouble();
            methodWithParameters.showInfo();
            System.out.println("您想要榨什么果汁:");
            String shuiguo = input.next();
            System.out.println("您需要榨几杯果汁:");
            int num = input.nextInt();
            //这里是实际参数(实参)
            methodWithParameters.zhazhi(shuiguo, num);
        }
    }

##### 带参方法使用注意事项 #####

> 方法定义处的参数叫形式参数，方法调用处传的值为实际参数  
> 带参方法，参数个数可以有一个，也可以有多个，多个参数之间用逗号进行隔开  
> 带参方法，参数的名字可以随意的取，符合变量命名规则  
> 形参和实参的名字可以不一样，但是数据类型一定要一致，顺序要一样，个数要一样  
> 方法有没有参数和方法有没有返回值没有联系

##### 带参方法的应用 #####

package Kind.dh;
    
    //定义一个存放学生姓名的数组，实现添加、查找 、和显示本班的学生的信息的方法
    //学员信息管理系统
    public class Student02 { 
        //属性:存放学生姓名的数组
        //声明学生姓名的数组
        String[] names = new String[30];
    
        //1.添加学生的姓名
        public void addName(String name) { 
            //遍历学生姓名的数组，查询到数组中某一个元素为null则进行插入
            for (int i = 0; i < names.length; i++) { 
                if (names[i] == null) { 
                    names[i] = name;
                    break;//插入学生的姓名后退出循环
                }
            }
        }
    
        //2.在固定的区间内，查找某一个学生
        //start:其实查找的位置
        //end:结束查找的位置
        //name:查找的学生姓名
        public boolean searchName(int start, int end, String name) { 
            boolean flag = true;//是否找到了该名学生，false没找到，反之找到了
            for (int i = start - 1; i < end; i++) { 
                if (name.equals(names[i])) { 
                    flag = true;
                    break;
                }
            }
            return flag;
        }
    
        //显示本班的学生信息
        public void showNames() { 
            System.out.println("本班的学员列表:");
            for (int i = 0; i < names.length; i++) { 
                if (names[i] != null) { 
                    System.out.println(names[i] + "\t");
                    break;
                }
            }
        }
    }

package instance.dh;
    
    import Kind.dh.Student02;
    
    import java.util.Scanner;
    
    public class Student02Test { 
        public static void main(String[] args) { 
            Student02 student02 = new Student02();
            Scanner input = new Scanner(System.in);
            for (int i = 0; i < 5; i++) { 
                System.out.println("请输入第" + (i + 1) + "个同学的姓名:");
                String name = input.next();
                student02.addName(name);
            }
            student02.showNames();
            //查找某一个学生的信息
            System.out.println("请输入要开始查找的位置:");
            int start = input.nextInt();
            System.out.println("请输入要结束查找的位置:");
            int end = input.nextInt();
            System.out.println("请输入您要查找的学生的姓名:");
            String findName = input.next();
            boolean flag = student02.searchName(start, end, findName);
            if (flag) { 
                System.out.println("恭喜您已经查询到了学生的信息");
            } else { 
                System.out.println("抱歉，没有查询到学生的相关信息");
            }
        }
    }

##### 基本数据类型和引用数据类型传参时的区别 #####

定义学生类，并实现增1操作

package Kind.dh;
    //学生类
    public class Student { 
        //属性:姓名 年龄 爱好
        public String name;
        public int age;
        public String love;
    
        //方法:输出个人信息
        public void showInfo() { 
            System.out.println("我叫" + name + "现在" + age + "岁了" + "我的兴趣爱好是" + love);
        }
    }

package Kind.dh;
    
    public class Demo { 
        public void calc1(int num) { 
            num = num + 1;
        }
    
        public void calc2(Student student) { 
            student.age = student.age + 1;
        }
    }

package instance.dh;
    
    import Kind.dh.Student;
    import Kind.dh.Demo;
    
    public class DemoTest { 
        public static void main(String[] args) { 
            Demo test = new Demo();
            int n = 8;
            test.calc1(n);
            Student student = new Student();
            student.age = 18;
            test.calc2(student);
            System.out.println(n + "---" + student.age);
        }
    }

运行代码发现结果是`8---19`，但是我们想得到的是每一个结果自增1，应该是`9---19`才对，这是为什么呢？这是由于参数类型的不同，如果是基本数据类型(int char double boolean float),操作传递的是变量的值，改变一个变量的值不会影像另一个变量的值。但是参数如果是引用数据类型(自定义数据类型 数组 接口)，赋值时是将原对象的引用(也就是内存地址)传递给另一个引用。  
基本数据类型传参:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70]  
引用数据类型传参:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70 1]

##### 方法传参-对象数组 #####

定义学生类并赋值输出学生的成绩，定义一个修改学生的成绩的类，如果学生的的成绩小于60分则进行加2

package Kind.dh;
    //学生类
    public class Student { 
        //属性:姓名 年龄 爱好
        public String name;
        public int age;
        public String love;
        public int score;
        //方法:输出个人信息
        public void showInfo() { 
    // System.out.println("我叫" + name + "现在" + age + "岁了" + "我的兴趣爱好是" + love);
            System.out.println(name+"的成绩是:"+ score);
        }
    }

package Kind.dh;
    
    //操作学生的成绩
    public class ModifyScore { 
        //修改小于60分的学生成绩
        public void modifyStuScore(Student[] stus) { 
            for (int i = 0; i < stus.length; i++) { 
                if (stus[i].score < 60) { 
                    stus[i].score += 2;
                }
            }
        }
    
        //显示本组学生成绩信息
        public void showStu(Student[] stus) { 
            for (Student stu : stus) { 
                stu.showInfo();
            }
        }
    }

package instance.dh;
    
    import Kind.dh.ModifyScore;
    import Kind.dh.Student;
    
    public class ModifyScoreTest { 
        public static void main(String[] args) { 
            ModifyScore modifyScore = new ModifyScore();
            //定义一个学生对象的数组
            Student student1 = new Student();
            student1.name = "张三";
            student1.score = 43;
            Student student2 = new Student();
            student2.name = "李四";
            student2.score = 59;
            Student student3 = new Student();
            student3.name = "王五";
            student3.score = 90;
            Student[] students = new Student[3];
            students[0] = student1;
            students[1] = student2;
            students[2] = student3;
            //显示学生的信息、修改学生的成绩
            System.out.println("成绩修改前:");
            modifyScore.showStu(students);
            modifyScore.modifyStuScore(students);
            System.out.println("成绩修改后:");
            modifyScore.showStu(students);
        }
    }

### 构造方法 ###

new一个对象的时候要用到构造函数,例如Student student1 = new Student();这时调用的是Hello的无参数构造方法  
构造方法是用来完成对象的初始化的，但是通常在代码中不需要手动书写，这是因为系统提供了默认的无参的构造方法。由于构造方法也属于方法的范畴，可见构造方法也可以指定参数。

##### 构造方法的格式如下: #####

> 访问修饰符 构造方法名 ()\{  
> //初始化代码  
> \}

需要我们值得注意的是构造方法没有返回值类型，并且方法名和类名是相同的。有返回值类型的方法是常用的普通方法

package instance.dh;
    
    import Kind.dh.ModifyScore;
    import Kind.dh.Student;
    
    public class ModifyScoreTest { 
        public static void main(String[] args) { 
            ModifyScore modifyScore = new ModifyScore();
            //定义一个学生对象的数组
            //在这里就实现了对象的初始化和赋值
            Student student1 = new Student("张三", 43);
    // student1.name = "张三";
    // student1.score = 43;
            Student student2 = new Student("李四", 59);
    // student2.name = "李四";
    // student2.score = 59;
            Student student3 = new Student("王五", 90);
    // student3.name = "王五";
    // student3.score = 90;
            Student[] students = new Student[3];
            students[0] = student1;
            students[1] = student2;
            students[2] = student3;
            //显示学生的信息、修改学生的成绩
            System.out.println("成绩修改前:");
            modifyScore.showStu(students);
            modifyScore.modifyStuScore(students);
            System.out.println("成绩修改后:");
            modifyScore.showStu(students);
        }
    }

代码中有这样的一段:

public Student(String name, int score) { 
            this.name = name;
            this.score = score;
        }

这里的this关键字是代指当前对象

Student student1 = new Student("张三", 43);
    Student student2 = new Student("李四", 59);
    Student student3 = new Student("王五", 90);

所谓的当前对象指的是Student类经过实例化出的student1,student2,student3。程序执行创建了student1时，this代指的是student1；创建了student2时，this代指的是student2这个对象。  
如果代码中自定义了带参的构造方法后，系统不会再提供无参构造方法了

##### this的其他用法 #####

this可以调用类中的普通方法和构造方法

package Kind.dh;
    
    //学生类
    public class Student { 
        //属性:姓名 年龄 爱好
        public String name;
        public int age;
        public String love;
        public int score;
    
        //系统会自动生成一个无参构造方法
        /* public Student(){ //对象初始化代码 } */
        //可以在构造方法中添加参数
        /* public Student(String name,int score){ name = name; score = score; } */
        //可以理解为这段代码
        /* public Student(String n,int s){ name = n; score = s; } */
        public Student(String name, int score) { 
            this.name = name;
            this.score = score;
        }
    
        //方法:输出个人信息
        public void showInfo() { 
    // System.out.println("我叫" + name + "现在" + age + "岁了" + "我的兴趣爱好是" + love);
            System.out.println(name + "的成绩是:" + score);
        }
        public void method1(){ 
    // showInfo();
            //this可以调用普通方法
            this.showInfo();
        }
        public Student(String name,int score,int age){ 
            /* this.name = name; this.score = score; this.age = age; */
            //上述代码等同于
            this(name, score);
            this.age= age;
            //需要注意的是this调用构造方法时一定要写在第一句中。
        }
    }

### 方法重载 ###

方法分为了普通方法和构造方法，所以方法重载也相应的分为了普通方法重载和构造方法重载

*  构造方法重载:

> 方法名相同  
> 参数项不同  
> 和返回值、访问修饰符无关

*  普通方法重载

> 需要在同一个类中  
> 方法名相同  
> 参数个数或者是类型不同  
> 和返回值、访问修饰符无关

*  实现简易计算器，分别实现两个整数、两个浮点数、三个浮点数进行相加的操作

package Kind.dh;
    
    //实现简易计算器
    public class Calc { 
        //实现两个整数相加操作
        public void add(int num1, int num2) { 
            int sum = num1 + num2;
            System.out.println(num1 + " + " + num2 + " = " + sum);
        }
    
        //实现两个浮点数进行相加
        public void add(double num1, double num2) { 
            double sum = num1 + num2;
            System.out.println(num1 + " + " + num2 + " = " + sum);
        }
    
        //实现三个浮点数进行相加操作
        public void add(double num1, double num2, double num3) { 
            double sum = num1 + num2 + num3;
            System.out.println(num1 + " + " + num2 + " + " + num3 + " = " + sum);
        }
    }

package instance.dh;
    
    import Kind.dh.Calc;
    
    public class CalcTest { 
        public static void main(String[] args) { 
            Calc calc = new Calc();
            calc.add(2, 8);
            calc.add(2.3, 78.9);
            calc.add(23.4, 67.8, 90.8);
        }
    }

其实`System.out.println();`就是一个方法重载。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70 2]

##### 成员变量和局部变量 #####

变量声明的位置决定变量的作用域，变量的作用域确定可以在程序中按照变量名称访问该变量的区域。  
**成员变量和局部变量的区别:**

*  作用域不同  
    局部变量的作用在它的方法中  
    成员变量(全局变量)作用在整个类中
 *  初始值不同  
    java会给成员变量一个初始值  
    java不会给局部变量赋初始值
 *  注意:  
    在同一个方法中，不允许有同名称的局部变量  
    在不同的方法中，可以有同名称的局部变量  
    在同一个类中，成员变量和局部变量同名称时，局部变量具有更高的优先级

package cn.zhz.Test.dh;
    
    public class Var { 
        //属性:这里的是成员变量 全局变量
        //定义成员变量num和s
        //系统默认给成员变量进行赋初始值，如果是int就是0，String就是null,double就是0.0
        int num;
        String s;
        //在同一个类中，局部变量可以和全局变量同名称，但是同名的时候局部变量的优先级会更高一些
        int var = 9;
    
        //方法:这里的是成员方法
        public void m1() { 
            //这里的a的作用域在m1中
            int a = 1;
            for (; a <= 5; a++) { 
                System.out.println("hello");
            }
        }
    
        public void m2() { 
            //这里的a的作用域在for循环中
            for (int b = 1; b <= 5; b++) { 
                System.out.println(b);
            }
        }
    
        public void m3() { 
            System.out.println(num);
            System.out.println(s);
        }
    
        //参数也是一种变量，它做的是局部变量
        public void m4(int num) { 
            System.out.println("num = " + num);
        }
    
        public static void main(String[] args) { 
    // //可以通过扩大a的变量范围来解决,此时a的作用域在main方法中
    // int a = 0;
    // for(;a <= 4;a ++){ 
    // System.out.println("hello");
    // }
    // System.out.println(a);//系统会找不到变量a
        }
    }

[java面向对象之封装][java 1]

[java]: https://blog.csdn.net/qq_45671732/article/details/115187704
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70]: /images/20221022/fc3be71bbfa740d3a1df138b30f0eafc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210408144819324.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210410212642952.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy,size_16,color_FFFFFF,t_70
[java 1]: https://blog.csdn.net/qq_45671732/article/details/115594417