这篇Java周记介绍了如何获取随机数，详细讲解了方法的定义与调用，包括有返回值和无返回值类型的方法。深入探讨了一维和二维数组的初始化、应用以及排序，并涉及了数组中的异常处理。还讨论了基本类型和引用类型作为参数传递的特点。
一.获取随机数的方法
java.lang.Math类，Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
获取随机数的方法介绍：
使用: public static double random() :取值范围[0.0,1.0)
eg:使用Math类中的方法 random()获取一个1-100之间的随机数
然后在键盘录入一个int类型的数据,猜产生的随机数!
分析:1)使用Math的random()产生一个1-100之间的随机数
2)然后使用Scanner:键盘录入录入int类型的数据
while(true){ //保证不断录入数据,不知道录入多少次,使用while循环
3)判断当前录入的数据和随机数的数据进行对比
break ; 结束while循环
实现代码
import java.util.Scanner;
class WhileTest2{
public static void main(String[] args){
//产生一个随机数:1-100之间
int number = (int)(Math.random()*100+1) ; //99
//为了保证不断的录入数据,使用while(true)
//定义一个统计变量
int count = 0 ;
while(true){
count ++ ;//统计变量++
//键盘录入数据
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请您输入一个要猜的数据:") ;
int guessNumber = sc.nextInt()
//判断
//键盘录入的数据大于产生的随机数
if(guessNumber > number){
System.out.println("您要猜的数据大了...") ;
}else if(guessNumber < number){
System.out.println("您要猜的数据小了...") ;
}else{
System.out.println("恭喜您,猜中了!!!") ;
break ;//结束了
}
}
}
二 .方法的定义
1，概念
将一个独立的代码块抽取出来使用{}将代码包裹起来,并给这个代码起一个名字:方法名---->以后直接使用方法名调用. {}代码块
**作用:提高代码的复用性**
2，有返回值类型的方法的定义
固定格式:
public static 返回值类型 方法名(形式参数类型1 参数名称1,形式参数类型2 参数名称2...){
业务需求...
return 结果;}
格式的详细介绍:
权限修饰符:public(公共的,访问权限足够大) static(静态)
返回值类型:数据类型(目前基本数据类型:四类八种: )
方法名:遵循标识符的规则(见名知意)
单个单词:全部小写
多个单独:第一个单词小写,从第二个单词开始,每个单词首字母大写,其余小写(小驼峰命名法)!
形式参数类型:数据类型(目前基本数据类型:四类八种: )
参数名称:变量名称
return: 这个方法调用完毕了,带回具体的结果!
有返回值类型的方法调用:
1)单独调用(没有意义)
2)输出调用:(可以用,不推荐!)直接输出,获取到的结果无法继续进行下一步操作!
System.out.println(add(a,b));
3)赋值调用:推荐获取到结果,可以继续其他业务操作!
int result = add(a,b) ;
System.out.println("result:"+result) ;
有具体返回值类型的方法定义的注意事项!
1)方法和方法平级关系,不能嵌套使用!
特殊:方法递归(IO流后面讲):方法调用方法本身的一种现象!
2)定义方法注意两个明确
明确返回值类型
明确参数类型以及参数个数
3)定义方法的时候:参数类型必须携带的!eg:public static int add(x,y){} 错误的:因为Java是一种强类型语言:语法非常严谨的,以及格式是有要求的!
4)定义方法的时候,()后面不要出现; (目前来说没意义的方法!)
5)调用方法的时候,实际参数不需要携带数据类型
要么没有具体结果;}
2，没有具体返回值类型的方法的
定义格式:
public static void 方法名(形式参数类型1 变量名1,形式参数类型2 变量名2...){直接输出语句或者其他业务操作;}
没有具体返回值类型的方法调用
单独调用
赋值调用
输出调用
存在问题:
方法的定义要遵循标识符的规则:见名知意!
目前这个方法的功能都是求和,如果一些方法的功能相同的,那么定义方法的时候:见名知意!
三．:方法重载 (overLoad) (方法名可以不可以相同呢?可以!)
方法名相同,参数列表不同,与返回值无关!
参数列表不同:
1)数据类型一样的,参数个数不同
2)参数个数一样,类型不同!
3）参数个数不一样,参数类型不同
四.java 中的内存分配
堆内存：new出来的东西
栈内存：一般存储局部变量
方法区：存储class文件
本地方法区：和系统相关
寄存器：与cpu有关
五.一维数组及其应用
基本概念
1.数组:是可以存储元素的一种容器!前提:元素的数据类型必须一致的!
特点:查询快
2.数组的定义格式:
数据类型[] 数组名称 ; int[] arr; (习惯于第一种) 定义了一个int类型数组arr变量
数据类型 数组名称[] ;int arr[] ;定义了一个int类型的arr数组
3.数组的初始化:
1)动态初始化:指定了数组长度,系统默认给定数组的元素值!
2)静态初始化:指定了具体的元素的内容,系统默认指定数组的长度!
动态初始化:
(1)数据类型[] 数组名称 = new 数据类型[数组长度];int[] arr = new int[3] ;
= ：号左边
int :表示当前数组是int类型:限定了元素的类型int
[] :是一个一维数组
arr :变量名称(数组对象名称)
=号右边
new :表示在内存中创建一个对象
int : 数据类型int类型
[] : 一维数组
3 : 在内存中指定3个长度(意味着:有3个元素)
( 2)数据类型 数组名称[] = new 数据类型[数组长度];int arr[] = new int[2] ;
数组的静态初始化 :指定数组的元素内容,系统给它默认长度
标准格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;
举例:int[] arr = new int[]{11,22,33} ;
简化格式:数据类型[] 数组名称 ={元素1,元素2,元素3....} ;
数据类型 数组名称[] ={元素1,元素2,元素3....} ;
举例:int[] arr = {1,2,3} ;
定义数组的时候:不能动,静集合(只能其中一种初始化方式!)
int[] arr = new int[3]{1,2,3} ; //错误的!
一维数组的基本应用
- 数组的遍历
//定义遍历数组的功能
//两个明确
//明确返回值类型: 没有具体的返回值:void 代替
//明确参数类型以及参数个数 :int类型 1个参数 数组
public static void printArray2(int[] arr){
System.out.print("{") ;
//遍历数组
for(int x = 0 ; x < arr.length ; x ++){
//判断
if(x == arr.length-1){ //遍历到了最后一个元素
System.out.println(arr[x] +"}") ;
}else{
System.out.print(arr[x] +", ") ; }
}
}
2.数组的最值问题:
分析:假设思想
1)将数组中第一个元素arr[0]看为最大值
2)从角标1开始遍历其他元素
分别将当前遍历的元素依次和最大值进行比较
如果当前元素大于最大值
将当前元素内容赋值max变量
class ArrayTest2{
public static void main(String[] args){
//创建一个数组:静态初始化
int[] arr = {13,87,65,24,57} ;
//赋值调用
int max = getMax(arr) ;
System.out.println("数组中的最大值是:"+max) ;
System.out.println("--------------------------------") ;
//获取最小值
int min = getMin(arr) ;
System.out.println("数组中的最小值是:"+min) ;
}
//方法
public static int getMin(int[] arr){
//参照物
int min = arr[0] ;//假设第一个元素是最小值
//从角标1开始遍历其他元素
for(int x =1 ; x < arr.length ; x ++){
//比较
if(arr[x] < min){
min = arr[x] ;
}
}
return min ;}
//定义一个方法
//明确返回值类型:int
//明确参数类型以及参数个数: int[] arr
public static int getMax(int[] arr){
//定义一个参照物
int max = arr[0] ;
//从角标1开始遍历其他元素
for(int x = 1 ; x < arr.length ; x ++){
//获取出来了
//分别将当前遍历的元素依次和最大值进行比较
if(arr[x] > max){
max = arr[x] ;
}
}
return max ;
}
}
- 数组的元素逆序
class ArrayTest3{
public static void main(String[] args){
//创建一个数组,静态初始化!
int[] arr = {13,87,65,24,57} ;
System.out.println("数组逆序前: ") ;
printArray(arr) ;
System.out.println("----------------") ;
System.out.println("数组逆序后: ") ;
//reverse(arr) ;//逆序方法
reverse2(arr) ;
printArray(arr) ;//遍历(输出结果)
}
//方式2:
publi
for(int start = 0 ,end = arr.length-1 ; start<end ; start ++,end --){ //中间变量互换
nt temp = arr[start] ;
arr[start] = arr[end] ;
arr[end] = temp ;
}}
//定义一个方法:逆序的方法
//两个明确
//明确返回值类型:没有具体返回值类型 void代替
//明确参数类型以及参数个数:int[] arr
//方式1:
public static void reverse(int[] arr){
//遍历数组:保证角标值小于数组长度/2
for(int x = 0 ; x < arr.length/2 ; x ++){
//中间变量方式互换
int temp = arr[x] ;
arr[x] = arr[arr.length-1-x] ; //后面的元素和前面的互换
arr[arr.length-1-x] = temp ;}
}
//数组的遍历功能:
public static void printArray(int[] arr){
System.out.print("[") ;
for(int x = 0 ; x < arr.length ; x ++){
//判断
if(x == arr.length-1){
System.out.println(arr[x]+"]") ;
}else{
System.out.print(arr[x] +", ") ;
}} }
}
4.数组元素查表法
数组名称[index:角标]访问元素
假设:字符串数组: 数据类型[] 数组名称 = new 数据类型[]{元素1,.} ;
String[] strs = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"} ;
需求:键盘录入数据:查询当前星期几
//导包
import java.util.Scanner ;
class ArrayTest4{
public static void main(String[] args){
//字符串数组
String[] strs = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"} ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数据(0-6):") ;
int index = sc.nextInt() ;
System.out.println("你要查询的是:"+strs[index]) ;}
}
5.数组的元素基本查找:
查询数组中的元素在数组索引值! (有一定的耗时:从头查到末尾)
查询的数组: 可以无序的,也可以有序
{11,22,33,44,55} ; 有序的
{13,87,65,24,57} ;//无序 假设:
int[] arr = {13,87,65,24,57} ;
查询65这个元素在数组中的出现的索引值!
class ArrayTest5{
public static void main(String[] args){
//创建一个数组,静态初始化
int[] arr = {13,87,65,24,57} ;
//1)查询65这个元素在数组中的出现的索引值!（使用方法來完成）
int index = getIndex(arr,65) ;
System.out.println("index:"+index) ;
System.out.println("------------") ;
int index2 = getIndex(arr,650) ;
System.out.println("index2:"+index2) ;
System.out.println("------------") ;
int index3 = getIndex2(arr,300) ;
System.out.println("index3:"+index3) ;
System.out.println("------------") ;
int index4 = getIndex2(arr,13) ;
System.out.println("index4:"+index4) ;
}
//方式2:
假设思想:1)假设找不到 定义一个变量 int index = -1 ;
2 )遍历数组,获取到每一个元素,如果当前元素和要查询的元素一致的话,改变index的值(将当前元素所在的角标值赋值给index)break ;
3)找不到,直接返回index
public static int getIndex2(int[] arr,int key){
//假设找不到
int index = -1 ;
//遍历arr数组
for(int x = 0 ; x < arr.length ; x ++){
//获取到每一个元素
//和key进行比较
if(arr[x] == key){
//找到了,改变index的值
index = x ;
break ;}}
return index ;
}
/*
两个明确:
1)明确返回值类型: int类型
2)明确参数类型以及参数个数:
//参数1:要查询的数组
//参数2:要查询的元素
int类型 两个参数: int[] arr , int key(元素)
*/
//方式1
public static int getIndex(int[] arr,int key){
//1)先去遍历arr数组
for(int x = 0 ; x < arr.length ; x ++){
//每一个元素都获取到了
//如果arr[x] 和可以 相等的话
//直接返回x :角标即可!
if(arr[x] == key){ //查询到了,返回x
return x ;
}
}
//写逻辑判断:
//两种:true,成立
//false,不成立
//如果找不到,Java中给定一个负数即可!
return -1 ;}
}
六. 数组的高级排序
冒泡排序法:
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处,依次这样比较
规律:两两比较,大的往后放, 第一次:有0个不比
第二次:有1个不比
.比较的次数:数组长度-1次
Eg: 定义排序的方法,两个明确
1)明确返回值类型: 没有具体返回值:void 代替
2)明确参数类型以及参数个数int[] arr
public static void bubboleSort(int[] arr){
for(int x = 0 ; x < arr.length-1 ; x ++){ //x 控制比较的次数
for(int y = 0 ; y < arr.length-1-x ; y++){//y表示元素的角标
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ;
}
}
}
}
七。 二维数组及其应用
二维数组:它就是一个包含多个一维数组的数组!
二维数数组的初始化
格式1:
数据类型[][] 数组名称 = new 数据类型[m][n] ;
//m:表示有m个一维数组
//n:表示每一个一维数组的长度
格式2:数据类型[][] 数组名称 = new 数据类型[m][] ;
//m:表示二维数组中有m个一维数组
每一个一维数组的长度需要动态给定
//举例:arr[0] = new int[2] ;
格式3:静态初始化
数据类型[][] 数组名称 =new 数据类型[][]{{元素1,元素2,,,},{元素1,元素2...},{...}} ;
简写格式:
数据类型[][] 数组名称 = {{元素1,元素2,,,},{元素1,元素2...},{...}} ;
//要么动态初始化/要么静态初始化,不能结合
int[][] arr = new int[3][2]{{1,2,3},{4,5,6}} ; //错误的书写格式:
二维数组的应用:杨辉三角形
输出:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
分析:
1)行数和列数:都是6 ----->数据可以采用键盘录入!
二维数组的定义格式:格式1:int[][] arr = new int[num][num] ;
2)任何一行的第一列和最后一列都是1
3)从第三行开始,中间的数据的值等于上一行的前一列+上一行的本列之和
键盘录入一个数据:使用二维数组初始化
外层循环:行数
内层循环:列数
int[][] arr = new int[n][n] ;
给二维数组中的数据赋值(给任何的一列和最后一列赋值) .将定义二维数组遍历for(int x =0 ; x < arr.length ; x ++){
何一行的第一列和最后一列都是1}
再次遍历二维数组,从第三行开始,中间的数据的值等于上一行的前一列+上一行的本列之和(要符合99乘法表的格式!)
//导包
import java.util.Scanner ;
class Array2Test{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请您输入一个数据:") ;
int n = sc.nextInt() ;
//定义二维数组,动态初始化
int[][] arr = new int[n][n] ;
//给二维数组中的数据赋值(给任何的一列和最后一列赋值)
//将定义二维数组遍历
for(int x = 0 ; x < arr.length ; x ++){
//赋值
//任何的一列和最后一列都是1
arr[x][0] = 1 ;
arr[x][x] = 1 ;
}
//第三行开始遍历
//从第三行开始,中间的数据的值等于上一行的前一列+上一行的本列之和
for(int x = 2 ;x < arr.length ; x ++){
//内层循环
/*
y从1开始, 当前任何一行的第一列已经赋值1
y<=x-1 : 最后一列也赋值为1
*/
for(int y = 1 ; y <=x -1; y ++){
//中间的数据的值等于上一行的前一列+上一行的本列之和
arr[x][y] = arr[x-1][y-1] + arr[x-1][y] ;
}
}
//跟99乘法表规律:y的角标值 y<=x 的值
for(int x = 0 ; x < arr.length ; x ++){
for(int y = 0 ; y <=x ; y ++){ //x = 0 (第一行), y=0(第一列) ,y<=1(0,1)
System.out.print(arr[x][y] +"\t") ; //arr[0][0] arr[1][1]
}
System.out.println() ;
}
}
}
八：异常. 程序出问题了!
严重问题:
error : 内存异常了 (通过一些第三方工具避免了!)
举例: 一些软件通过一些特殊的操作:造成软件崩溃了
!
异常:Exception: 能够通过本身代码来解决问题
编译时期异常:只要不是运行时期的异常都属于编译时期(不解决,编译通过不了)
RuntimeExcetion:运行时期异常:在执行过程中,由于代码结构不严谨,导致的问题!
数组中的第一个异常:数组角标越界!
java.lang.ArrayIndexOutOfBoundsException:
出现的原因:访问不存在的角标!就出异常了
解决方案:改动角标值即可!
数组中第二个异常:空指针异常:
java.lang.NullPointerException:
出现的原因:某个对象都为null,还需要使用对象访问内容或者调用其他功能!
解决方案:只需要对某个对象做一个非空判断!(逻辑判断)if---else
If(某对象 !=null){完成业务需求;}
九，基本类型, 引用类型作为形式参数进行传递的特点
1.基本类型作为形式参数进行传递的特点:
形式参数的改变对实际参数没有影响
2.引用类型作为形式参数进行传递的特点:
形式参数的改变对实际参数有影响
3.String类型是一种特殊的引用类型:
它作为形式参数,形参的改变对实际参数没有影响-----跟基本类型作为形式参数是一样!
`
1231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
