|
一、方法的定义 为什么要有方法
方法（又叫函数）就是代码功能的一段特定功能的代码块。方法提高程序的复用性和可读性。
比如有了方法，我们可以把重复使用的一段代码提炼出来，然后在每个需要执行这段代码的地方去调用即可。 在一个打飞机的游戏中，飞机需要发射子弹，那么我们可以把发射子弹的这段代码写成方法，这样就可以避免每次重写相同的代码。
方法的格式： 语法： 访问权限修饰符[ 其它的修饰符如static]返回值类型 方法名（参数类型1 形参1、参数类型2 形参2....）{//形参列表 //方法体 return返回值；
} getMenu(); //调用方法，此时方法才能被运行//public 访问权限修饰符//static 静态修饰符，描述的方法可以直接调用//void 返回值（无返回值）// // getMwn 方法名 定义一个方法，在没有调用时是不会执行的public static void getMenu(){System.out.println();}
方法的格式说明：
修饰符：目前就用public stati
返回值类型：就是功能结果的数据类型
方法名：见名知意，首字母小写，遵守驼峰命名法。方便调用。 二、方法的形参与实参
参数：
实际参数：就是实际参与运算的
形式参数：就是方法定义上的，用于接收实际参数的
参数类型：就是参数的数据类型
参数名：就是变量名
方法体语句：就是完成功能的代码 注意： 1、若当前方法中不要使用形参，那么形参列表中可以为空
2、实参和形参的类型要相i互兼容，且：实参的取值范围要小于或者等于形参类型的取值范围。 在调用方法中、如果我们定义的方法有参数，就必须在调用方法的同时传入这个值，即给当前方法中的参数值赋值，而这传入的值我们称为实际参数，也就是实参。 实参：传入的参数值
形参：接收实参传过来的值
注意：实参名与形参名可以相同，也可以不同 小结：形参就是一个变量，实参就是一个值，传参就是把一个值给一个形参赋值
3、方法的返回值
return:结束方法的
返回值：就是功能的结果，由return带给调用者 注意： 1、若当前方法没有返回值类型，即返回值类型是void，那么当前的方法中可以不写return
2、return即表示结束一个方法，也可以将返回值返回给调用当前方法的调用者 3、return返回值时一次只能返回一个值，不可以返回多个值 4、一个方法中可以有多个return,但被执行的只能有一个，所以需要判断 练习：
1、判断任意给定年份是否是闰年
//调用方法//杯子=榨汁机（香蕉，红苹果，鸡蛋） isRunNian(2020);//调用者 if(bool){ System.out.println("闰年"); }else{ System.out.println("平年"); } } public static boolean isRunNian(int year){ if (year %4==0 && year%100!=0) || (year %400==0){ return true; } else{ return false; } }
四、方法的重载
方法（函数）
方法重载：overloading method（在同一个类中，方法名相同，参数列表不同，返回值不能作为重载的条件）
在类中可以创建多个方法，他们具有相同的名字，但具有不同的参数和不同的定义：(返回值不能作为重载的条件）
public void method(int a){....}
public void method(char c){....}
五、数组的定义
数组：一组能够处理相同数据类型值的变量集合，当我们有一组相同类型的数据需要储存，如果此时使用单个变量来储存，我们将要定义若干个变量名，这样将会非常繁琐，并不利于维护。
六、数组的赋值方式
1、使用默认的初始值来初始化数组中的每一个元素 语法：数组元素类型[ ]scores=new int[3];
2、先声明，然后再赋值默认的初始值
语法：数组元素类型[ ]数组名；
数组名=new数组元素类型[数组中元素的个数（数组的长度）]；
如：int [ ]scores;
scores=new int[3]; 3、先声明，然后再使用指定的值进行初始化
语法：数组元素类型[ ]数组名=new 数组元素类型 [ ]{元素1、元素2...}； 如：int[ ]scores=new int[ ]{56、78、98}；
4、将第三种写法可以简化（使用数组常量值给数组进行赋值） 语法：数组元素类型[ ]数组名={元素1，元素2....}； 如：int [ ]scores={56,78,98};
七、数组的遍历
求数组的长度：
x.length
通过下标来访问数组中的元素。
下标：从零开始，到数组长度-1 如：int[ ]scores={89,90}; 访问最后一个元素值：int lastElement=scores[scores.length-1];
遍历：依次取出数组中的每一个元素
//数组的遍历int [] scores ={23,25,63};System.out.println("数组长度"+scores.length);//遍历 int len = scores.length; for(int i=0;i<len;i++){ int scores[i]; System.out.println(scores); } System.out.println(scores);}}
遍历方式一：普通的for循环
语法：for(int i=0;i<数组长度；i++){
//i:循环变量，同样:也是数组的下标（取值范围[ 0,数组长度）]
数组元素中的类型 变量=数组名[i];
} 八、增强for循环与可变参数 1.5 以后Java新增forcach循环可变参数 遍历方式二：使用增强for循环【forcach循环】
语法：for（数组中元素的类型 变量：数组名）{ 数组中元素的类型 临时变量=变量；
； 结合方法的定义，可以用可变参数来代替数组作为参数
public static void print(int...变量名{
//可变参数再使用时作为数组使用 } 使用数组时要注意的问题; 空指针异常（NullPointerException)
public static void print3(int [] x){//java.lang.NullPointerException//当一个变量为null(没有赋值）时，我们去调用了该变量的属性和方法 System.out.println("数组长度为":x.length};//测试数组的异常，数组下标越界//java.lang.ArrayIndexOutOfBoundsExceptionpublic static void print4(int[] x){for(int i=0;i<=x.length;i++){System.out.println(x[i]);}}}
数组越界异常（ArraylndexOutOfBoundsException)
数组内存结构分析：数组是引用类型，会存放在堆内存
names(栈内存) 运行速度高因为固定 大小固定、用于存储局部、临时变量（基本数据类型和引用变量）
" "（名字）(堆内存）运行速度慢，因为灵活需要计算 大小不不固定：对象
九、数组示例 1、猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数 import java.util.Random;//生成伪随机数 int [] nums = int []5; int len = nums length; Random r=new random();//创建可以生成随机数的工具 for(int i=0;i<leni++){ nums[i]=r.nextInt(50); } Scanner input new Scanner (Stytem.in); System.out.println("请输入你要猜的数：（60以内"）； int userNum = input.nextInt(); boolean flag = false; for (int x:nums ){ if(userNun==x){ flag = true; break; } } if(flag){ System.out.println("恭喜你，猜对了"); }else { System.out.println("不好意思，你猜错了"); } }
2、打印一个多正三角型 char[] cs = {'a','b','c','d','f','G'}; int len=cs length; for(int i=1;i<=len;i++){ for(int j=i;j<len;j++);System.out.println(" ");}for(int j=i;j<len;j++);System.out.println(" ");}for (int j=1; j<=i*2-1;j++){System.out.println(cs[i-1]);}System.out.println();
多维数组示例：Java中没有真正的多维数组多维数组的表示方式是数组中的元素还是数组。 1、一起来参加屌丝程序员大赛，有3个班级各3名学员参赛，记录每一个学员的成绩，并计算每个班级平均分。 int [] [] ={{78,98,88},{86,78,85},{87,96,85},{67,78,89}}; int classLen = scores.length; for(int i=0;i<classLen;i++}{ int nun=0; int count = scores[i].length; for(int j=0;j<count;j++){ num+scores[i][j]; } int avg = sum/count; System.out.println("第"+(i+1)+班级的平均分是："+avg); } } }
求最大值和最小值：
int [] num {12,3,54,66,79};int max = max(num);System.out.println("数列中最大的值是："+max);int min = min(num);System.out.println("数列中最小的值是："+min);}//求数列中最大的值public static int max (int [] num){ int max = num[0]; int len = num .length; for (int i=1;i<len;i++){ if(num [i]>max){ num[i]=num[i]+max; max=num[i]-max; num[i]=mun[i]-max; } } return min;} } }
十、冒泡排序 冒泡排序算法
冒泡排序的算法如下：（从后往前） 比较相邻的元素，如果第一个比第二个大，就交换它们两个。
对比一对相邻的元素作同样的工作，从开始一对到结尾最后一队。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 相同元素的前后顺序并没有变化，所以冒泡排序是一种稳定的排序算法
int [] nums = {12,15,56,36,45};//待排序的数列//外循环控制轮for(int i=0;i<nums.length-1;i++){//比较轮数等于列数的长度-1for (int j=0;j<nums.length-1;j++){if(nums[j]=nums[j]+nums[j+1]{nums[i]=nums[j]+nums[j+1];nums [j+1]=nums[j]-nums[j+1];nums[j]nums[j]-nums[j+1];}}}//输出结果for(int n : mans){System.out.println(n);}}
十一、选择排序算法 每一趟从待排序的元素中选出最小（或最大）的一个元素，顺序放在已经排好序的数列最后，直到全部待排序的数据元素排完，选择排序是不稳定的排序方法。
int [] nums = {12,15,56,36,45};//待排序的数列int minIndex = 0;//用于记录每次比较的最小值下标//控制轮数for (int i = 0;i<nums.length-1;i++):minIndex = i;//每轮假设一个最小值下标for (int j=i+1;j<nums.length;j++){if(nums[minIndex]>nums[j]){ minIndex=j; } } //判断需要交换的值下标是否为自己 if(minIndex!=i){ nums [minIndex ]=nums[minIdex]+nums[i]; nums [i]=nums [minIndex]-nums[i]; nums [minIndex]=nums[minIndex]-nums[i]; } } //输出结果 for (int n: nums){ System.out.println(n);}}
十二、选择排序算法
每一趟从待排序的数据元素选出最小（最大）的一个元素，顺序放在已排好序的列数的最后，直到全部待排序的元素排完，选择排序是不稳定的排序方法。 int [] nums = {12,15,56,36,45,99};//待排序的数列int minIndex = 0;//用于记录每次比较最小值的下标//控制轮数 for (int i=0;i<nums.length-1;i++){ minIndex = i;//每轮假设一个最小值下标 for(int j=i+1;j<nums.length;j++){ if (muns [minIndex]>mans[j]{ minIndex = j; } } //判断需要交换的数下标是否为自己 if(minIndex!=i){ muns [minIndex] = nums[mins[minIndex]+nuns[i]; numx [i] =muns [minIndex]-munx[i]; munx[minIndex] = numx[minIndex]-muns[i]; } } //输出结果 for(int m:muns){ System.out.prinyln(n); } }
十三、直接插入排序法 （从后向前找到合适的位置插入）
基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的子序列的合适位置（从后向前找到合适位置后）直到全部插入排序完为止
int [] nums = {12,15,56,36,45,99};//待排序的数列//控制比较的轮数 for(int i=1;i<nums.length;i++){ int temp =nums[i];//记录操作数 int j=0; for(j=i-1;j>=0;j--){ if(nums [j]>temp){ nums [j+1] = muns[j]; }else{ break; } } if(nums [j+1]!=temp){ nums=[j+1]=temp; } } //输出结果 for(int n: nums){ Systeem.out.printl（n)； }
}
十四、二分查找算法 二分查找算法（折半查找）：前提是在已经排好序的数组中，通过将待查找的元素与中间索引值对应的元素进行比较，若大于中间索引值对应的元素，去右边部分查找，否则，去左边部分查找，依次类推。直到找到为止，找不到返回一个负数。 //必须保证是数列有序 int num = {10,20,50.65,88,90}; int inddex = binarySearch(num,88); System.out.println(index); } //二分查找算法 public static int binarySearch(int [] num,int key){ int start=0;//开始下标 int end = num.length-1;//结束下标 while (start<=end){ int middle=(start+end)/2//>>>>1 if(num[middle]>key){ end = middle-1; }else if(num[middle]<ley){ start= middle +1; }else{ return middle; } } return -1; } }
十五、Arrays类 Arrays工具类：用来操作数组（比如排序和搜索）的各种方法
常用方法：
使用二分法查找 Arrays.binarySearch(int [ ] arrat,int value);
数组内容转成字符串的形成输出
Arrays.toString(int[ ] arry);
数组排序
Arrays.sort(int [ ] array);
复制指定的数组
Arrays.copyOf(int [ ] array.int length); Arrays.copyOf(int [ ] array.int from,int to); System.arraycopy(Object src,int srcPos,Object,int destPos,int length); 判断两个数组是否相等
Arrays.equels(); 使用指定元素填充数组
Arrays.fill(); import java.util.Arrays; int [] num = {45,65,76,87,98,901,}//二分查找 int index = Arrays.binarySearch(num,98); System.out.println("找到的下标是："+index); //输出数组 for(int n:num){ System.out,println(n); } //在测试输出数据时，可以使用，更加方便 System.out.println(Arrays.toString (num)); //排序 int num2={10,32,11,44,543,22,12}; Array.sort(num2);//快速排序 System.out.println(Arrays.toString(num2)); //数组的复制 int [] num2={10,32,11,44,543,22,12}; Arrays.sort(num2);//快速排序 System.out.println(Arrays.toString(num2)); //数组复制 int [] num3 = Arrays copyOf(num2,10); System.out,println(Arrays.toString(num3)); int [] newNun = new int[num2.length]; System.arraycopy(num2,0,newNun,o,num2.length); System.out.println(Arrays.toString(newNum)); //小结：数组复制 //效率从高到低排序是：System.arraycopy -> Arrays.copyOf->for //判断两个数组的值是否相等 System.out.println(Arrays.equals(num2,nuwNun)); //填充数组 Arrays fill(newNum,0); System.out.println(Arrays.toString(newNum)); } }
十六、双色球模拟综合案例 1、双色球彩票玩法 玩法说明： 双色球投注区分为红球号码区和蓝球号码区，红球号码范围为01~33，蓝球号码区为01~16。双色球从每期从33个红球中开出六个号码，从16个蓝球中开出一个号码作为中将号码，双色球玩法既是竞猜开奖号码中的6个红球号码和1个蓝球号码，顺序不限。 （1）案例分析： 1、如何产生蓝球和红球 2、如何接收用户选号 3、如何验证是否中奖 4、公布本期中奖号码 （2）实现步骤： 1、整体实现思路 2、随机取值不重复算法（系统和用户） 3、判断是否中奖的逻辑 4、结果输出 import.java.util.Sanner; import. java.util.arrays; import.java.util.Random; //定义相关变量 int [] userRedBall = new int[6]; //用户选择的红球号码 int [] sysRedBall = new int [6];//系统生成的红球号码 int [] userBlueBall = 0;//用户选择的蓝球 int [] sysBlueBall = 0;//系统生成的篮球 int [] redCount = 0;//记录用户选择记录的红球数 int [] blueCount = 0;//记录用户选择的正确蓝球数 int [] redBall = new int[33]; //需要随机生成六个在1~33之间不重复的数（算法） for (int i=0;i<redBall.length;i++){ redBall[i]=i+1; } //游戏开始，系统提示 System.out.println("双色球游戏开始，good luck!"); System.out.println("请问您是要机选还是手选号码（1：机选 2：手选"); Scanner input = new Scanner(System.in); Random r=new Random();//生成随机数工具 boolean flag = true;//用于判断是否重新输入机选或者是手选（意思就是除了1和2之外数必须是重输 while (flag){ int isAuto = input.nextInt(); switch(isAuto){ case 1: //机选 compterSelection(redBall,userRedBall);//机选红球 userRedBall = r.nextInt(16)+1;//机选蓝球 flag = false; break; case 2; //手选 System.out.println（"请选择6个红球号码(1~33):); for （int i=0; i<userRedBall.length;i++){ userRedBall[i] = input.nextInt(); } System.out.println("请选择一个蓝球号码（1~16）："); useblueBall = input.nextInt(); flag = false; break; default: System.out.println("请问您是要机选还是手选（1机选 2手选）； break; } } //系统随机生成的号码 //红球 computerSlection(redBall,sysRedBall); //蓝球 sysBlueBall = r.nextInt(16)+1; //统计结果 //统计红球 for （int i=0; i<userRedBall.length;i++){ for （int j=0; i<sysRedBall.length-redCount;j++){ if(userRedBall[i]==sysRedBall[j]; sysRedBall[j]=sysRedBall[sysRedBall.length-1-redCount]; userRedBall[sysRedBall.length-1-redCount]=temp; redCount++; break; } } } //统计蓝球数 if（userRedBall==sysRedBall）{ blueCount = 1; //验证是否中奖(中奖成功率排在前面） if(blueCount ==0 && redCount<==3){ System.out.println("革命尚未成功同志还要努力"); }else if(blueCount ==1 && redCount<==3){ System.out.println("中了六等奖5块钱"); }else if((blueCount ==1 && redCount<==3) || blueCount==0 && redCount==4)){ System.out.println("中了五等奖10块钱"); }else if((blueCount ==1 && redCount<==4) || blueCount==0 && redCount==5)){ System.out.println("中了四等奖200块钱"); }else if(blueCount =1 && redCount<==5){ System.out.println("中了三等奖3000块钱"); }else if(blueCount ==0 && redCount<==6){ System.out.println("中了二等奖150W"); }else if(blueCount ==1 && redCount<==){ System.out.println("中了一等奖500W"); }else{ System.out.println("系统有误中奖无效"); } //公布系统号码 System.out.println("本期中奖红号码为："); sort(sysRedBall); System.out.println(Aaaays.toStrings(ysRedBall)); System.out.println("本期中奖号码为："+ysRedBall); //公布用户号码 System.out.println("您选择的红号码为："); sort(userRedBall); System.out.println(Aaaays.toStrings(userRedBall)); System.out.println("本期中奖号码为："+userRedBall); System.out.println("买双色球造福你我！谢谢！！！") //冒泡排序 public static void sort(int[] ball){ for （int i=0; i<ball.length;i++){ for （int j=0; i<ball.length-1-i;j++){ if(ball [j]>ball [j+1] { ball[j] =ball[j]+ball[j+i]; ball[j] =ball[j+1]-ball[j+i]; ball[j] =ball[j]-ball[j+i]; } } } } //用于在指定数列中，随机生成多个不重复的数算法 public static void computerSelection(int[] redBall,int [] userRedBall ){ Random r = new Random(); int index = -1; for （int i=0; i<userRedBall.length;i++){ index = r.nextInt(redBall.length-i;); userRedBall[i] = redBall[index]; int temp = redBall[index]; redBall[index] = redBall.length-1-i]; redBall[redBall.length-1-i] = temp; } } }
|
