如何在java中重载方法

tangjin

作者

这篇文章给大家介绍如何在java中重载方法，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。

Java的特点有哪些

Java的特点有哪些 1.Java语言作为静态面向对象编程语言的代表，实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。 2.Java具有简单性、面向对象、分布式、安全性、平台独立与可移植性、动态性等特点。 3.使用Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

一、带参方法

1.1 带参方法的定义和调用

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

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

调用带参数的方法

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

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

packageKind.dh;

//定义榨汁机类
publicclassMethodWithParameters{
//属性:颜色价格
publicStringcolor;
publicdoubleprice;

publicvoidshowInfo(){
System.out.println("这是一台"+color+"的榨汁机，价格为:"+price+"元");
}

//方法:榨汁-前提:水果杯数-形式参数(形参):参数类型参数名称
publicvoidzhazhi(Stringfruit,intnum){
System.out.println(num+"杯"+fruit+"汁");
}
}

packageinstance.dh;

importKind.dh.MethodWithParameters;

importjava.util.Scanner;

publicclassMethodWithParametersTest{
publicstaticvoidmain(String[]args){
//创建对象
MethodWithParametersmethodWithParameters=newMethodWithParameters();
Scannerinput=newScanner(System.in);
System.out.println("请输入您的榨汁机的颜色:");
methodWithParameters.color=input.next();
System.out.println("请输入您的榨汁机的价格:");
methodWithParameters.price=input.nextDouble();
methodWithParameters.showInfo();
System.out.println("您想要榨什么果汁:");
Stringshuiguo=input.next();
System.out.println("您需要榨几杯果汁:");
intnum=input.nextInt();
//这里是实际参数(实参)
methodWithParameters.zhazhi(shuiguo,num);
}
}

1.2 带参方法使用注意事项

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

1.3 带参方法的应用

packageKind.dh;

//定义一个存放学生姓名的数组，实现添加、查找、和显示本班的学生的信息的方法
//学员信息管理系统
publicclassStudent02{
//属性:存放学生姓名的数组
//声明学生姓名的数组
String[]names=newString[30];

//1.添加学生的姓名
publicvoidaddName(Stringname){
//遍历学生姓名的数组，查询到数组中某一个元素为null则进行插入
for(inti=0;i<names.length;i++){
if(names[i]==null){
names[i]=name;
break;//插入学生的姓名后退出循环
}
}
}

//2.在固定的区间内，查找某一个学生
//start:其实查找的位置
//end:结束查找的位置
//name:查找的学生姓名
publicbooleansearchName(intstart,intend,Stringname){
booleanflag=true;//是否找到了该名学生，false没找到，反之找到了
for(inti=start-1;i<end;i++){
if(name.equals(names[i])){
flag=true;
break;
}
}
returnflag;
}

//显示本班的学生信息
publicvoidshowNames(){
System.out.println("本班的学员列表:");
for(inti=0;i<names.length;i++){
if(names[i]!=null){
System.out.println(names[i]+"\t");
break;
}
}
}
}

packageinstance.dh;

importKind.dh.Student02;

importjava.util.Scanner;

publicclassStudent02Test{
publicstaticvoidmain(String[]args){
Student02student02=newStudent02();
Scannerinput=newScanner(System.in);
for(inti=0;i<5;i++){
System.out.println("请输入第"+(i+1)+"个同学的姓名:");
Stringname=input.next();
student02.addName(name);
}
student02.showNames();
//查找某一个学生的信息
System.out.println("请输入要开始查找的位置:");
intstart=input.nextInt();
System.out.println("请输入要结束查找的位置:");
intend=input.nextInt();
System.out.println("请输入您要查找的学生的姓名:");
StringfindName=input.next();
booleanflag=student02.searchName(start,end,findName);
if(flag){
System.out.println("恭喜您已经查询到了学生的信息");
}else{
System.out.println("抱歉，没有查询到学生的相关信息");
}
}
}

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

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

packageKind.dh;
//学生类
publicclassStudent{
//属性:姓名年龄爱好
publicStringname;
publicintage;
publicStringlove;

//方法:输出个人信息
publicvoidshowInfo(){
System.out.println("我叫"+name+"现在"+age+"岁了"+"我的兴趣爱好是"+love);
}
}

packageKind.dh;

publicclassDemo{
publicvoidcalc1(intnum){
num=num+1;
}

publicvoidcalc2(Studentstudent){
student.age=student.age+1;
}
}

packageinstance.dh;

importKind.dh.Student;
importKind.dh.Demo;

publicclassDemoTest{
publicstaticvoidmain(String[]args){
Demotest=newDemo();
intn=8;
test.calc1(n);
Studentstudent=newStudent();
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

packageKind.dh;
//学生类
publicclassStudent{
//属性:姓名年龄爱好
publicStringname;
publicintage;
publicStringlove;
publicintscore;
//方法:输出个人信息
publicvoidshowInfo(){
//System.out.println("我叫"+name+"现在"+age+"岁了"+"我的兴趣爱好是"+love);
System.out.println(name+"的成绩是:"+score);
}
}

packageKind.dh;

//操作学生的成绩
publicclassModifyScore{
//修改小于60分的学生成绩
publicvoidmodifyStuScore(Student[]stus){
for(inti=0;i<stus.length;i++){
if(stus[i].score<60){
stus[i].score+=2;
}
}
}

//显示本组学生成绩信息
publicvoidshowStu(Student[]stus){
for(Studentstu:stus){
stu.showInfo();
}
}
}

packageinstance.dh;

importKind.dh.ModifyScore;
importKind.dh.Student;

publicclassModifyScoreTest{
publicstaticvoidmain(String[]args){
ModifyScoremodifyScore=newModifyScore();
//定义一个学生对象的数组
Studentstudent1=newStudent();
student1.name="张三";
student1.score=43;
Studentstudent2=newStudent();
student2.name="李四";
student2.score=59;
Studentstudent3=newStudent();
student3.name="王五";
student3.score=90;
Student[]students=newStudent[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的无参数构造方法构造方法是用来完成对象的初始化的，但是通常在代码中不需要手动书写，这是因为系统提供了默认的无参的构造方法。由于构造方法也属于方法的范畴，可见构造方法也可以指定参数。

构造方法的格式如下:

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

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

packageKind.dh;

//学生类
publicclassStudent{
//属性:姓名年龄爱好
publicStringname;
publicintage;
publicStringlove;
publicintscore;

//系统会自动生成一个无参构造方法
/*
publicStudent(){
//对象初始化代码
}
*/
//可以在构造方法中添加参数
/*
publicStudent(Stringname,intscore){
name=name;
score=score;
}
*/
//可以理解为这段代码
/*
publicStudent(Stringn,ints){
name=n;
score=s;
}
*/
publicStudent(Stringname,intscore){
this.name=name;
this.score=score;
}

//方法:输出个人信息
publicvoidshowInfo(){
//System.out.println("我叫"+name+"现在"+age+"岁了"+"我的兴趣爱好是"+love);
System.out.println(name+"的成绩是:"+score);
}
}

packageKind.dh;

//操作学生的成绩
publicclassModifyScore{
//修改小于60分的学生成绩
publicvoidmodifyStuScore(Student[]stus){
for(inti=0;i<stus.length;i++){
if(stus[i].score<60){
stus[i].score+=2;
}
}
}

//显示本组学生成绩信息
publicvoidshowStu(Student[]stus){
for(Studentstu:stus){
stu.showInfo();
}
}
}

packageinstance.dh;

importKind.dh.ModifyScore;
importKind.dh.Student;

publicclassModifyScoreTest{
publicstaticvoidmain(String[]args){
ModifyScoremodifyScore=newModifyScore();
//定义一个学生对象的数组
//在这里就实现了对象的初始化和赋值
Studentstudent1=newStudent("张三",43);
//student1.name="张三";
//student1.score=43;
Studentstudent2=newStudent("李四",59);
//student2.name="李四";
//student2.score=59;
Studentstudent3=newStudent("王五",90);
//student3.name="王五";
//student3.score=90;
Student[]students=newStudent[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);
}
}

代码中有这样的一段:

publicStudent(Stringname,intscore){
this.name=name;
this.score=score;
}

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

Studentstudent1=newStudent("张三",43);
Studentstudent2=newStudent("李四",59);
Studentstudent3=newStudent("王五",90);

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

2.1 this的其他用法

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

packageKind.dh;

//学生类
publicclassStudent{
//属性:姓名年龄爱好
publicStringname;
publicintage;
publicStringlove;
publicintscore;

//系统会自动生成一个无参构造方法
/*
publicStudent(){
//对象初始化代码
}
*/
//可以在构造方法中添加参数
/*
publicStudent(Stringname,intscore){
name=name;
score=score;
}
*/
//可以理解为这段代码
/*
publicStudent(Stringn,ints){
name=n;
score=s;
}
*/
publicStudent(Stringname,intscore){
this.name=name;
this.score=score;
}

//方法:输出个人信息
publicvoidshowInfo(){
//System.out.println("我叫"+name+"现在"+age+"岁了"+"我的兴趣爱好是"+love);
System.out.println(name+"的成绩是:"+score);
}
publicvoidmethod1(){
//showInfo();
//this可以调用普通方法
this.showInfo();
}
publicStudent(Stringname,intscore,intage){
/*
this.name=name;
this.score=score;
this.age=age;
*/
//上述代码等同于
this(name,score);
this.age=age;
//需要注意的是this调用构造方法时一定要写在第一句中。
}
}

三、方法重载

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

构造方法重载:

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

普通方法重载

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

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

packageKind.dh;

//实现简易计算器
publicclassCalc{
//实现两个整数相加操作
publicvoidadd(intnum1,intnum2){
intsum=num1+num2;
System.out.println(num1+"+"+num2+"="+sum);
}

//实现两个浮点数进行相加
publicvoidadd(doublenum1,doublenum2){
doublesum=num1+num2;
System.out.println(num1+"+"+num2+"="+sum);
}

//实现三个浮点数进行相加操作
publicvoidadd(doublenum1,doublenum2,doublenum3){
doublesum=num1+num2+num3;
System.out.println(num1+"+"+num2+"+"+num3+"="+sum);
}
}

packageinstance.dh;

importKind.dh.Calc;

publicclassCalcTest{
publicstaticvoidmain(String[]args){
Calccalc=newCalc();
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不会给局部变量赋初始值

注意:

在同一个方法中，不允许有同名称的局部变量在不同的方法中，可以有同名称的局部变量在同一个类中，成员变量和局部变量同名称时，局部变量具有更高的优先级

packagecn.zhz.Test.dh;

publicclassVar{
//属性:这里的是成员变量全局变量
//定义成员变量num和s
//系统默认给成员变量进行赋初始值，如果是int就是0，String就是null,double就是0.0
intnum;
Strings;
//在同一个类中，局部变量可以和全局变量同名称，但是同名的时候局部变量的优先级会更高一些
intvar=9;

//方法:这里的是成员方法
publicvoidm1(){
//这里的a的作用域在m1中
inta=1;
for(;a<=5;a++){
System.out.println("hello");
}
}

publicvoidm2(){
//这里的a的作用域在for循环中
for(intb=1;b<=5;b++){
System.out.println(b);
}
}

publicvoidm3(){
System.out.println(num);
System.out.println(s);
}

//参数也是一种变量，它做的是局部变量
publicvoidm4(intnum){
System.out.println("num="+num);
}

publicstaticvoidmain(String[]args){
////可以通过扩大a的变量范围来解决,此时a的作用域在main方法中
//inta=0;
//for(;a<=4;a++){
//System.out.println("hello");
//}
//System.out.println(a);//系统会找不到变量a
}
}

关于如何在java中重载方法就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。

阅读全文

发布于 2021-05-10 20:38:55

java