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

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

一、带参方法

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(StringxpFFSIYa[] 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分的学生成绩

pubxpFFSIYalic 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 = newxpFFSIYa 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

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。