Java学习3
（一）、if语句
格式1：单条件判断
执行流程：
注意事项：
1.大括号开头可以另起一行写，建议写在第一行的末尾
2.在语句体中，如果只有一句代码，大括号可以省略不写
3.如果对一个布尔类型变量进行判断。不要用==号。直接把变量写在小括号里
格式2：双条件判断
执行过语句体1，则不会执行2
格式3：多条件判断
从上往下依次判断，只要有一个为真就执行当前语句体
全是假就执行最后一个else的语句体
（二）、switch语句
使用场景：把有限个数据一一列举出来，我们任选其一
格式：
执行流程：
注意事项：
1.表达式计算出的值类型为byte、short、int、char。jdk5以后可以是枚举，7以后可以是String
2.case后面跟的是和表达式进行比较的值
3.case后的值必须是字面量，不能是变量且值不能重复
4.default不一定写在最下面，可以省略但不建议
5.case穿透：语句体没有写break产生的，没有break会一直执行一直到遇见break或右大括号
switch的新特性（jdk12以上的版本）
可以省略break，并且不会触发case穿透，只有一行代码可以省略括号
case 1->{
System.out.println("一");
//将语句体写在括号里
}
default->{
System.out.println("一");
}
（三）、for循环
一个循环尽量只做一件事
使用场景：知道循环次数或者循环范围
格式：
执行流程：
如果将变量定义在循环里面，则变量只能在当次循环有效
（四）、while循环
使用场景：不知道循环的次数和范围，只知道循环的结束条件
格式：
与for循环的区别：
练习1：
package tdjava;
import sun.awt.geom.AreaOp;
public class iflx {
public static void main(String[] args) {
double height=8844430;
double paper=0.1;
int count=0;
while(paper<height){
paper=paper*2;
count++;
}
System.out.println(count);
}
}
练习2：
package tdjava;
public class t2 {
public static void main(String[] args) {
int x=123;
int temp=x;//定义一个临时变量存储x的初始值
int num=0;//记录倒过来的值
while(x!=0){
//从右往左获取每一位的数字
int ge=x%10;
//每次循环去掉获取过的值
x=x/10;
//拼接获取到的数字
num=num*10+ge;
}
System.out.println(num);
System.out.println(x);
System.out.println(num==temp);//打印是不是回文数的判断结果
}
}
练习3：
package tdjava;
public class t3 {
public static void main(String[] args) {
int d1=20;//被除数
int d2=3;//除数
int count=0;
while (d1>=d2){
d1=d1-d2;
count++;
}
System.out.println(count);//商
System.out.println(d1);//余数
}
}
//原理是不断的用被除数-除数，只要被除数>=除数就一直循环，循环次数就是商，最后的被除数的值就是余数
do while：
会先执行循环体再判断，不论条件是否正确，循环体都会执行一次
（五）、循环练习
5.1无限循环：三种形式
注意：无限循环下方不能再写代码，因为永远不会执行到
5.2跳转控制语句
continue： 结束本次循环，继续下次循环
break：结束整个循环
5.3 逢七过
package tdjava;
public class t5 {
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
//判断 7倍数 十位7 个位7
//满足一个即可
if(i%7==0 ||i/10%10==7||i%10==7){
System.out.println(i);
}
}
}
}
5.4 平方根
package tdjava;
import java.util.Scanner;
//从1开始，用数字的平方根与number比较
//如果相等就是平方根
//如果大于number那么就是前一个数就是平方根的整数部分
public class t6 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("输入一个整数");
int number=sc.nextInt();
for (int i = 0; i < number; i++) {
if(i*i==number){
System.out.println(i+"就是"+number+"的平方根");
break;//符合条件直接退出循环，提高效率
}else if(i*i>number){
System.out.println((i-1)+"就是"+number+"平方根的整数部分");
break;//符合条件后直接退出循环
}
}
}
}
5.5 判断质数
package tdjava;
import java.util.Scanner;
public class t7 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("输入一个整数");
int number =sc.nextInt();
//可以定义一个变量表示标记，类型为布尔
boolean flag=true;
//循环从2开始，到number-1结束。判断有没有数字可以被number整除
for (int i = 2; i < number - 1; i++) {
if(number%i==0){
flag=false;
break;
}
}
if(flag){
System.out.println(number +"是一个质数");
}else{
System.out.printf(number+"不是一个质数");
}
}
}
思路2：循环结束到number的平方根
5.6 猜数字游戏
使用Random类生成随机数：
随机数范围是从0开始，到随机数-1结束（包头不包尾，包左不包右）
生成任意范围的随机数：
1.让这个范围头尾都减去一个值，让他从0开始
2.尾巴+1
3.最终的结果，再加上第一步减去的数
如：7-15
既最大范围-最小范围加1为括号内的值，括号外最小范围的值
package tdjava;
import java.util.Random;
import java.util.Scanner;
public class t8 {
public static void main(String[] args) {
Random r=new Random();
int number=r.nextInt(100)+1;
//不知道循环次数，使用while循环，设置成死循环直到猜中才跳出循环
while (true){
Scanner sc=new Scanner(System.in);
System.out.println("输入猜的数字");
int guessn=sc.nextInt();
if (guessn>number){
System.out.println("大了");
} else if (guessn<number) {
System.out.println("小了");
}else{
System.out.println("正确");
break;
}
}
}
}
（六）、数组
数组指的是一种容器，可以用来存储同种类型数据的多个值
存储时需要结合隐式转换来考虑
6.1数组的定义
格式1：
格式2：
静态初始化：
简化格式：数据类型 [] 数组名 = {元素1，元素2}
动态初始化：创建时我们给出长度，虚拟机给出默认初始化的值
默认初始化的规律：
整数类型：0
字符类型：‘/u0000’ 既空格
小数类型：0.0
布尔类型：false
引用数据类型：null
数组的地址值：直接打印数组会获得数组的地址值
如：[D@776ec8df
[：表示是一个数组
D：表示数据类型是double
@：是一个间隔符，固定格式
776ec8df：真正的地址值
6.2 数组的访问
格式： 数组名[索引]
索引从0开始
6.3数组的储存
数组名[索引]=具体数据/变量
6.4 数组的遍历
将数组中的所有内容取出来
遍历指的是取出数据的过程，不要局限的理解为打印
package tdjava;
public class t4 {
public static void main(String[] args) {
int str[]={1,2,3,4};
for (int i = 0; i < str.length; i++) {
System.out.println(str[i]);
}
}
}
idea快捷键：数组名.fori
6.5 数组常见问题
索引越界异常：访问了不存在的索引
6.6 数组的内存图
Java的内存分配：
数组存在堆内存
6.6 数组练习
求最大值：max初始化的值必须是数组中的值
package tdjava;
public class t9 {
public static void main(String[] args) {
int[]arr={33,5,22,44,55};
int max=arr[0];//用max来记录当前的最大值，每一个值都跟max比较，比max大就赋值为新的max
for (int i = 0; i < arr.length; i++) {
if(arr[i]>max){
max=arr[i];
}
}
System.out.println(max);
}
}
遍历数组求和：
package tdjava;
import java.util.Random;
public class t10 {
public static void main(String[] args) {
double sum=0;
int count=0;//记录多少个数据比平均值小
int []arr=new int [10];//动态初始化长度为10的数组
for (int i = 0; i < arr.length; i++) {
Random r= new Random();
arr[i]=r.nextInt(100)+1;
}//给数组赋值
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}//求和
double average=sum/arr.length;//平均值
for (int i = 0; i < arr.length; i++) {
if(arr[i]<average){
count++;
}
}
System.out.println("和为"+sum);
System.out.println("平均数为"+average);
System.out.println("比平均数小的有"+count+"个");
}
}
交换数组：通过中间容器交换
（七）、方法
方法是程序中最小的执行单元
重复的代码，具有独立性的代码可以抽取到方法中
有利于提高代码的复用性，提高代码的可维护性
7.1 方法的定义和调用
方法必须先定义再调用
方法定义的技巧：
最简单方法的定义：
调用：方法名（）
带参方法的定义：
方法名（变量/具体的参数）
传入参数的类型和数量必须和定义的相同
形式参数：方法中定义的参数
实际参数：方法调用中的参数
带返回值的方法的定义：
方法的返回值就是方法运行完的最终结果
赋值调用 类型 变量=方法名（）
7.2 方法注意事项
1.方法与方法是平级，不能相互嵌套
2.方法不调用就不执行
3.方法的执行顺序与编写顺序无关
4.方法的返回值类型为void，表示该方法无返回值，没有返回值的方法可以省略return，如果要写不能跟具体数字（此时return表示为结束方法）
5.return语句下面不能写代码
6.方法有返回值，必须写return，表示返回值和结束方法
7.3 方法的重载
同一个类当中，方法名相同但是参数不同的方法就构成了重载。与返回值无关
参数不同：类型不同，顺序不同，个数不同
相同功能的方法会起成一个名字
7.4 方法的值传递
传递基本数据类型时，传递的是真实的值，形参的改变不影响实参
传递引用数据类型时，传递的是地址值，形参的改变会影响实参
（八）、引用数据类型和基本数据类型
基本数据类型变量存储的是一个具体的值
数据值存储在自己的空间，赋值给其他变量也是赋的真实的值
引用数据类型变量存储的是地址值，引用了其他空间的数据
数据值存储在其他空间，自己的空间存储地址值。赋值给其他变量的是地址值
（九）、综合训练
9.1 飞机票
package tdjava;
import java.util.Scanner;
public class z1 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入月份");
int month=sc.nextInt();
System.out.println("请输入机票原价");
double pnumber=sc.nextDouble();
System.out.println("请输入座位类型 0是头等舱 1是经济舱");
int ptype=sc.nextInt();
if (month>=5 && month<=10){
if(ptype==0){
pnumber=pnumber*0.9;
System.out.println( "价格为" + pnumber);
}else {
pnumber=pnumber*0.85;
System.out.println( "价格为" + pnumber);
}
} else{
if(ptype==0){
pnumber=pnumber*0.7;
System.out.println( "价格为" + pnumber);
}else {
pnumber=pnumber*0.65;
System.out.println( "价格为" + pnumber);
}
}
}
}
cctrl+alt+M 自动抽取方法
9.2 验证码
package tdjava;
import java.util.Random;
public class z2 {
public static void main(String[] args) {
//1.先将所有字母放进数组当中
char[] chs=new char[52];
for (int i = 0; i < chs.length; i++) {
if(i<=25){
chs[i]=(char)(97+i);
}else{
chs[i]=(char)(65+i-26);
}
}
//2.随机抽取4次
String result="";
Random r=new Random();
for (int i = 0; i < 4; i++) {
int randomindex=r.nextInt(chs.length);
result+=chs[randomindex];
}
//3.随机抽取数字0-9
result=result+r.nextInt(10);
System.out.println(result);
}
}
9.3 评委打分
package tdjava;
import java.util.Scanner;
public class z3 {
public static void main(String[] args) {
//1.定义数组存储分数
int[] score=new int[6];
Scanner sc =new Scanner(System.in);
for (int i = 0; i < score.length; i++) {
System.out.println("请输入评委打分(0-100)");
int doc=sc.nextInt();
if(doc>=0 && doc<=0){
score[i]=doc;
}else{
System.out.println("分数有误");
i--;
}
}
//2.求出数组中的最大值
int max=score[0];
for (int i = 1; i < score.length; i++) {
if(max<score[i]){
max=score[i];
}
}
//3.求出数组中的最小值
int min=score[0];
for (int i = 1; i < score.length; i++) {
if(min>score[i]){
min=score[i];
}
}
//4.求数组的和
int num=0;
for (int i = 0; i < score.length; i++) {
num+=score[i];
}
//5.计算平均分：（总和-最大值-最小值）/4
System.out.println("平均分为" +(num-max-min)/4);
}
}
9.4数字加密
package tdjava;
import java.util.Scanner;
public class z4 {
public static void main(String[] args) {
//1.把整数里的每一位放到数组中
//1.1计算数组长度
Scanner sc=new Scanner(System.in);
System.out.println("输入一个大于0的数字");
int number=sc.nextInt();
int temp=number;//用于第三步
int count=0;
while (number!=0){
number=number/10;
count++;
}//循环每次去掉一位数，count加1，直到0结束
//1.2定义数组
int[] arr=new int[count];
//1.3把整数上的每一位都添加到数组当中去
int index=arr.length-1;
while (temp!=0){
int ge=temp%10;
temp=temp/10;
arr[index]=ge;
index--;
}
//2.加密
for (int i = 0; i < arr.length; i++) {
arr[i]=arr[i]+5;
}
for (int i = 0; i < arr.length; i++) {
arr[i]=arr[i]%10;
}
for (int i = 0,j=arr.length-1; i < j; i++,j--) {
int temp1=arr[i];
arr[i]=arr[j];
arr[j]=temp1;
}
//3.把数组中的每一位进行拼接，得到加密后的结果
int number1=0;
for (int i = 0; i < arr.length; i++) {
number1=number1*10+arr[i];
}
System.out.println("加密后为" + number1);
}
}
解密：%10返回的一步
9.5 抽奖
第一种：
package tdjava;
import java.util.Random;
public class z5 {
public static void main(String[] args) {
int[] arr={2,588,888,1000,10000};//表示奖池
int[] newArr=new int[arr.length];//储存抽奖结果
//抽奖
Random r=new Random();
for (int i = 0; i < 5;) {
int index=r.nextInt(arr.length);
int prize=arr[index];
boolean flag=contains(newArr,prize);
if(!flag){
newArr[i]=prize;
i++;
}
}
for (int i = 0; i < newArr.length; i++) {
System.out.println(newArr[i]);
}
}
//定义一个方法判断抽到的奖品是否已经被抽取
public static boolean contains(int[] arr,int price){
for (int i = 0; i < arr.length; i++) {
if(arr[i]==price){
return true;
}
}
return false;
}
}
第二种：
package tdjava;
import java.util.Random;
public class z5_1 {
public static void main(String[] args) {
//直接打乱奖池里的顺序
int[] arr={2,588,888,1000,10000};
Random r=new Random();
for (int i = 0; i < arr.length; i++) {
int index=r.nextInt(arr.length);
int temp=arr[i];
arr[i]=arr[index];
arr[index]=temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
9.6 双色球
package tdjava;
import java.util.Random;
import java.util.Scanner;
public class z6 {
public static void main(String[] args) {
//1.生成中奖号码
int[] arr=createNumber();
//用户输入号码
int[] userInputArr=userInput();
//判断有没有中奖
int redCount=0;
int blueCount=0;
//判断红球
for (int i = 0; i < userInputArr.length-1; i++) {
int redNumber=userInputArr[i];
for (int j = 0; j < arr.length-1; j++) {
if (redNumber==arr[j]){
redCount++;
break;
}
}
}
int blueNumber=userInputArr[userInputArr.length-1];
if (blueNumber==arr.length-1){
blueCount++;
}
if (redCount==6 && blueCount==1){
System.out.println("中一等奖");
}else if (redCount==6&&blueCount==0){
System.out.println("二等奖");
} else if (redCount==5&&blueCount==1) {
System.out.println("中三等奖");
} else if (redCount==4&&blueCount==1) {
System.out.println("中四等奖");
}else if (redCount==4&&blueCount==0){
System.out.println("中四等奖");
} else if (redCount==3&&blueCount==1) {
System.out.println("中五等奖");
} else if (redCount==2&&blueCount==1) {
System.out.println("中五等奖");
} else if (redCount==1&&blueCount==1) {
System.out.println("中六等奖");
}else if (redCount==0&&blueCount==1){
System.out.println("中六等奖");
}else {
System.out.println("没中奖");
}
}
public static int[] userInput(){
int[] arr=new int[7];
Scanner sc=new Scanner(System.in);
//输入红球
for (int i = 0; i < 6; ) {
System.out.println("请输入第"+(i+1)+"个红球号码");
int redNumber=sc.nextInt();
if (redNumber>=1 && redNumber<=33){
boolean flag=contains(arr,redNumber);
if (!flag){
//有效
arr[i]=redNumber;
i++;
}else {
System.out.println("已存在，重新输入");
}
}else {
System.out.println("超出范围，重新输入 ");
}
}
//输入蓝球
System.out.println("输入蓝球号码");
while (true){
int blueNumber=sc.nextInt();
if (blueNumber>=1 && blueNumber<=16){
arr[arr.length-1]=blueNumber;
break;
}else {
System.out.println("当前蓝球号码不符合要求");
}
}
return arr;
}
public static int[] createNumber(){
//1.创建数组添加中奖号码
//6红 1蓝
int[] arr=new int[7];
//2.生成随机号码,添加到数组中
//红球不重复，蓝球可以跟红球重复
Random r=new Random();
//生成红球
for (int i = 0; i < 6; ) {
int redNumber= r.nextInt(33)+1;
boolean flag=contains(arr,redNumber);
if (!flag){
arr[i]=redNumber;
i++;
}
}
int blueNumber=r.nextInt(16)+1;
arr[arr.length-1]=blueNumber;
return arr;
}
//判断数字是否存在
public static boolean contains(int[] arr,int number){
for (int i = 0; i < arr.length; i++) {
if(arr[i]==number){
return true;
}
}
return false;
}
}
9.7 二维数组
静态初始化：
简化格式：
建议：定义时，每个单独的一维数组写一行
每一个一维数组是二维数组中的元素
获取元素：arr[i][j]
i：二维数组的索引，得到的是一维数组
j：一维数组的索引，得到的是一维数组中的元素
二维数组中的遍历：两个循环嵌套
第一个范围是arr.length
第二个范围是arr[i].length
动态初始化：
m是二维数组的长度
n表示二维数组的长度
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
