本文介绍了Java中的方法重载，强调了方法名相同但参数列表不同的概念，并探讨了数组的定义、初始化、访问元素及注意事项。接着，详细讲解了冒泡排序算法的原理和实现过程，为初学者提供了清晰的学习路径。
一、方法重载
-
方法重载(OverLoad):方法名相同,参数列表不同,与返回值无关!
Java规定:如果很多个功能都是一样的,又做到方法名要见名知意；参数列表不同:
1)参数个数不一样；
2)参数类型不一样；举例1： public static int compare(int a,int b){} public static float compare(float a,float b){} public static int compare(float a,int b){} public static int compare(float a,double b){} -
Java中的方法重载:为了提供这个功能扩展性:方法名相同,可以接收各种类型的参数!
举例2: Math类的abs(int/double/float...): //求绝对值 Arrays类: //数组工具类 binarySearch(int[]/byte[]/char[]/double[]..,int key): //二分搜索法 sort(int[]/byte[]/char[]/double[]) : //给数组排序的(默认升序排序) 举例3： class FunctionDemo{ public static void main(String[] args){ //调用方法 int result = sum(10,20) ; System.out.println("result:"+result) ; System.out.println("----------------------") ; //int result2 = sum2(10,20,30) ; int result2 = sum(10,20,50) ; System.out.println("result2:"+result2) ; System.out.println("----------------------") ; //int result3 = sum3(10,20,30,40) ; int result3 = sum(10,20,50,60) ; System.out.println("result3:"+result3) ; } //求两个数据之和! public static int sum(int a,int b){ return a + b ; } //求三个数据之和 //public static int sum2(int a, int b,int c){//方法名相同 public static int sum(int a,int b,int c){ return a + b + c ; } //求四个数据之和 //public static int sum3(int a,int b,int c,int d){ public static int sum(int a,int b,int c,int d){ return a + b + c + d ; } }
二、数组
-
数组的概念:就是用来存储同一种数据类型的容器!
(类型必须一致,否则数组定义的时候 编译通过不了) -
特点:
1)数组的长度是固定的!
2)存储的类型必须是同一种类型String[] strArray = {"hello","world",100} ;3)数组中存储的元素可以是引用类型,也可以存储基本数据类型
int[] arr = new int[4] ; 举例: 存储5个学生 (集合之前讲)创建数组:数据类型[] 数组名称 = new 数据类型[数组长度] ;
Student[] students = new Student[5] ; 对象数组(能够存储对象的数组) -
数组的定义格式:(数组目前:都存储基本类型)
方式1) . 数据类型[] 数组名称 ; (推荐)
举例:
int[] arr ; 定义了一个int类型的数组arr变量方式2) . 数据类型 数组名称[] ;
举例
int arr[] ; 定义了一个int类型的arr数组变量; -
数组的初始化:
动态初始化
静态初始化1). 动态初始化:我们定义了数组的长度,数组的元素由系统默认初始化!
格式： 数据类型[] 数组名称 = new 数据类型[数组长度] ; int[] arr = new int[3] ; 数据类型 数组名称[] = new 数据类型[数组长度] ; int arr[] = new int[3]2). 静态初始化:给定了数组的元素的内容,由系统指定数组的长度！
格式: 数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3...} ;(推荐) 数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3...} ; 简写方式: 数据类型[] 数组名称 = {元素1,元素2,元素3...} ; int[] arr = {1,2,3,4,5,6} ; 注意: 不能动静初始化(要么动态初始化,要么静态初始化!) int[] arr = new int[3]{1,2,3} ; 错误的
举例：
class ArrayDemo3{
public static void main(String[] args){
//创建一个数组,静态初始化
int[] arr = {11,22,33,44,55} ;
System.out.println(arr) ; //地址值
System.out.println(arr[2]) ;
System.out.println(arr[3]) ;
}
}
- 在数组中如何获取数组的元素?
数组名称[索引值]:索引值:0开始
最大索引值:数组长度-1
举例：
class ArrayDemo{
public static void main(String[] args){
//数据类型[] 数组名称 = new 数据类型[数组长度] ;
//创建一个int类型的数组,长度为4
int[] arr = new int[4] ;//arr[0],arr[1],arr[2],arr[3]
int[] arr2 = new int[3] ;
System.out.println(arr2) ;
System.out.println(arr) ; //[I@6d06d69c 地址值
//[:数组
//@:地址值标记
//6d06d69c:一堆十六进制数据
/*
解释说明一下格式:
=号左边
int:里面存储的都是int类型
[]:一维数组
arr:数组名称(符号标识符的规则)
=号右边
new :创建对象
int:int类型的元素
[]:一维数组
4:数组的长度
*/
System.out.println("----------------------------") ;
//在数组中如何获取数组的元素?
//数组名称[索引值]:索引值:0开始
System.out.println(arr[0]) ;
System.out.println(arr[1]) ;
System.out.println(arr[2]) ;
System.out.println(arr[3]) ;
}
}
-
在数组注意问题:
1). 数组角标越界异常:ArrayIndexOutOfBoundsException
出现的原因:访问了数组中不存在的索引值,索引值是非法!(大于或者等于数组长度,索引值为负)
解决方案:及时检查错误,然后更新代码!2). 数组是引用类型,引用类型的默认值是null(空对象),
空指针异常:NullPointerException
出现的原因:
1)在数组中的,数组对象已经为null,还要访问里面的元素
2)在后期可能会使用某些类的功能的时候,但是这个类的对象已经为null了解决方案:(在idea中,使用断点来调试程序!debug)
在某段代码中,如果出现空指针,在使用该对象的时候,进行非空判断!
举例：
arr = null ;
//对arr进行非空判断
if(arr!=null){
System.out.println(arr[0]) ;
}else{
System.out.println("数组对象已经为null了...") ;
}
//arr=null ; 将堆内存 中没有值了(空值了),还要访问空对象中的元素!
- 应用：
数组的应用:
1)遍历数组
就是将数组的元素一一获取并输出
class ArryTest2{
public static void main(String[] args){
//创建一个数组,静态初始化
int[] arr = {11,22,33,44,55} ;
//数组名称[索引值]:访问数组的元素
//循环改进
//x:角标(索引值)
for(int x = 0 ; x < 5 ; x ++ ){
System.out.println(arr[x]) ;
}
//创建一个数组:
int[] arr2 = {11,23,4,5,6,8,9,78,45,30,20,22,55,120} ;
//任何数组有一个属性:length:获取的长度
System.out.println(arr.length) ;
//优化:获取数组长度
printArray2(arr) ;
}
/*
定义一个遍历数组的功能
两个明确
1)明确返回值类型:void 代替
2)明确参数类型以及参数个数
int[] 一个参数
*/
public static void printArray2(int[] arr){
//输出一个"["
System.out.print("{") ;
//遍历数组,获取元素内容
for(int x = 0 ; x < arr.length ; x ++){
//获取到了
//判断x是否能够取到最大索引值:arr.length-1
if(x==arr.length-1){
//获取最大索引值对应最后一个元素
System.out.println(arr[x]+"}") ;
}else{
//不是最后一个元素,中间的元素
//元素1, 元素2, ..
System.out.print(arr[x]+", ") ;
}
}
}
2). 数组的最值
给定一个数组,静态初始化,获取数组中的最大值(同最小值)。
class ArrayTest3{
public static void main(String[] args){
//指定一个数组,静态初始化
int[] arr = {69,45,87,13,24} ;
int max2 = getMax(arr) ;
System.out.println("数组的最大值是:"+max) ;
}
/*
定义一个求最大值的方法
两个明确
1)明确返回值类型:int
2)明确参数类型以及参数个数
int[] 1个参数
*/
public static int getMax(int[] arr){
//定义有一个参照物
int max = arr[0] ;
//遍历其他元素
for(int x = 1 ; x < arr.length ; x ++){
if(arr[x] > max){
max = arr[x] ;
}
}
return max ;
}
}
3).元素逆序
已知数组,静态初始化,将元素逆序!
举例:
int[] arr = {14,69,24,78,52} ;
分析:
1)已知数组,静态初始化
2)
需要将arr[0]和arr[arr.length-1] 对应的元素进行互换
arr[1]和arr[arr.length-1-1] 对应的元素进行互换…
…
…
保证数的长度arr.length/2
class ArrayTest4{
public static void main(String[] args){
//创建数组,并静态初始化
int[] arr = {14,69,24,78,52} ;
System.out.println("逆序前:") ;
printArray(arr) ;
System.out.println("--------------------") ;
System.out.println("逆序后:") ;
//reverse(arr) ;
reverse2(arr) ;
printArray(arr) ;
}
//方式2
public static void reverse2(int[] arr){
//start,end:索引值
for(int start = 0 ,end = arr.length-1 ; start < end ;start ++,end -- ){
//使用中间变量的方式
int temp = arr[start] ;
arr[start] = arr[end] ;
arr[end] = temp ;
}
}
/*
方式1:
定义方法:逆序的方法
两个明确
1)明确返回值类型:void
2)明确参数类型以及参数格式:int[] 数组 1个参数
需要将arr[0]和arr[arr.length-1] 对应的元素进行互换
arr[1]和arr[arr.length-1-1] 对应的元素进行互换...
...
...
保证数的长度arr.length/2
*/
public static void reverse(int[] arr){
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). 元素查表法
举例:
字符串数组
String[] strs = {“星期一”,“星期二”,“星期三”,“星期四”,“星期五”,“星期六”,“星期日”} ;
键盘录入一个数据(0-6)
使用 :数组名称[索引值] 确定元素
import java.util.Scanner ;
class ArrayTest5{
public static void main(String[] args){
//已知字符串数组
String[] strs = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入
System.out.println("请输入一个数据(0-6):") ;
int num = sc.nextInt() ;
System.out.println("当前是"+strs[num]) ;
}
}
总结：
数组中的基本元素查找法:
基本查询
在数组中从头查找到末尾
高级查询: 二分搜索法(数组 折半查找)
已知一个数组,静态初始化
int[] arr = {69,78,34,200,120} ;
需求:查询34这个元素在数组的角标值(默认int)
分析:
1)创建一个数组,静态初始化
2)定义一个功能:查询元素在数组的角标值的功能
两个明确
1)明确返回值类型: int
2)明确参数类型以及参数格式
两个参数:
int[] arr
int target/key
方式1:
以后在判断:无非两种情况:要么成立,要么不成立!
先去遍历数组中的所有元素,一一获取每一个元素
判断:如果当前要查询的target元素和arr[x]元素一致
找打了,直接x返回;
如果找不到呢?
在Java中:如果元素在数组中没有找到,返回负数:-1
class ArratTest6{
public static void main(String[] args){
//已知一个数组,静态初始化
int[] arr = {69,78,34,200,120} ;
//查询34这个元素第一次在数组中出现索引值
//int index = getIndex(arr,34) ;
int index = getIndex2(arr,120) ;
System.out.println("index:"+index) ;
//int index2 = getIndex(arr,250) ;
int index2 = getIndex2(arr,300) ;
System.out.println("index2:"+index2) ;
}
//方式2:
//使用一种假设思想
public static int getIndex2(int[] arr,int key){
//定义一个变量index
int index = -1 ; //假设找不到
//遍历arr数组
for(int x = 0 ; x < arr.length ; x ++){
//判断
if(arr[x] == key){
index = x ;
break ;
}
}
return index ;
}
//方式1:
//定义一个功能
//参数1:在指定的数组中查询
//参数2:要查找的元素
public static int getIndex(int[] arr,int target){
//遍历数组
for(int x = 0 ; x < arr.length ; x ++){
//获取到元素
//判断:如果当前要查询的target元素和arr[x]元素一致
if(target == arr[x]){
return x ; //找到了
}
}
//找不到
return -1 ;
}
}
三、java数据内存分配
/*
创建多个数组对象:
创建两个数组对象,分别输出数组名称以及他们的元素
重新给这两个数组中的元素进行赋值
定义第三个数组,将第一个数组名称赋值给它,再次重新给元素赋值
*/
class ArrayDemo2{
public static void main(String[] args){
//创建第一个数组
int[] arr = new int[2] ;
int[] arr2 = new int[3] ;
System.out.println(arr) ;
System.out.println(arr2) ;
System.out.println(arr[0]) ; //0
System.out.println(arr[1]) ; //0
System.out.println(arr2[0]) ; //0
System.out.println(arr2[1]) ; //0
System.out.println(arr2[2]) ; //0
System.out.println("-----------------") ;
arr[0] = 10 ;
arr[1] = 5 ;
arr2[1] = 20 ;
arr2[2] = 30 ;
System.out.println(arr) ;
System.out.println(arr2) ;
System.out.println(arr[0]) ;
System.out.println(arr[1]) ;
System.out.println(arr2[0]) ;
System.out.println(arr2[1]) ;
System.out.println(arr2[2]) ;
//定义第三个数组,将第一个数组名称赋值给它
System.out.println("-----------------") ;
int[] arr3 = arr ;
arr3[0] = 100 ;
arr3[1] = 200 ;
System.out.println(arr[0]) ;
System.out.println(arr[1]) ;
System.out.println(arr2[0]) ;
System.out.println(arr2[1]) ;
System.out.println(arr2[2]) ;
}
}
四、第一个排序算法：冒泡排序
-
冒泡排序:
两两比较,将较大的值往后方法,第一次比较完毕,最大值出现在最大索引处!
依次这样比较…
最终比较次数:数组长度-1次
class ArrayTest{ public static void main(String[] args){ //创建一个数组,静态初始化 int[] arr = {24,69,87,56,13} ; System.out.println("排序前:") ; printArray(arr) ; System.out.println("-------------------") ; //使用功能代码块调用 //调用冒泡排序的方法 bubbleSort(arr) ; //遍历 printArray(arr) ; } //定义一个冒泡排序的功能 //两个明确:明确返回值类型: void //明确参数类型以及参数个数:int[] 一个参数 public static void bubbleSort(int[] arr){ for(int x = 0 ; x < arr.length-1 ; x ++){ //比较4次 for(int y = 0 ; y < arr.length-1-x ; y++){ //判断 if(arr[y] > arr[y+1]){ int temp = arr[y] ; arr[y] = arr[y+1] ; arr[y+1] = 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]+", ") ; } } }
}
扫一扫
1194
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
