首页 > 资讯 > 后端开发 > Python >java基础之方法和方法的重载详解

801

分享到

java基础之方法和方法的重载详解

2024-04-02 19:04:59 801人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录一、带参方法1.1 带参方法的定义和调用1.2 带参方法使用注意事项1.3 带参方法的应用1.4 基本数据类型和引用数据类型传参时的区别1.5 方法传参-对象数组二、构造方法2.

一、带参方法

1.1 带参方法的定义和调用

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

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

调用带参数的方法

对象名.方法名(参数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);
    }
}

1.2 带参方法使用注意事项

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

1.3 带参方法的应用


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.4 基本数据类型和引用数据类型传参时的区别

定义学生类，并实现增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),操作传递的是变量的值，改变一个变量的值不会影像另一个变量的值。但是参数如果是引用数据类型(自定义数据类型数组接口)，赋值时是将原对象的引用(也就是内存地址)传递给另一个引用。

基本数据类型传参:

在这里插入图片描述

引用数据类型传参:

在这里插入图片描述

1.5 方法传参-对象数组

定义学生类并赋值输出学生的成绩，定义一个修改学生的成绩的类，如果学生的的成绩小于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 Kind.dh;

//学生类
public class Student {
    //属性:姓名 年龄 爱好
    public String name;
    public int age;
    public String love;
    public int score;

    //系统会自动生成一个无参构造方法
    
    //可以在构造方法中添加参数
    
    //可以理解为这段代码
    
    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);
    }
}


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("张三", 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这个对象。
如果代码中自定义了带参的构造方法后，系统不会再提供无参构造方法了

2.1 this的其他用法

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


package Kind.dh;

//学生类
public class Student {
    //属性:姓名 年龄 爱好
    public String name;
    public int age;
    public String love;
    public int score;

    //系统会自动生成一个无参构造方法
    
    //可以在构造方法中添加参数
    
    //可以理解为这段代码
    
    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, 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();就是一个方法重载。

在这里插入图片描述

3.1 成员变量和局部变量

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

作用域不同

局部变量的作用在它的方法中
成员变量(全局变量)作用在整个类中

初始值不同

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方法和方法的重载内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: java基础之方法和方法的重载详解

本文链接: https://www.lsjlt.com/news/125451.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

java基础之方法和方法的重载详解

目录一、带参方法1.1 带参方法的定义和调用1.2 带参方法使用注意事项1.3 带参方法的应用1.4 基本数据类型和引用数据类型传参时的区别1.5 方法传参-对象数组二、构造方法2....

99+

2022-11-12
Java基础之方法重写详解

一、java方法重写方法的重写是子类根据需求对父类继承的方法进行重新的编写，在重写时，可以使用super方法的方式来保留父类中的方法，注意:构造方法不可以被重写。创建一个人类，属...

99+

2022-11-12
【Java 基础】类和对象 & 方法重载详解

《Java 零基础入门到精通》专栏持续更新中。通过本专栏你将学习到 Java 从入门到进阶再到实战的全套完整内容，所有内容均将集中于此专栏。无论是初学者还是有经验的开发人员，都可从本专栏获益。 ...

99+

2023-10-10

java 开发语言后端
java基础之方法详解

目录一、什么是方法二、方法的定义三、方法的调用四、方法的重载五、递归一、什么是方法 Java方法是语句的集合，他们在一起执行一个功能。 1.方法是解决一类问题的步骤的有序...

99+

2022-11-12
【Java 基础】类和对象 & 方法重载详解

《Java 零基础入门到精通》专栏持续更新中。通过本专栏你将学习到 Java 从入门到进阶再到实战的全套完整内容，所有内容均将集中于此专栏。无论是初学者还是有经验的开发人员，都可从本专栏获益。订阅专栏后添加我微信或者进交流群，...

99+

2023-08-21

java 开发语言后端
Java基础入门篇之如何理解方法和重载

本篇内容介绍了“Java基础入门篇之如何理解方法和重载”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！一、什么是方法简单来说方法就是一段可以被...

99+

2023-06-15
【Java基础篇】方法的使用（方法的重载和递归）

作者简介：辭七七，目前大一，正在学习C/C++，Java，Python等作者主页：七七的个人主页文章收录专栏：Java.SE，本专栏主要讲解运算符，程序逻辑控制，方法的使用，数组的使用，类和对象，继承和多态，抽象类和接口等内容 ...

99+

2023-08-20

java 开发语言 jvm
Java基础之详解HashSet的使用方法

Java HashSet HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。 HashSet 允许有 null 值。 HashSet 是无序的，即不会记录...

99+

2022-11-12
Java基础学习之方法的重载知识总结

目录一、什么是方法的重载？二、构成方法重载的条件三、重点一、什么是方法的重载？方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配...

99+

2022-11-12
Java构造方法和方法重载详解

目录第一构造方法的作用第二构造方法的特点方法重载总结类的结构包括 : 1. 成员变量 2. 成员方法 3. 构造方法 4. 代码块 5. 内部类第一构造方法的作用主要有以下...

99+

2022-11-13
Java基础学习之构造方法详解

目录一、构造方法概述二、构造方法的注意事项三、标准类制作一、构造方法概述构造方法是一种特殊的方法作用：创建对象Student stu = new Student(); 格式： p...

99+

2022-11-13
Java基础之FastJson的解决方法

这篇文章主要介绍了Java基础之FastJson的解决方法，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。一、fastJson将json格式字符串转化成List集合注：json...

99+

2023-06-15
Java基础之重载(Overload)与重写(Override)详解

目录一、重载（Overload）二、重写(Override)三、重写与重载之间的区别四、总结一、重载（Overload）重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相...

99+

2022-11-12
Python编程基础之构造方法和析构方法详解

目录一、本讲学习目标二、构造方法（一）概述（二）案例演示三、析构方法（一）概述（二）案例演示四、self的使用（一）self概述（二）案例演示总结一、本讲学习目标 1.掌握构造方法的...

99+

2022-11-13
详解Java中方法重写和方法重载的6个区别

目录1.方法重写1.1 基本用法1.2 使用场景1.3 注意事项2.方法重载2.1 基本使用2.2 使用场景2.3 注意事项3.方法重写 VS 方法重载总结方法重写（Override...

99+

2022-11-12
JavaScript基础系列之函数和方法详解

目录一、函数和方法的区别二、如何写好一个函数2.1 命名准确2.1.1 函数命名2.1.2 参数命名2.2 函数注释2.2.1 参数注释2.3 函数参数2.3.1 参数默...

99+

2022-11-12
【Java 基础篇】Java方法引用详解

文章目录导言一、方法引用的概念二、方法引用的语法三、方法引用的使用方法四、方法引用的限制和注意事项总结导言 Java方法引用是Java 8引入的一项重要特性，它提供了一种简洁、可读...

99+

2023-09-02

java jvm 开发语言
【Java基础篇】一文搞懂Java方法的调用与重载（超详细）

个人主页：兜里有颗棉花糖欢迎点赞👍 收藏✨ 留言✉ 加关注💓本文由兜里有颗棉花糖原创收录于专栏【JavaSE_primary】目录一、方法...

99+

2023-09-05

java 开发语言
Java基础第三篇构造器与方法重载

目录1、定义构造器2、初始化方法的优先级3、方法重载4、总结在方法与数据成员中，我们提到，Java中的对象在创建的时候会初始化(initialization)。初始化时，对象的数据成...

99+

2022-11-12
python基础之类方法和静态方法

目录类方法静态方法复习总结类方法 class People: country='China' # 类方法用classmethod来修饰 @classm...

99+

2022-11-12