本篇的知识点有：方法的参数传递，构造方法，方法重载，成员变量和局部变量
为什么要用带参数的方法，就比如说去买果汁，买一杯橙汁，拿到手的就是橙汁，买一杯酸梅汁，拿到手的就是酸梅汁，将我们的需求放进方法里，就可以输出带参数的结果。
那我们如何使用带参数的方法呢？
定义带参数的方法：
<访问修饰符> 返回类型 <方法名>(<形式参数列表>) {
//方法的主体
}
调用带参数的方法：
对象名.方法名（参数1, 参数2,……，参数n）
后面的参数要与方法带的形参要一致，也就是说要与形参的数量，数据类型都要一致
例题：如何输出指定杯数的果汁
public class Demo1 {
String color;//品种
int num ;//数量
public static void main(String[] args) {
Demo1 d = new Demo1();
d.Juice("橙汁",2);
d.Juice("深水炸弹超超超大杯", 1);
}
public void Juice(String color,int num){
System.out.println("您的"+num+"杯"+color+"请慢用");
}
}
使用带参方法实现学员信息管理
增加学员姓名，在保存了多个学生姓名的数组中，指定查找区间，查找某个学生姓名并显示是否查找成功
class Student {
String[] name;// 姓名
int num;// 区间（num-1就是下标）
public void Search(String[] name, int num) {
if (num > 0 && num <= 5) {
System.out.println("查找成功：" + name[num - 1]);
} else {
System.out.println("查找失败");
}
}
}
public class Demo2 {
public static void main(String[] args) {
String[] name = new String[] { "狗娃", "狗剩", "狗蛋", "铁蛋", "毛旦" };
Scanner input = new Scanner(System.in);
int num = 5;//这是name数组的长度
while (true) {
System.out.println("请输入学员的姓名：(输入0退出添加功能)");//这时候应该让数组长度增加一位，还没学到集合，就用这种比较麻烦的方法
String names = input.next();
if(names.equals("0")){
break;
}
String [] newName = new String [num+1];//new新数组接受原数组
for(int i = 0;i<name.length; i++){
newName[i] = name[i];
}
for (int i = 0; i < newName.length; i++) {
if (newName[i] == null) {
newName[i] = names;
name = newName;//将新数组的值赋回原数组，因为之后经过循环增加数组长度的时候，新数组将全部重新赋值，
//也就是有新建了数组，这时候不将数据赋回老数组的话，就是数据丢失了
}
}
}
Student s = new Student();
System.out.println("请输入想查询的那位同学的编号：");
int num1 = input.nextInt();
s.Search(name,num1);
}
}
救过大神老师指导，修改了一下
import java.util.*;
class Student {
String[] name = new String[] { "狗娃", "狗剩", "狗蛋", "铁蛋", "毛旦" };// 姓名
public void Search(int start, int end, String names) {
int count = 0;//这个数用于判断是否查找成功，成功就给个别的值
if(end>name.length){//防止输入的最终值比数组长度长，那遍历数组就会报错空指针
end = name.length;
}else if(end<start){//防止输入最终值比开始值还小
System.out.println("输入错误，结束值比初始值小");
return;
}//start-1为初始值下标，end-1为最终值下标
for (int i = start-1; i <=end-1; i++) {
if (name[i].equals(names)) {
count = 1;
System.out.println("查找成功");
break;
}
}
if(count==0){
System.out.println("查找失败");
}
}
}
public class Demo2 {
public static void main(String[] args) {
Student s = new Student();
Scanner input = new Scanner(System.in);
System.out.println("请输入指定的区间开始值：");
int start = input.nextInt();
System.out.println("请输入指定的区间结束值：");
int end = input.nextInt();
System.out.println("请输入查询的学生姓名：");
String name = input.next();
s.Search(start, end, name);
}
}
关于调用要注意的几点，第一点，调用方法时不能指定实参类型，参数类型是在设置形参的时候就定好的，调用的时候不需要写类型。第二点，形参和实参的数据类型要一致，数量也要一致。
思考一下：以下代码输出的结果是什么
这一题的结果是8—19，为什么呢？基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。引用数据类型（类、数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用。所以这题的n带进去，n的本身不会变化，还是8，而stu.age是把自己的内存地址传递到形参里面，进行了操作，所以stu,age的值最终为19.
对象数组作参数
使用学员对象数组作为参数，实现学员成绩修改
如果学员成绩小于60，集体提高2分
class Student {
int score;
}
public class Demo2 {
public static void main(String[] args) {
Student[] stu = new Student[5];
stu[0]= new Student();
stu[0].score = 60;
stu[1]= new Student();
stu[1].score = 80;
stu[2]= new Student();
stu[2].score = 70;
stu[3]= new Student();
stu[3].score = 50;
stu[4]= new Student();
stu[4].score = 60;
System.out.println("每个学员的成绩为：");
for (int i = 0; i < stu.length; i++) {
System.out.print(stu[i].score + " ");
}
System.out.println();
scoreNew(stu);
System.out.println("修改过后的每个学员的成绩为：");
for (int i = 0; i < stu.length; i++) {
System.out.print(stu[i].score + " ");
}
}
public static void scoreNew(Student[] stu) {
for (int i = 0; i < stu.length; i++) {
if (stu[i].score < 60) {
for (int j = 0; j < stu.length; j++) {
stu[j].score += 2;
}
}
}
}
}
构造方法
先举个带参的例子
Student stu1=new Student("张三",40);
Student stu2=new Student("李四",90);
想要达到这种简单赋值的操作，就需要用到构造函数这个东西，构造函数的格式：
访问修饰符 构造方法名 ( ) {
//初始化代码
}
构造方法的作用就是给对象进行初始化，jvm会默认给一个无参的构造方法，所以平常如果不写构造函数的话，系统就默认是无参的构造方法，所以里面就不能写参数了
构造方法重载：
重载（Overload）是让类以统一的方式处理不同类型数据的一种手段，实质表现就是多个具有不同的参数个数或者类型的同名函数（返回值类型可随意，不能以返回类型作为重载函数的区分标准）同时存在于同一个类中，是一个类中多态性的一种表现（调用方法时通过传递不同参数个数和参数类型来决定具体使用哪个方法的多态性）。
————————————————
版权声明：本文为优快云博主「熊仙森」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/qunqunstyle99/article/details/81007712
这个是我在网上找的说的比较容易理解的版本了
构造方法重载的话和上面说的其实一样的，举个栗子
public Teacher() {
}
public Teacher(int age) {
this.age = age;
}
构造方法重载需要注意的事项有：
自定义构造方法
方法名相同
参数项不同
此时系统不再提供默认无参构造方法 。
也就是说写过有参的构造方法，还想再用无参的构造方法就必须再多写个无参的构造方法。
ps:this关键字：带参构造方法中this关键字
是对一个对象的默认引用，这里用以区分同名成员变量，也就是说this.变量名，就是该类的成员变量
this关键字的用法
this可以调用属性，调用方法，调用构造方法，意思都是调用本类中的成员属性、方法、构造方法
this.health = 100;
this.name = "大黄";
this.print();
this("小黑",100,100,"雄");
有个点要注意一下，如果调用无参构造方法，必须放在构造方法中的第一条语句
一个小题：阅读代码，并说出运行结果，指出原因
class Penguin {
//省略相关属性
public void Penguin() {
health=10;
sex="雄";
System.out.println("执行构造方法");
}
public void print() {
System.out.println("企鹅的名字是" + name + ",健康值是"
+ health + ",性别是" + sex);
}
}
Penguin pgn3= new Penguin();
pgn3.print();
这题输出的是null,0,null，因为构造函数是无返回值的，和void的意思不一样，如果写了void，那这个方法就不会再被自动调用了
所以总结一下方法重载：
同一个类中；
方法名相同；
参数个数或类型不同；
与返回值、访问修饰符无关。
练习：实现简易计算器，分别实现两个整数、三个浮点数的加法运算
import java.util.Scanner;
//实现简易计算器，分别实现两个整数、三个浮点数的加法运算
class Calculator {// 计算器类
int a;
int b;
double c;
double d;
double e;
public Calculator(int a, int b) {
this.a = a;
this.b = b;
System.out.println(a + "+" + b + "=" + (a + b));
}
public Calculator(double c, double d, double e) {
this.c = c;
this.d = d;
this.e = e;
System.out.println(c + "+" + d + "+" + e + "=" + (c + d + e));
}
}
public class Demo4 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while (true) {
System.out.println("选择整数运算请选择1/选择浮点运算请选择0");
int num = input.nextInt();
if (num == 1) {
System.out.println("请输入第一个数：");
int num1 = input.nextInt();
System.out.println("请输入第二个数：");
int num2 = input.nextInt();
Calculator c = new Calculator(num1,num2);
break;
}else if(num==0){
System.out.println("请输入第一个数：");
double num1 = input.nextInt();
System.out.println("请输入第二个数：");
double num2 = input.nextInt();
System.out.println("请输入第三个数：");
double num3 = input.nextInt();
Calculator c = new Calculator(num1,num2,num3);
break;
}else{
System.out.println("输入错误，请重新选择。");
continue;
}
}
}
}
成员变量和局部变量
变量声明的位置决定变量作用域
变量作用域确定可在程序中按变量名访问该变量的区域
成员变量就是声明在类的内部，方法的外部的变量，正常书写顺序在最上方，而局部变量是声明在方法的内部，就目前学习到的内容来看，最大的区别应该在于生命周期的区别，成员变量的生命周期在于所存在的该类的生命周期，只要类被使用，成员变量就会被使用，局部变量的生命周期则相对短了很多，他的存在范围只在于方法中，若是不调用这个方法，那这个局部变量就是死的，而且，由于只在自己的方法内部，所以其他的方法都是不能调用该局部变量的。也就是局部变量超出其作用域后不可用！成员变量与局部变量还有个区别，就是初始值的区别，成员变量可以不赋初始值，jvm会默认初始值，而局部变量则没有这种待遇了，书写的时候必须写初始值。
区别
作用域不同
---------局部变量的作用域仅限于定义它的方法
---------成员变量的作用域在整个类内部都是可见的
初始值不同
---------Java会给成员变量一个初始值
---------Java不会给局部变量赋予初始值
注意：在同一个方法中，不允许有同名局部变量，在不同的方法中，可以有同名局部变量。在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级。这时候想使用成员变量的话，则需要使用到this关键字了。
练习：说出一下代码运行结构
public class Test {
public int num;
public void calc(int num,int num2){
System.out.println(num+num2);
}
public static void main(String[] args) {
Test test = new Test();
test.num=10;
test.calc(11,3);
}
}
先将成员变量num赋值10，然后调用calc方法并传入参数11,3，这时候在calc方法中运算的都是局部变量，num虽然与成员变量num同名，但是根据使用变量的就近原则，没有使用this的就是局部变量，也就是方法中计算的是11+3，所以结构就是14
扫一扫
823
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
