06 方法其他知识
一、方法重载
1.1 概念
方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同
注意
参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。
使用方法重载练习
public class Demo02MethodOverLoad {
public static void main(String[] args) {
//调用方法: 输出调用
System.out.println(getSum(10,20));
System.out.println(getSum(10,20,30));
System.out.println(getSum(10.0,20.0));
System.out.println(getSum(10.0,20.0,30.0));
}
//1.定义一个获取两个int数字之和的方法
public static int getSum(int a, int b) {
System.out.println("求两个int数字之和....");
return a + b;
}
//2.定义一个获取三个int数字之和的方法
public static int getSum(int a, int b,int c) {
System.out.println("求三个int数字之和....");
return a + b + c;
}
//3.定义一个获取两个double数字之和的方法
public static double getSum(double a, double b) {
System.out.println("求两个double数字之和....");
return a + b;
}
//4.定义一个获取三个double数字之和的方法
public static double getSum(double a, double b,double c) {
System.out.println("求三个double数字之和....");
return a + b + c;
}
}
1.2 方法重载注意事项一
/*
参数列表不同有哪些情况,可以构成重载?
1.参数的数量不同
2.参数的类型不同
3.多个类型顺序不同
方法重载关键看: 在方法名称相同的前提下,参数列表必须要有本质(名称不算)的区别
*/
public class Demo03MethodOverLoad {
public static void main(String[] args) {
}
//1.定义方法method,没有参数
public static void method() {
}
//2.定义方法method,有一个int参数
//1没有参数,2有一个参数,参数的数量不同,可以构成重载
public static void method(int a) {
}
//3.定义方法method,有一个double参数
//2有一个int参数,3有一个double参数,参数的类型不同,可以构成重载
public static void method(double a) {
}
//4.定义方法method,有一个int参数和一个double参数
public static void method(int a, double b) {
}
//5.定义方法method,有一个double参数和一个int参数
//4是先int后double,5是先double后int,多个类型顺序不同
public static void method(double a, int b) {
}
}
1.3 方法重载注意事项二
/*
方法重载与哪些因素无关?
1.与返回值类型无关
2.与参数名称无关
3.与修饰符无关
*/
public class Demo04MethodOverLoad {
public static void main(String[] args) {
}
//1.定义方法method,参数是一个int,一个double
public static int method(int a, double b) {
return 0;
}
//2.定义方法method,参数是一个int,一个double
//1返回int类型,2返回double类型,其它没有区别,不能构成重载,因为方法重载与返回值类型无关
/*public static double method(int a, double b) {
return 0.0;
}*/
//3.定义方法method,参数是一个int,一个double
//1.的参数名称叫a和b,3的参数名称叫c和d,其它没有却别,不能构成重载因为方法重载与参数名称无关
/*public static int method(int c, double d) {
return 0;
}*/
//4.定义方法method,参数是一个int,一个double
//1修饰符是public static,4修饰符是public,其它没区别,不能构成重载因为方法重载与修饰符无关
/*public int method(int a, double b) {
return 0;
}*/
}
二、方法的参数传递
形式参数:
在定义方法时,()中定义的变量,称为形式参数,定义时必须不能有值,方法被调用时,才会有值
实际参数:
在调用方法时,()中给定的参数(常量/变量),称为实际参数,如果是变量,则必须要有值
2.1 基本数据类型作为方法参数
/*特点:
形式参数的改变,不会影响实际参数
原因:
基本类型作为参数,传递的是具体的数据值
每个方法都有自己的内存空间,所以每个方法内部的变量也有自己的内存空间,
即便是不同的方法内部定义了同名的变量,他们的内存空间不同,它们之间互不影响,互不干扰
*/
public class Demo03BaseVar {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("ms..a="+a);//10
System.out.println("ms..b="+b);//20
//调用方法
change( a, b );//调用方法时,()中给出的参数,称为实际参数
System.out.println("me..a="+a);//10
System.out.println("me..b="+b);//20
}
//定义方法
public static void change(int a, int b) {//方法定义时,()中定义的变量,称为形式参数
System.out.println("cs..a="+a);//10
System.out.println("cs..b="+b);//20
a = a * 10;
b = b * 10;
System.out.println("ce..a="+a);//100
System.out.println("cd..b="+b);//200
return ;//结束方法,返回到调用处
}
}
2.2 引用数据类型作为方法参数
/*特点:
形式参数的改变,会影响实际参数
通过形参找到堆内存空间的数组,修改元素值后,再通过实参看到的是修改后的数组内容
原因:
引用变量保存的是堆内存空间的地址值,调用方法传递的是地址值,
导致多个变量指向同一个数组,只要有一个变量修改的数组的元素,
其它变量看到的都是修改后的元素
*/
public class Demo04RefVar {
public static void main(String[] args) {
int[] a = new int[] {10,20};//数组变量a保存数组在堆内存空间的地址
System.out.println("ms..a[0]="+a[0]);//10
System.out.println("ms..a[1]="+a[1]);//20
//调用方法: 传递的是地址值
change( a );//调用方法时,()中给出的参数,称为实际参数
System.out.println("me..a[0]="+a[0]);//100
System.out.println("me..a[1]="+a[1]);//200
}
//定义方法
public static void change(int[] a) {//方法定义时,()中定义的变量,称为形式参数
System.out.println("cs..a[0]="+a[0]);//10
System.out.println("cs..a[1]="+a[1]);//20
a[0] = a[0] * 10;
a[1] = a[1] * 10;
System.out.println("ce..a[0]="+a[0]);//100
System.out.println("ce..a[1]="+a[1]);//200
return ;//结束方法,返回到调用处
}
}
2.3 方法的参数练习一
import java.util.Arrays;
import java.util.Scanner;
public class Demo09 {
public static void main(String[] args) {
/*在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。*/
int[] array = getArray(6);
printArray(array);
int sum = getSum(array);
System.out.println("6个评委的总分为：" + sum);
int max = getMax(array);
System.out.println("6个评委中最高评分为：" + max);
int min = getMin(array);
System.out.println("6个评委中最低评分为：" + min);
int avg = (sum - max - min) / (array.length - 2);
System.out.println("去掉最高分去掉最低分后的平均分为：" + avg);
}
//获得数组
public static int[] getArray(int value_num) {
Scanner sc = new Scanner(System.in);
int[] array = new int[value_num];
for (int i = 0; i < array.length; i++) {
System.out.println("第" + (i + 1) + "个评委的分数为：");
array[i] = sc.nextInt();
}
return array;
}
//打印数组
public static void printArray(int[] array) {
System.out.println(Arrays.toString(array));
}
//获得数组中元素值的总和
public static int getSum(int[] array) {
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
return sum;
}
//获得数组中元素值的最大值
public static int getMax(int[] array) {
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (max < array[i]) {
max = array[i];
}
}
return max;
}
//获得数组中元素值的最小值
public static int getMin(int[] array) {
int min = array[0];
for (int i = 1; i < array.length; i++) {
if (min > array[i]) {
min = array[i];
}
}
return min;
}
}
2.4 练习二
方法一：
public class Demo11 {
public static void main(String[] args) {
/* 定义一个方法传入一个int类型数组，输出这个数组中每一个数字及其出现的个数
例如 传入数组[1,2,2,2,3,3,4,4,4,4] 打印结果：
数字1出现了1次
数字2出现了3次…*/
int[] array = {1,2,2,2,3,3,4,4,4,4};
printNum(array);
}
public static void printNum(int[] array) {
int[] new_array =new int[array.length];
int num = 0;
for (int i = 0; i < array.length; i++) {
boolean flag = true;
for (int i1 = i+1; i1 < array.length; i1++) {
if (array[i] == array[i1]) { //i索引后面有和array[i]相同元素的话，不把这个元素放到新的数组中
flag = false;
break;
}
}
if (flag) {
new_array[num] = array[i];
num++;
}
}
for (int i = 0; i < num; i++) {
int count = getNum(new_array[i],array);
System.out.println("数字"+new_array[i]+"出现了"+count+"次");
}
}
public static int getNum(int value,int[] array){
int num =0;
for (int i = 0; i < array.length; i++) {
if (array[i] == value) {
num++;
}
}
return num;
}
}
方法二：
package com.itheima.level02;
/*
* 定义一个方法传入一个int类型数组，输出这个数组中每一个数字及其出现的个数
例如 传入数组[1,2,2,2,3,3,4,4,4,4]
打印结果：
数字1出现了1次
数字2出现了3次…
如：原数组： int[] arr = {1,2,2,2,3,3,4,4,4,4,22,0,0}
记录出现的元素 int[] ele = {1,2,3,4,22,0}
记录元素出现的次数 int[] count = {1,3,2,4, 1,2}
*/
public class Task02 {
public static void main(String[] args) {
int[] arr = {1,2,2,2,3,3,4,4,4,4,22,0,0};
int[] ele = new int[arr.length];//记录出现的元素
ele[0] = arr[0]; //数字1
int index = 1; //已存到ele数组中元素数量
int[] count = new int[arr.length];//记录元素出现的个数
count[0] = 1; //记录出现1次
for (int i = 1; i < arr.length; i++) {
int element = arr[i];
//查找element元素在ele数组中是否存在
//存在，则元素出现个数+1，
boolean isFind = false;
for (int j = 0; j < index; j++) {
if (ele[j] == element) {
isFind = true;//说明已找到
count[j]++;//出现次数+1
}
}
if (!isFind) {//如果不存在，则元素存个ele数组中，并设置元素出现个数为1
ele[index] = element;
count[index] = 1;
index++;
}
}
//打印结果：
for (int i = 0; i < index; i++) {
//数字1出现了1次
System.out.println("数字"+ele[i]+"出现了"+count[i]+"次");
}
}
}
方法三：
public class Demo11 {
public static void main(String[] args) {
/* 定义一个方法传入一个int类型数组，输出这个数组中每一个数字及其出现的个数
例如 传入数组[1,2,2,2,3,3,4,4,4,4] 打印结果：
数字1出现了1次
数字2出现了3次…*/
/*定义一个方法传入一个int类型数组，输出这个数组中每个数字及其出现的个数
* 例如 传入数组[]*/
int[] array = {1,2,2,2,3,3,4,4,4,4};
printNum(array);
}
public static void printNum(int[] array) {
int num = 0;
for (int i = 0; i < array.length; i++) {
boolean flag = true;
for (int j = 0; j < i; j++) {
if (array[i] == array[j]) { //i的索引前面如果有和array[i]相同的元素的时候，不打印输出
flag = false;
break;
}
}
if (flag) {
int count = getNum(array[i], array);
System.out.println("数字"+array[i]+"出现了"+count+"次");
}
}
}
public static int getNum(int value,int[] array){
int num =0;
for (int i = 0; i < array.length; i++) {
if (array[i] == value) {
num++;
}
}
return num;
}
}
2.5 练习三
import java.util.Arrays;
public class Demo03 {
public static void main(String[] args) {
/*冒泡排序 {2,6,5,4,3,1} ----->{1,2,3,4,5,6}
第一步：{2,6,5,4,3,1}------->{2,5,4,3,1,6}
第二步：{2,5,4,3,1,6}------->{2,4,3,1,5,6}
...
最后一步：{2,1,3,4,5,6,}------>{1,2,3,4,5,6}*/
int[] array = {2,6,5,4,3,1};
for (int i = 1; i < 6; i++) {
getArray(array,i);
}
System.out.println(Arrays.toString(array));
}
public static void getArray(int[] array, int a) {
for (int i = 0; i < array.length-a; i++) {
if (array[i] > array[i + 1]) {
array[i] = array[i]^array[i+1];
array[i+1] = array[i]^array[i+1];
array[i] = array[i]^array[i+1];
}
}
}
}
三、随机数
3.1 Random产生随机数（掌握）
-
概述：
- Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能
- API后续课程详细讲解，现在可以简单理解为Java已经写好的代码
-
使用步骤：
-
导入包
import java.util.Random;
-
创建对象
Random r = new Random();
-
产生随机数
int num = r.nextInt(10);
解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0(包括)-9(包括)，括号写20，参数的随机数则是0(包括)-19(包括)
-
3.2 Random练习-猜数字
-
需求：程序自动生成一个1-100(包含1和100)之间的数字，使用程序实现猜出这个数字是多少？
-
效果：
- 如果猜的数字比真实数字大，提示你猜的数据大了
- 如果猜的数字比真实数字小，提示你猜的数据小了
- 如果猜的数字与真实数字相等，提示恭喜你猜中了
-
代码实现
/*
Random练习-猜数字
需求：程序自动生成一个1-100(包含1和100)之间的数字，使用程序实现猜出这个数字是多少？
效果：
如果猜的数字比真实数字大，提示你猜的数据大了
如果猜的数字比真实数字小，提示你猜的数据小了
如果猜的数字与真实数字相等，提示恭喜你猜中了
实现步骤:
1.创建Random类的对象
2.产生一个1-100(包含1和100)之间的数字保存到int变量guessNum中,以供大家猜测
3.创建键盘录入Scanner类的对象
4.到底多少次可以猜对,是不确定的,使用死循环(while(true))
4.1 获取键盘录入的用户猜测的数字,保存到int变量inputNum中
4.2 判断 如果用户猜测的inputNum中的数字 等于 产生的 guessNum 中的数字,说明猜对了
提示: "恭喜你猜中了"
使用break,结束循环
4.3 判断 如果用户猜测的inputNum中的数字 小于 产生的 guessNum 中的数字,说明没猜对
提示: "你猜的数据小了"
4.4 判断 如果用户猜测的inputNum中的数字 大于 产生的 guessNum 中的数字,说明没猜对
提示: "你猜的数据大了"
*/
public class Demo06GuessNum {
public static void main(String[] args) {
//1.创建Random类的对象
Random r = new Random();
//2.产生一个1-100(包含1和100)之间的数字保存到int变量guessNum中,以供大家猜测
int guessNum = r.nextInt(100) + 1;
//3.创建键盘录入Scanner类的对象
Scanner sc = new Scanner(System.in);
//4.到底多少次可以猜对,是不确定的,使用死循环(while(true))
while (true) {
//4.1 获取键盘录入的用户猜测的数字,保存到int变量inputNum中
System.out.println("请输入您猜测的数字(1到100之间的): ");
int inputNum = sc.nextInt();
//4.2 判断 如果用户猜测的inputNum中的数字 等于 产生的 guessNum 中的数字,说明猜对了
if (inputNum == guessNum) {
//提示: "恭喜你猜中了"
System.out.println("恭喜你猜中了");
//使用break,结束循环
break;
} else if (inputNum < guessNum) {
//4.3 判断 如果用户猜测的inputNum中的数字 小于 产生的 guessNum 中的数字,说明没猜对
//提示: "你猜的数据小了"
System.out.println("你猜的数据小了");
} else {
//4.4 判断 如果用户猜测的inputNum中的数字 大于 产生的 guessNum 中的数字,说明没猜对
//提示: "你猜的数据大了"
System.out.println("你猜的数据大了");
}
}
}
}
3.2 Random练习-电脑猜数字
import java.util.Random;
import java.util.Scanner;
public class Demo13 {
public static void main(String[] args) {
//输入一个0~100之间的数字，让电脑来猜，看需要多少次能够猜对
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数(0~100):");
int num = sc.nextInt();
Random rand = new Random();
int b = 0;
int c = 100;
int count = 1;
while (true) {
//boolean flag = true; //
int a = rand.nextInt(c - b + 1) + b;
System.out.println(a);
if (a > num) {
System.out.println("猜大了");
c = a - 1;
System.out.println("在" + b + "~" + c + "的范围内");
} else if (a < num) {
System.out.println("猜小了");
b = a + 1;
if (c == 101) {
System.out.println("在" + b + "~" + 100 + "的范围内");
}
System.out.println("在" + b + "~" + c + "的范围内");
} else {
System.out.println("恭喜您猜对了");
break;
}
count++;
}
System.out.println("一共猜了" + count + "次猜对");
}
}
浙公网安备 33010602011771号