一、带参方法
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(){
//对象初始化代码
}
*/
//可以在构造方法中添加参数
/*
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);
}
}
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(){
//对象初始化代码
}
*/
//可以在构造方法中添加参数
/*
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();就是一个方法重载。
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方法和方法的重载内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
黄山市民网：https://www.huangshanshimin.com/
