Java学习之路之week2
向Java程序员的目标前进！
学习内容
day5
键盘录入数据练习
练习1：键盘录入两个数据，并对这两个数据求和，输出其结果
//导包
import java.util.Scanner ;
class ScannerTest2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您录入第一个数据：") ;
int a = sc.nextInt() ;
System.out.println("请您录入第二个数据：") ;
int b = sc.nextInt() ;
//求两个数的和
int c = a+b ;
System.out.println("两个数的和为："+c) ;
}
}
练习2：键盘录入两个数据，获取这两个数据中的最大值
//导包
import java.util.Scanner ;
class ScannerTest2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您录入第一个数据：") ;
int a = sc.nextInt() ;
System.out.println("请您录入第二个数据：") ;
int b = sc.nextInt() ;
//求两个数中的最大值
System.out.println("两个数的最大值为："+((a>b)?a:b)) ;
}
}
练习3：键盘录入三个数据，求最大值
//导包
import java.util.Scanner ;
class ScannerTest3{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入第一个数据：") ;
int a = sc.nextInt() ;
System.out.println("请您输入第二个数据：") ;
int b = sc.nextInt() ;
System.out.println("请您输入第三个数据：") ;
int c = sc.nextInt() ;
//求三个数的最大值
//方式1：定义中间变量的方式（推荐）
int temp = (a>b)?a:b ;
int max = (temp>c)?temp:c ;
System.out.println("三个数据中的最大值为："+max) ;
System.out.println("---------------------------------------") ;
//方式2：三元运算符的嵌套（不推荐）
int max2 = (a>b)?((a>c)?a:c):((b>c)?b:c) ;
System.out.println("三个数据中的最大值为："+max2) ;
}
}
练习4：键盘录入两个数据，比较两个数据是否相等
//导包
import java.util.Scanner ;
class ScannerTest4{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您录入第一个数据：") ;
int a = sc.nextInt() ;
System.out.println("请您录入第二个数据：") ;
int b = sc.nextInt() ;
//比较两个数据是否相等
//方式1
boolean flag = (m==n)?true:false ;
System.out.println(flag) ;
//方式1的改进——因为==本身就是比较，所以可将方式1简写
boolean flag = m==n ;
System.out.println(flag) ;
//方式2：流程控制语句（接下来开始讲）
}
}
通过上面的练习，我们熟悉了运算符的使用，但是在某些地方其实可以使用可读性更好、更为强大的方式实现，所以接下来开始学习流程控制语句。
流程控制语句
流程控制语句分为顺序结构语句、选择结构语句和循环结构语句。
顺序结构语句
顺序结构语句是程序中最简单的流程控制，代码由上而下依次加载（刚开始学习时写的HelloWorld，就是顺序结构语句）。
顺序结构图
接下来写个程序测试一下：
//JVM要加载这个类
class ShunXuDemo{
//main方法是程序的入口，需要被JVM调用
public static void main(String[] args){
System.out.println("程序开始了。。。") ;
System.out.println("Hello Java!!!") ;
System.out.println("程序结束了。。。") ;
int a = 100 ;
System.out.println("over"+a) ;
}
}
选择结构语句
选择结构也叫分支结构，代码要根据条件（逻辑运算）进行判断，产生两种选择。代码根据不同的选择执行不同的代码。
Java提供了if语句和switch语句
选择结构之if语句
if语句有三种格式，接下来会依次学习
if语句格式1：
if(条件表达式){
语句 ;
}
执行流程：
- 当前条件表达式成立，就执行语句
- 否则不成立，不执行语句
//导包
import java.util.Scanner ;
class IfDemo{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数据x的值:") ;
int x = sc.nextInt() ;
if(x<10){
System.out.println("x小于10，值是:"+x) ;
}
//if()...
System.out.println("over") ;
}
}
格式1的应用场景：针对单个条件进行判断
注意事项：
- 关系表达式的结果必须是布尔类型
- if结构的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略大括号。
- 一般来说，有左大括号就没有分号，有分号就没有左大括号。
if语句格式2：
if(条件表达式){
语句1 ;
}else{
语句2 ;
}
执行流程：
- 判断条件表达式是否成立，如果成立，执行语句1
- 如果不成立，执行语句2
/*
需求：判断两个数中的最大值
*/
//导包
import java.util.Scanner ;
class IfDemo2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请你输入第一个数据:") ;
int a = sc.nextInt() ;
System.out.println("请你输入第二个数据:") ;
int b = sc.nextInt() ;
//比较两个数据中的最大值
//定义结果变量
int max ;
if(a>b){
//System.out.println("最大值是"+a) ; //输出语句
max = a ; //将a赋值max
}else{
max = b ; //将b赋值max
}
System.out.println("两个数据中的最大值是:"+max) ;
}
}
格式2的应用场景：针对两种情况进行判断
if格式2的嵌套方式：
if(表达式){
if(表达式1){
语句1 ;
}else{
语句2 ;
}
}else{
if(表达式2){
语句3 ;
}else{
语句4 ;
}
}
执行流程:
-
先判断表达式是否成立，如果成立
-
执行里面的if语句
2.1 判断表达式1是否成立，如果成立，执行语句1
2.2 如果不成立，执行语句2 -
如果第一次进行比较表达式如果不成立，执行else中的if语句
3.1 判断表达式2是否成立，如果成立，执行语句3
3.2 如果不成立，执行语句4
if格式2的练习：模拟用户登录操作
需求：
-
假设已经存在用户名和密码（模拟数据库）
-
键盘录入用户名和密码（String类型）
判断用户名和密码是否匹配
-
如果匹配，则提示“"恭喜您，登录成功！”；如果不匹配，则提示“对不起，用户名或者密码错误！”。
涉及的方法：
-
Scanner类提供了一个方法：
public String nextLine()：录入String类型数据 -
String类型中的功能：
equals(String other)：比较两个字符串内容是否相同
//导包
import java.util.Scanner ;
class IfTest{
public static void main(String[] args){
//需求
//假设已经存在用户名和密码(模拟数据库)
String name = "admin" ; //String 是一种特殊的引用类型(后期常用类中讲)
String pwd = "admin" ;
//创建键盘录入对象，准备录入用户名和密码
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入用户名:") ;
//public String nextLine() :录入String类型数据
//变量名 = 固定格式:键盘录入对象.nextLine() ;
String username = sc.nextLine() ;
System.out.println("请您输入密码:") ;
String password = sc.nextLine() ;
//进行判断
//我们使用已知存在的用户名和密码和录入的用户名和密码进行对比
/*
String类型中的功能:equals(String other)
比较两个"字符串内容"是否相同
*/
if(name.equals(username) && pwd.equals(password)){ //一致
//成立
System.out.println("恭喜您，登录成功!");
}else{
//不成立
System.out.println("对不起，您的用户名或密码错误!");
}
}
}
注意事项：if语句格式2和三元运算符的区别
- if…else不仅可以操作具体数值，还能嵌套语句；三元运算符不能嵌套语句
- if…else可以没有返回值，三元运算符运算完需要有返回值
- 三元运算符一定可以转换成if…else结构，if…else结构不一定能转换为三元运算符
if语句格式3：
if(表达式1){
语句1 ;
}else if(表达式2){
语句2 ;
}else if(表达式3){
语句3 ;
...
...
}else{
语句n ;
}
执行流程：
- 判断表达式1是否成立，如果成立，则执行语句1；
- 如果表达式1不成立，继续判断表达式2是否成立，如果成立，执行语句2；
- 如果表达式2不成立，继续判断表达式3是否成立，如果成立，执行语句3；
- 重复进行类似3的判断（只是换了数字），直到判断到上面的条件表达式都不成立时（也就是遇见了对应的else），则执行else中的语句n…
/*
需求:
键盘录入一个学生的成绩:(没有提示数据类型,int类型接收)
90~100 "优秀"
80~90 "较好"
70~80 "良好"
60~70 "及格"
60以下 "不及格"
*/
//导包
import java.util.Scanner ;
class IfDemo3{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入学生的成绩:") ;
int socre = sc.nextInt() ;
//按照上面的需求格式进行判断
if(socre>100 || socre<0){
//错误数据提示
System.out.println("对不起,非法数据!") ;
}else if(socre>=90 && socre<=100){
System.out.println("成绩优秀") ;
}else if(socre>=80 && socre<90){
System.out.println("成绩较好") ;
}else if(socre>=70 && socre<80){
System.out.println("成绩良好") ;
}else if(socre >=60 && socre<70){
System.out.println("成绩及格") ;
}else{
System.out.println("不及格") ;
}
}
}
注意事项：
Q：我们在测试程序时应该输入什么样的数据？
A：测试时应该输入3类数据：
1. 错误数据（负数,或者超过范围内的数据,都属于"非法数据"）
2. 正确数据（范围内的数据）
3. 边界数据（临界值）
格式3的应用场景：针对多种情况进行判断，一般情况下，开发中业务逻辑中格式3比较少见！
选择结构之switch语句
格式：
switch(表达式){
case 值1:
语句1 ;
break ;
case 值2:
语句2 ;
break ;
...
...
...
default:
语句n ;
break ;
}
执行流程：
- 判断表达式的值和case值1进行匹配，如果匹配成功，则执行语句1，通过break退出判断
- 如果case值1不匹配，就继续和case后面的case值2进行比较，如果匹配，则执行语句2，通过break退出判断
- 以此类推，直到上面的case的值都和switch中表达式的结果不匹配，就执行default中的语句n。
- 最后如果程序默认执行到了末尾，则自动结束，否则通过break结束
/*
需求:
键盘录入一个值week，来输出 "星期几"
week是1，就是"星期一"；2，就是"星期二"；3，就是"星期三"......一直到星期日。
*/
//导包
import java.util.Scanner ;
class SwitchDemo{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数据week:") ;
int week = sc.nextInt() ;
switch(week){
case 1:
System.out.println("星期一") ;
break ;
case 2:
System.out.println("星期二") ;
break ;
case 3:
System.out.println("星期三") ;
break ;
case 4:
System.out.println("星期四") ;
break ;
case 5:
System.out.println("星期五") ;
break ;
case 6:
System.out.println("星期六") ;
break ;
case 7:
System.out.println("星期日") ;
break ;
default :
System.out.println("对不起,非法数据!") ;
break ;
}
}
}
注意事项：
-
switch语句中表达式的数据类型可以是byte、short、int和char，JDK5以后可以是枚举类型（enum），JDK7以后可以是String类型。
-
case后面的值只能是常量，不能是变量。而且多个case后的值不能出现相同。
-
只有在判断的值是固定的时候，default可以省略，否则一般不建议省略。
-
case语句中的break必须带上，否则会造成case穿透（下面会单独介绍）；如果default语句在数据的末尾，break可以省略（不建议）。
-
default可以出现在switch语句的任何位置。
-
只有当前case中都没有匹配的时候，才执行default。
-
switch的结束条件有两个：
a. break结束
b. 程序默认执行到末尾
switch语句的应用场景：针对几个常量值的判断
补充：
-
case穿透性
在switch语句中，如果case的后面不写break，将出现穿透现象，也就是说，程序不会再判断下一个case的值，顺序向下运行，直到遇到break语句或者执行到switch结束。
下面我们来看几个例子：
class SwitchDemo2{
public static void main(String[] args){
int i = 5 ;
switch(i){
case 0:
System.out.println("执行case0") ;
break ;
case 5:
System.out.println("执行case5") ;
case 10:
System.out.println("执行case10") ;
default:
System.out.println("执行default") ;
}
}
}
上面的程序在执行了case 5之后，由于没有break语句让程序停止，程序会一直顺序执行，直到执行到switch结构结束为止。
class SwitchDemo3{
public static void main(String[] args){
int x = 3 ;
int y = 4 ;
switch(x){//3
default :
y++ ;//4+1 = 5
case 4:
y++ ;//5+1 = 6
case 5 :
y++ ;//6+1 = 7
}
System.out.println("y:"+y) ;
}
}
上面的程序先判断x，没有任何匹配后跳转到default并执行，由于没有break语句让程序停止，程序会一直顺序执行，y的值也会根据执行情况依次增加，直到执行到switch结构结束为止。
class SwitchDemo4{
public static void main(String[] args){
int a = 3 ;
int b = 4 ;
switch(a){//3
default :
b++ ;//3+1 = 4
break ;
case 4:
b++ ;
case 5:
b++;
}
System.out.println("b:"+b) ;
}
}
上面的程序先判断a，没有任何匹配后跳转到default并执行，y因为有break语句让程序停止，所以b在自增一次后结束了switch语句，b的值输出为4。
class SwitchDemo5{
public static void main(String[] args){
int a = 3 ;
int b = 4 ;
switch(a){//a=3
case 3:
b++ ;//4+1 = 5
case 5:
b++ ;//5+1 = 6
default :
b++ ;//6+1 = 7
break ;
}
System.out.println("b:"+b) ;
}
}
上面的程序先判断a，在case 3匹配后开始执行，由于没有break语句让程序停止，程序会一直顺序执行，b的值也会根据执行情况依次增加，直到遇到break为止，b的值为7。
day6
流程控制语句—续
循环结构语句
循环语句就是在特定的情况下（满足了循环条件），反复干一件事情（反复执行某段代码），这些重复执行的代码被称为循环体语句。
循环结构语句分为for循环、while循环和do-while循环。
循环结构之for循环
格式：
for(初始化语句a;条件表达式b;控制体语句（也叫步长语句）d){
循环体语句;c
}
执行流程：
- 执行顺序：abcd—>bcd—>bcd…直到b不满足为止。
- a负责初始化循环变量
- b负责判断是否满足循环条件
- c是循环执行的语句
- d负责控制循环变量的变化
/*
需求:
需要在dos控制台输出10句"HelloWorld"
*/
class ForDemo{
public static void main(String[] args){
for(int x = 1 ;x <= 10 ; x ++)
System.out.println("HelloWorld") ;
}
}
}
注意事项：
循环体语句如果是一条语句，大括号可以省略；如果循环体语句是多条语句，大括号不能省略，建议永远不要省略。
for循环的应用场景：明确循环次数的时候，优先用for循环。
补充：
- for循环的另一种使用方式（死循环方式）：
for(;;){
循环体语句 ;
if(条件表达式){
break ;//当达到某种条件时，使用break语句中断循环
}
}
循环结构之while循环
格式：while有基本格式和拓展格式两种
//基本格式
while(条件表达式){
循环体语句 ;
}
//拓展格式
初始化语句 ;
while(条件表达式){
循环体语句 ;
控制体语句 ;
}
执行流程：
- 初始化语句进行赋值
- 判断条件表达式是否成立
- 如果成立，执行循环体语句和控制体语句
- 继续执行2、3，直到条件表达式不成立，退出循环
流程图跟for循环的执行流程图相同，此处省略
while循环的应用场景：不明确循环次数，使用while循环。
补充：
- while循环和for循环的联系与区别：
联系：都能够描述循环的思想，将重复度高的代码进行优化，从而解决冗余度的问题
区别：
- 格式上不同
- 从内存角度考虑，for循环执行结束后，循环变量也就随着结束被释放了。但是while循环在执行结束后，由于初始化语句在循环结构外已经被定义，所以内存中始终存在着这个变量。所以for循环比较节省内存空间。（变量的生命周期）
- 明确循环次数时，优先用for循环，其次才是while；不明确循环次数时，使用while循环。在实际的开发中，for循环使用次数最多。
- while循环的另一种使用方式（死循环方式）：
while(true){//死循环
循环体语句 ;
if(条件表达式){
break ;//当达到某种条件时，使用break语句中断循环
}
}
循环结构之do-while循环
格式：do-while有基本格式和拓展格式两种（与while循环相似）
//基本格式
do{
循环体语句 ;
}while(条件表达式) ;
//拓展格式
初始化语句 ;
do{
循环体语句 ;
控制体语句 ;
}while(条件表达式) ;
执行流程：
- 执行初始化语句
- 执行控制体语句
- 判断条件表达式是否成立
- 如果成立，继续执行2、3，直到条件表达式不成立，退出循环
/*
需求：在控制台输出6次"Hello World!"
*/
class DoWhileDemo{
public static void main(String[] args){
int x = 1 ;//初始化语句
do{
System.out.println("Hello World!") ;
x++ ;
}while(x<=6) ;
}
}
补充：循环语句的区别
三种循环大多数情况下可以等价转换，但是还是有些小区别。
比如do…while循环是先执行再判断，所以至少会执行一次循环体，for循环和while循环都是先判断再执行。
所以写程序优先考虑for循环，其次while循环，最后考虑do…while循环。
day7
流程控制语句—续2
循环结构语句之for循环嵌套
格式：
for(初始化语句1;条件表达式1;控制体语句1){
循环体是for循环
for(初始化语句2;条件表达式2;控制体语句2){
循环体语句2;....
}
}
跳转控制语句
跳转控制语句分为break语句、continue语句和return语句。
break语句
顾名思义，它具有中断、结束的意思。break语句不能单独使用。
break语句的应用场景：
- switch语句中
- for循环和while循环中
break语句的作用：
- 跳出单层循环
- 跳出多层循环
- 带标签的跳出
continue语句
continue语句表示结束本次循环，开始下一次的循环。continue语句不能单独使用。
continue语句的使用场景：循环
return语句
return语句表示返回结果，一般不会单独使用，它是在结束方法时使用的，并且返回的结果要结合Java中的有具体返回值类型的方法去使用。
方法
在Java中，方法就是使用{}代码块将一些业务代码包裹起来，形成一个单独的功能。当我们需要时就去调用，实现了代码的复用性。
方法分为有具体返回值类型和无具体返回值类型。
有具体返回值类型的方法
格式：
权限修饰符 静态修饰符 返回值类型 方法名(参数类型1 变量名1,参数类型2 变量名2......){
代码的业务逻辑（根据需求进行操作）
return 结果 ;
}
权限修饰符和静态修饰符：后面的面向对象中讲解
返回值类型：就是数据类型，目前我们研究的是基本数据类型
方法名：给{}代码块起个名字，见名知意，需要遵循标识符规则和"小驼峰命名法"。
参数列表：参数类型就是数据类型，而变量名就是给当前形式参数起名字，见名知意，遵循"小驼峰命名法"。
return 结果：根据方法的返回值类型判断对应类型的具体返回结果。
调用方式：
- 输出调用：直接在print语句中调用方法，采用了硬编码方式，这是不推荐的。
- 赋值调用：新建一个变量，然后调用方法并将返回值赋给新建的变量，推荐。
- 单独调用：由于调用方法都有返回值，所以单独调用不会有任何效果，不推荐。
/*
需求:
求两个数据之和(没有提示数据类型,都是int)
*/
class FunctionDemo{
public static void main(String[] args){
/*
int a = 10 ;
int b = 20 ;
System.out.println(a+b) ;
//输出调用：不推荐
*/
//键盘录入或者直接现在给具体值:实际参数
int a = 10 ;
int b = 20 ;
//赋值调用:推荐
int result = add(a,b) ;
System.out.println("两个数据的结果是:"+result) ;
}
public static int add(int x,int y ){//10,20 :实际参数将结果赋值形式参数x,y
//赋值运算
int result = x + y ;
return result ;//具体业务结果
//return x+y ;
}
}
注意事项：
-
方法和方法是平级的关系，不能嵌套，只能在方法里面去调用方法。
-
定义方法时需要“两个明确”
（1）明确返回值类型
（2）明确参数类型以及参数个数
-
在定义方法时，形式参数必须有对应的数据类型
-
在方法中调用方法的时候，实际参数不需要有数据类型
-
实际参数和形式参数在传参时数据类型和顺序要一一对应。
day8
方法—续
没有具体返回值类型的方法
格式：
权限修饰符 静态修饰符 void 方法名(形式参数列表){
//方法的业务逻辑
}
调用方式：
- 输出调用和赋值调用：由于方法没有返回值，这两项调用都没有效果。所以只适用于单独调用。
数组
数组的概念：数组就是能够存储同一种数据类型的容器，必须满足里面的元素是同一种类型的元素
数组定义的格式
数据类型[] 数据名称 ;//推荐第一种方式
数据类型 数据名称[] ;
定义的注意事项：
数组属于引用数据类型，里面可以放同一种类型的基本类型数据或同一种类型的引用类型数据。
数组的动态初始化
我们给定数组的长度，数组的元素内容由系统默认初始化
默认初始化：系统根据数组中存储的数据类型来判定默认值。
举例：int类型的默认值是0；double类型的默认值是0.0
格式：
数据类型[] 数组名称 = new 数据类型[数组长度] ;//推荐第一种方式
数据类型 数组名称[] = new 数据类型[数组长度] ;
举例剖析：
int[] arr = new int[3] ;
等号左边：
int：表示当前数组中存储元素为int数据类型（基本数据类型）
[]：表示一维数组
arr：表示当前数组的对象名称（变量名）叫arr
等号右边：
new：创建对象（跟JVM内存有关，数组存储在堆内存中）
int：创建的对象是一个int类型的数组
[]：表示创建的是一个一维数组
3：我们给定数组的长度为3
输出数组地址：
System.out.println(arr) ;
//输出结果为"[I@6d06d69c"
[：一维数组
@：地址值标记
6d06d69c：十六进制数据
输出数组元素：
System.out.println(arr[0]) ;
System.out.println(arr[1]) ;
System.out.println(arr[2]) ;
注意：数组的角标从0开始，到数组长度-1结束（数组长度为3，所以这里的角标是0-2）
Java中的内存分配
Java 程序在运行时，需要在内存中分配空间。为了提高运算效率，就对分配的空间进行了不同区域的划分。划分的每一片区域都有特定的处理数据方式和内存管理方式。
-
栈内存：存储局部变量
局部变量：在方法定义中（{}中）或者是方法声明上（()中）的变量
-
堆内存：存储new出来的东西
比如：new Scanner(System.in) ;
new arr[3] ;
-
方法区：存放字节码文件（class），静态相关的东西（static）和字符串常量（常量池…ConstantPool）。（面向对象讲解）
-
寄存器：和CPU相关
-
本地方法区：和系统相关
创建一个数组对象的内存图解
图解1：定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。
图解2：定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。
图解3：定义两个数组，再定义一个数组，赋值然后输出。定义第三个数组的时候把第一个数组的地址赋值给第一个数组。然后给第三个数组赋值，再次输出两个数组的名及元素。
数组的静态初始化
我们给定元素的内容，系统来默认分配长度。
格式：
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;//（推荐）
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;
简化格式：
数据类型[] 数组名称 = {元素1,元素2,元素3....} ;
数据类型 数组名称[] = {元素1,元素2,元素3....} ;
错误格式：创建数组的时候，不能既动态初始化，又静态初始化。
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ; 错误！
int[] arr = new int[3]{1,2,3} ; 错误！
数组中常见的两个异常：
-
数组索引越界
ArrayIndexOutOfBoundsException 类名
出现的原因：访问了数组中不存在的索引值报错！
解决方案：改变索引值
-
空指针异常
NullPointerException
出现的原因：某个对象如果为null，那么通过当前对象名来访问里面的元素或者方法的时候，出现报错
解决方案：对这个对象名称进行非空判断
day9
方法—续2
方法重载
在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
方法重载为了提高某个功能的拓展性，方法名相同，参数列表不同，与返回值无关！
参数列表不同：
- 参数个数不同
- 参数类型不同
- 考虑参数类型的顺序
//练习：判断下列哪些方法是重载关系？
public static void open(){}
public static void open(int a){}
static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}
//答案：第2，3，4，5，6行都是重载，第4和第9行一样，第6和第7行一样
数组—续
数组的应用（练习）
1. 数组遍历
/*
* 需求：数组遍历（依次输出数组中的每一个元素）
* */
class ArrayTest1 {
public static void main(String[] args){
int[] arr = {11,1,2,3,4,5,6,7,8,100,45,23,13,46,78,69} ;
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
2. 数组获取最值
/*
* 需求：数组获取最值（获取数组中的最大值最小值）
* */
public class ArrayTest2 {
public static void main(String[] args) {
int[] arr = {69,87,52,13,24} ;
int max = arr[0], min=arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max){
max = arr[i] ;
}else if(arr[i] < min){
min = arr[i] ;
}
}
System.out.println("当前数组中的最大值是"+max+"，最小值是"+min) ;
}
}
3. 数组逆序
/*
* 需求：数组元素逆序 （就是把元素对调）
* */
public class ArrayTest3 {
public static void main(String[] args) {
int[] arr = {69,87,52,13,24} ;
System.out.println("逆序前: ") ;
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
System.out.println("------------------------------------");
reserve(arr);
System.out.println("逆序后: ") ;
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
}
//方式1
public static void reserve(int[] arr){
for(int start = 0 ,end = arr.length-1 ; start<end ; start++,end--){
int temp = arr[start] ;
arr[start] = arr[end] ;
arr[end] = temp ;
}
}
//方式2
public static void reserve2(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 ;
}
}
}
4. 数组查表法
/*
数组的基本查表法
就是通过数组的对象名称[索引值]——获取元素内容
数据结构：
底层数据结构：
数组（顺序表）：查询快（角标就直接访问），增删慢
链表：由数据域和指针域组成：查询慢（从链表开头查），增删快
*/
//导包
import java.util.Scanner ;
class ArrayTest4{
public static void main(String[] args){
//字符串数组,静态初始化
String[] weeks =
{"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数据: ") ;
int n = sc.nextInt() ;
if(n>=0 && n<=6){
System.out.println("您要查找的是:"+weeks[n]) ;
}else{
System.out.println("录入的数据,不再数据表的范围内...") ;
}
}
}
5. 数组元素查找
/*
数组的基本元素查询：这种情况,查元素第一次出现的索引值,每次从头查询到尾
高级查询——二分搜索法---->"折半思想查找"
前提条件：只能针对数组有序的情况使用
*/
class ArrayTest5{
public static void main(String[] args){
int[] arr = {11,45,5,78,96,13} ; //无序的数组
int index = getIndex(arr,45) ;
System.out.println("当前该元素的索引值是:"+index) ;
int index2 = getIndex(arr,450) ;
System.out.println("当前该元素的索引值是:"+index2) ;
}
public static int getIndex(int[] array,int target){
for(int x = 0 ; x < array.length ; x ++){
if(array[x] == target){
return x ;
}
}
return -1 ;
}
}
冒泡排序
核心思想：两两比较，将两个数中较大的值往后放，使得每一次比较完毕后，最大值总是出现在最大索引处。这样依次比较，直到循环到第 数组长度 趟时，就得到了排好序的数组！
//定义一个方法,冒泡排序的方法
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length-1 ; x ++){//比较的次数
//里面元素进行比较,互换
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 ;
}
}
}
}
写博客难免会产生一些错误。如果写的有什么问题，欢迎大家批评指正。
2202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
