1. 基本介绍 227
java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！
比如：System.out.println(); 可以输出不同类型的值
out 是 PrintStream 类型
1.1 重载的好处
1) 减轻了起名的麻烦
2) 减轻了记名的麻烦
1.2 例
public class Test31
{
public static void main(String[] args)
{
System.out.println(100);
System.out.println("hello,world");
System.out.println('h');
System.out.println(1.1);
System.out.println(true);
}
}
2. 方法重载的快速入门
2.1 具体案例 228
编写程序完成下列功能
1) calculate(int n1, int n2) //两个整数的和
2) calculate(int n1, double n2) //一个整数，一个 double 的和
3) calculate(double n1, int n2)//一个 double ,一个 Int 和
4) calculate(int n1, int n2,int n3)//三个 int 的和
public class Test31
{
public static void main(String[] args)
{
MyCalculator mc = new MyCalculator();
System.out.println(mc.calculate(1,2));//3匹配第一个方法
System.out.println(mc.calculate(1.1,2));//3匹配第三个方法
}
}
class MyCalculator
{
//下面四个calculate方法构成了重载
//两个整数的和
public int calculate(int n1, int n2)
{
return n1+n2;
}
//一个整数，一个 double 的和
public double calculate(int n1, double n2)
{
return n1+n2;
}
//一个 double ,一个 Int 和
public double calculate(double n1, int n2)
{
return n1+n2;
}
//三个 int 的和
public int calculate(int n1, int n2,int n3)
{
return n1+n2+n3;
}
}
3. 注意事项和使用细节 229
3.1 练习
3.1.1 判断 230
3.1.2 编程题 例1 231
编写程序，类 Methods 中定义三个重载方法并调用。方法名为 m。 三个方法分别接收一个 int 参数、两个 int 参数、一个字符串参数。分别执行平方运算并输出结果， 相乘并输出结果，输出字符串信息。在主类的 main ()方法中分别用参数区别调用三个方法 4
public class Test31
{
public static void main(String[] args)
{
Methods mc = new Methods();
mc.m(10);//100
mc.m(10,20);//200
mc.m("中国，hello");//中国，hello
}
}
class Methods
{
//分析
//1 方法名 m
//2 形参 (int)
//3.void
public void m(int n)
{
System.out.println("平方="+(n*n));
}
//分析
//1 方法名 m
//2 形参 (int,int)
//3.void
public void m(int n1,int n2)
{
System.out.println("相乘="+(n1*n2));
}
//分析
//1 方法名 m
//2 形参 (String)
//3.void
public void m(String str)
{
System.out.println("传入的str="+str);
}
}
3.1.3 编程题 例2 232
定义三个重载方法 max()，第一个方法，返回两个 int 值中的最大值， 第二个方法，返回两个 double 值中的最大值，第三个方法， 返回三个 double 值中的最大值，并分别调用三个方法
public class Test31
{
public static void main(String[] args)
{
Methods mc = new Methods();
System.out.println(mc.max(10,24));//24
System.out.println(mc.max(10.0,21.4));//21.4
System.out.println(mc.max(10.0,1.4,30.0));//30.0
}
}
class Methods
{
//分析
//1 方法名 max
//2 形参 (int,int)
//3.int
public int max(int n1,int n2)
{
return n1>n2?n1:n2;
}
//分析
//1 方法名 max
//2 形参 (double,double)
//3.double
public double max(double n1,double n2)
{
return n1>n2?n1:n2;
}
//分析
//1 方法名 max
//2 形参 (double,double,double)
//3.double
public double max(double n1,double n2,double n3)
{
//先比较前两个
double max1 = n1>n2?n1:n2;
//在比较
return max1>n3?max1:n3;
}
}
4. 可变参数基本概念
java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
就可以通过可变参数实现
4.1 基本语法
访问修饰符 返回类型 方法名(数据类型... 形参名) {
}
4.2 例 233
看一个案例 类 HspMethod，方法 sum 【可以计算 2 个数的和，3 个数的和 ， 4，5， 。。】
//看一个案例 类 HspMethod，方法 sum 【可以计算 2 个数的和，3 个数的和 ， 4，5， 。。】
public class Test32
{
public static void main(String[] args)
{
HspMethod m = new HspMethod();
System.out.println("和="+m.sum(1,3,5));//9
System.out.println("和="+m.sum(1,19));//20
}
}
class HspMethod
{
//可以计算 2 个数的和，3 个数的和 ， 4， 5， 。。
//可以使用方法重载
// public int sum(int n1,int n2)//2个数的和
// {
// return n1+n2;
// }
// public int sum(int n1,int n2，int n3)//3个数的和
// {
// return n1+n2+n3;
// }
// public int sum(int n1,int n2,int n3,int n4)//4个数的和
// {
// return n1+n2+n3+n4;
// }
//..... //上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化
//解读
//1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
//3. 遍历 nums 求和即可
public int sum(int...nums)
{
//System.out.println("接受的参数个数="+nums.length);
//把nums看成数组
//遍历
int ret = 0;
for(int i=0;i<nums.length;i++)
{
ret+=nums[i];
}
return ret;
}
}
5. 可变参数的注意事项 234
例1
2.1 可变参数的实参可以是数组
2.2 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
2.3 一个形参列表中只能有一个可变参数
public class Test32
{
public static void main(String[] args)
{
int arr[]={1,2,3};
T t1 = new T();
//可变参数的实参可以是数组
t1.f1(arr);//编译通过
}
}
class T
{
public void f1(int...nums)
{
System.out.println("长度="+nums.length);
}
//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
public void f2(String str,double...nums)//编译通过
{
}
//一个形参列表中只能有一个可变参数
public void f3(int...nums1,double...nums2)//错误
{
}
}
6. 可变参数练习 235
有三个方法，分别实现返回姓名和两门课成绩(总分)， 返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。 封装成一个可变参数的方法
public class Test32
{
public static void main(String[] args)
{
Method m = new Method();
System.out.println(m.showScore("张三",90.1,80.0));
System.out.println(m.showScore("李四",90.1,80.0,10));
System.out.println(m.showScore("王五",90.1,80.0,10,30.5,70));
}
}
class Method
{
//分析 1. 方法名 showScore 2. 形参(String ,double... ) 3. 返回 String
public String showScore(String name,double...scores)
{
//遍历求总成绩
double totalscore = 0;
for(int i=0;i<scores.length;i++)
{
totalscore+=scores[i];
}
return name+"有"+scores.length+"门课的成绩总分为="+totalscore;
}
}
7. 作用域 236
7.1 基本概念
//作用域
public class Test32
{
public static void main(String[] args)
{
}
}
class Cat
{
//全局变量：也就是属性，作用域为整个类体 Cat 类：cry eat 等方法使用属性
//属性在定义时，可以直接赋值
int age = 10; //指定的值是 10
//全局变量(属性)可以不赋值，直接使用，因为有默认值，
double weight; //默认值是 0.0
//局部变量必须赋值后，才能使用，因为没有默认值
public void hi()
{
int num;
String address;
System.out.println("num="+num);//报错
System.out.println("address="+address);//报错
System.out.println("weight="+weight);//正确
}
public void eat()
{
System.out.println("在eat中使用属性 age="+age);
}
public void cry()
{
//1. 局部变量一般是指在成员方法中定义的变量
//2. n 和 name 就是局部变量
//3. n 和 name 的作用域在 cry 方法中
int n = 10;
String name = "jack";
System.out.println("在cry中使用属性 age="+age);
}
}
