作业
1. 下列代码有问题吗?
float score = 3.14f; //有小数默认是double所以float需要添加f
byte num = -128;
char gender = 'nan'; //char类型是字符--》 一个
2. 下列代码的输出结果是?
//字符串使用 + 相当于是字符串的拼接
System.out.println("hello" + "world");helloworld
//打印语句中是没有 字符串所以 这个常量值相当于是 两个数的相加
System.out.println(98 + 12); 110
//字符串和任意类型 使用 + 默认就是字符串拼接,拼接的内容会形成字符串
System.out.println(13 + "" + 14); 1314
//字符串类型是可以参与计算,参与计算的时候,根据字符,查找对应ASCII码表中十进制
System.out.println(14 + 'A' + 12); 91
3. 下列代码的输出结果是?
int a = 10;
//++ -- 运算符 无论是++ 还是 -- 最终变量都需要进行+1 或 -1操作
//区分运算符是在变量之前 还是 变量之后
/*
运算符在变量之前,称为前++ ,变量本身会先进行一次+1操作,然后在参与其他运算
前-- -1操作,
运算符在变量之后,称为后++ ,变量会先参运算,然后本身会进行一次+1操作
后-- -1操作
*/
//后++,先取出a变量值的进行打印,然后a变量会进行自增
System.out.println(a++); //10 ---> 10+1 --->a = 11
//前++,先获取a变量的值并进行一次自增运算,然后在参与打印
System.out.println(++a);//11+1 ---> a = 12 ---> 12
//后--,先取出a变量的值进行打印,然后a变量会进行自减
System.out.println(a--);//12 ---> 12-1 --->a = 11
//前--,先获取a变量的值并进行一次自减运算,然后在参与打印
System.out.println(--a);//11-1 ---> a = 10 ---> 10
import java.util.Scanner;
/**
* 作业
*/
public class HomeWork {
public static void main(String[] args) {
//2.输入三个不等,并将数据升序输出【升序从小到大】
/**
* random的随机数原则
* [) -->左闭右开区间 --》包含做不包含右
* 原始范围 [0,1) --> Math.random() ---》随机出的结果值是一个小数【double】
* 假如要随机100以内的数据,不包括100
* [0,1)*100 --->[0*100,1*100) -->[0,100) -->随机到100以内数据
*/
int a = (int)(Math.random()*1000);
int b = (int)(Math.random()*1000);
int c = (int)(Math.random()*1000);
//假设一个固定顺序 a 最小,b第二大,c是最大值
//想尽所有办法保证a最小【只要把a最大的情况都排除即可】
int tmp = 0;
if(a>b){
tmp = a;
a = b;
b = tmp;
}//a可定比b小
if(a>c){
tmp = a;
a = c;
c = tmp;
}//a肯定最小了
if(b > c){
tmp = b;
b = c;
c = tmp;
}
System.out.println(a+" "+b+" "+c);
//4:有一个函数,当x<0,则y=-1;当x=0,y=0;当x>0,y=1,;编写一个程序,输入一个x值,输出一个y值。
int x = (int)(Math.random()*100);
x = x-30;
if (x<0){
System.out.println("y=-1");
}else if(x == 0){
System.out.println("y=0");
}else if(x > 0 ){
System.out.println("y=1");
}
//求出第三个数的最大值【最小值可以参考这个逻辑】
int tmp2 = a > b ? a : b;//这个表达式肯定会得到a和b之间的最大值
tmp2 = tmp2 > c ? tmp2 : c; //通过a和b之间的最大值和c进行比较得到最终最大值
System.out.println("最大值是:"+tmp2);
//获取控制台上一个字符
Scanner input = new Scanner(System.in);
System.out.println("请输入一个字符:");
char ch = input.next().charAt(0);
if (ch>='0' && ch<='9'){
System.out.println("是数字");
}else if(ch>='a' && ch<='z'){
System.out.println("是小写字母");
}else if(ch>='A' && ch<='Z'){
System.out.println("是大写字母");
}else{
System.out.println("其他字符");
}
}
}
import java.util.Scanner;
/**
* 作业最后三个小题
*/
public class HomeWork2 {
public static void main(String[] args) {
/**
* 12.水仙花数,是一个三位数
* 个位立方+十位的立方+百位的立方 == 原来的数 153 如何获取个位 十位 和 百位
* 百位数 153/100 = 1
*/
int n = 153;
//百位
int a = n/100; // --> 153/100-->1
//十位
int b = n/10%10; // --> 153/10%10 --> 15%10 --> 5
//个位
int c = n%10;// 153%10 --> 3
//Math.pow(被求的数据,次方) 次方计算的方
if((Math.pow(a,3)+Math.pow(b,3)+Math.pow(c,3)) == n){
System.out.println("是水仙花数:"+n);
}else{
System.out.println("不是水仙花数:"+n);
}
/* 13.输入一个时间,输出它的下一秒
* 在控制台上输入一个时间例如: 20:30:30 --> 打印出来 20:30:31
* 20:30:59 --> 20:31:00
* 20:59:59 --> 21:00:00
* 23:59:59 --> 00:00:00
* 这里的输出分别就是 小时,分钟 和 秒 --》 输出的时候必须是 小时:分钟:秒 --》 21:0:0
*
* PS:所有所学分支语句都是可以互相嵌套的
* if(){
* if(){
* switch(){
* case 1:
* break
* }
* }
* }
*/
System.out.println("------------------------------华丽的分割线------------------------------");
Scanner input = new Scanner(System.in);
System.out.println("请输入小时:");
int h = input.nextInt();
System.out.println("请输入分钟:");
int m = input.nextInt();
System.out.println("请输入秒:");
int s = input.nextInt();
//输出用户输入值的下一秒
s++; //秒+1
if(s == 60){
//秒要清0
s = 0;
//分钟要+1
m++;
if (m == 60){
m = 0; // 分钟要清0
h++;//小时要+1
if(h == 24){
h = 0 ;//小时清0
}
}
}
System.out.println(h+":"+m+":"+s);
/*
* 14.输出这一年的第几天,需要考虑闰年的问题
* 输入 2000-12-31 --》 打印是366天
* 输入 2000-1 -1 --》 打印是1天
*
* 提示:先明确,这一年中过完了几个月例如 2000-5-1 ,过完了和这个年中的 4 3 2 1四个月,你在过5月份第一天
* 1+4月份+3月份+2月份天数+1月份天数 == 总天数 需要注意2分月
*
* 2000-12-31 --> 2001-1-1 12-1
*/
System.out.println("------------------------------华丽的分割线------------------------------");
System.out.println("请输入年:");
int year = input.nextInt();
System.out.println("请输入月:");
int month = input.nextInt();
System.out.println("请输入日期:");
int day = input.nextInt();
//计算:
switch (month-1){//求出过完了多少个月
case 11:
day += 30;
case 10:
day += 31;
case 9:
day += 30;
case 8:
day += 31;
case 7:
day += 31;
case 6:
day += 30;
case 5:
day += 31;
case 4:
day += 30;
case 3:
day += 31;
case 2:
if((year%4==0 && year%100!=0)||(year%400==0)){
day += 29;
}else{
day+=28;
}
case 1:
day += 31;
System.out.println("这是这一年的第:"+day+"天");
break;
default:
System.out.println("这是这一年的第:"+day+"天");
break;
}
}
}
Java中的循环
PS:Java中程序的组成【顺序,分支,循环】
如果在程序中需要重复执行某个指令(代码),此时就需要使用到循环了
Java中常见的循环有**【while循环、do-while循环、for循环】**
PS:重点掌握for循环,其次while循环,最后do-while
写循环的要求:
1.重复操作事情【重复执行代码什么】
2.循环次数【重复多少遍】
while循环
语法:
PS:循环中重复的次数在程序的表现形式 ---》 一个范围判断 ---》 循环条件
既然做一个范围,那么就需要有一个开始的位置 ---》循环的起始点
---》通过这个起始点作为一个范围,判断这个范围,如果是在范围允许内的---》重复操作这个事情
---》如果不在这个范围内 ---》不执行
循环变量赋初值; //循环开始的位置
while(循环条件){ // 循环变量和你知道的循环次数 作为一个范围【循环次数】
重复操作的事情; //重复执行代码
控制循环变量的自增或自减; // 让循环趋于结束
}
说明:
1.while 是一个关键字
2.循环变量赋初值【基本上都是整数】,作用定义循环开始位置即起始点
3.循环条件【表达式】,作用起到对循环次数的控制【即控制循环范围】
表达式组成: 一般是由关系和逻辑运算符组成
PS:
"1.既然是关系和逻辑运算符,组成的表达式结果只有 true 和 false"
"2.一般多使用关系运算符作为,循环范围出现,常使用运算符【> >= < <=】"
"3.偶尔可见关系和逻辑运算符一次使用,常使用运算符【 == != && ||】"
"4.既然while循环的表达式是一个boolean类型,所以while循环条件就允许单独写 true 或 false"
4.{} 循环体,需要重复执行的代码都写到这个循环体中
PS:
"1.执行语句,就是重复代码【这个代码可以有N行】"
"2.循环变量的控制,就让循环趋于结束 ,让循环变量进行自增或自减"
执行过程:
当程序执行到循环变量赋初值的时候,先对循环变量进行初始化,然后执行while循环后循环条件判断,如果循环挑那判断为 true 就会执行{} 中的执行语句,执行语句执行完毕之后,会进行循环变量的自增或自减操作,会继续判断循环条件是否成立【判断是true还是false】,只要为 true 就继续执行之前的操作,否则【为false】循环结束
案例1
/**
* 基础案例:
*/
public class WhileDemo1 {
public static void main(String[] args) {
//1.输出10遍你好
/*
分析:
10 是循环执行次数 ---》 做一个范围满足这个次数
输出你好 ---》重复操作的事情
*/
//循环变量赋初值
int i = 0;
while(i<10){//循环条件
//重复的事情
System.out.println("你好");
//对循环变量自增或自减,以达到对循环的控制
i++;
}
}
}
案例2
/**
* 基础案例2:
*/
public class WhileDemo2 {
public static void main(String[] args) {
//1.打印100以内所有 奇数、偶数和3的倍数
/*
分析:
100是循环执行次数 ---》 做一个范围满足这个次数
重复操作的事情就是对数据的计算
重复计算 奇数 重复计算 偶数 重复计算3的倍数
谁可以做到这个计算?
循环变量赋初值,也看开始的位置,我们控制这个循环变量是不断变化
变化的范围真正好是在 100以内,所以就可以使用这个循环变量来参与这个运算
*/
//1.循环变量赋初值
int i =1;
while(i < 100){ //循环循环条件
//重复操作的事情
if(i%2 == 1){
System.out.println("奇数:"+i);
}
if(i%2 == 0){
System.out.println("偶数:"+i);
}
if(i%3 == 0){
System.out.println("3的倍数:"+i);
}
//控制循环变量让循环循环停止
i++;
}
}
}
PS:循环变量赋初值有两种存在的目的:
1.单纯的只为了循环条件而存在,不会参与到执行语句中计算
2.除了控制循环次数之外,也会参与到执行语句中计算
总结:
while循环是仅次于for循环而存在一个循环,循环的特点就是while循环后面循环条件是一个boolean表达式,所以利用这个原则写一个死循环,只要表达式的始终为true就是死循环,如果循环过程中是一个单纯的boolean表达式,建议优先使用while循环
PS:死循环书写---》 无限循环
while(true){
//重复执行操作语句会一直执行
}
do-while循环
PS:do-while循环和while循环有一些类似,之间可以看做时一个"亲戚"关系,do-while循环是while循环的倒写
语法:
循环变量赋初值
do{
执行语句:
循环变量的自增或自减;
}while(循环条件);
说明:
1. do while 都是关键字
2.循环变量赋初值【基本上都是整数】,作用定义循环开始位置即起始点
3.循环条件【表达式】,作用起到对循环次数的控制【即控制循环范围】
表达式组成: 一般是由关系和逻辑运算符组成
PS:
"1.既然是关系和逻辑运算符,组成的表达式结果只有 true 和 false"
"2.一般多使用关系运算符作为,循环范围出现,常使用运算符【> >= < <=】"
"3.偶尔可见关系和逻辑运算符一次使用,常使用运算符【 == != && ||】"
"4.既然while循环的表达式是一个boolean类型,所以while循环条件就允许单独写 true 或 false"
4.{} 循环体,需要重复执行的代码都写到这个循环体中
PS:
"1.执行语句,就是重复代码【这个代码可以有N行】"
"2.循环变量的控制,就让循环趋于结束 ,让循环变量进行自增或自减"
展示while循环和do-while循环的不同
/**
* 演示do-while循环
*/
public class DoWhileDemo {
public static void main(String[] args) {
//使用while循环和do-while循环完成1-10的打印
System.out.println("-----------------------------while循环-----------------------------");
int i = 1;
while(i<10){
System.out.println(i);
i++;
}
System.out.println("-----------------------------do-while循环-----------------------------");
//1.循环变量赋初值
int j = 1;
do {
//重复操作的事情
System.out.println(j);
//循环变量的自增
j++;
}while(j<10);//循环条件
}
}
总结:
本质上do-while循环和while循环是一样的,无论是操作重复的事情还是控制重复的次数都是一样,只不过do-while循环是while循环的倒写
极端修改代码
PS:将判断条件统一设置为 i<1 和 j<1
/**
* 演示do-while循环
*/
public class DoWhileDemo {
public static void main(String[] args) {
//使用while循环和do-while循环完成1-10的打印
System.out.println("-----------------------------while循环-----------------------------");
int i = 1;
while(i<1){
System.out.println(i);
i++;
}
System.out.println("-----------------------------do-while循环-----------------------------");
//1.循环变量赋初值
int j = 1;
do {
//重复操作的事情
System.out.println(j);
//循环变量的自增
j++;
}while(j<1);//循环条件
}
}
说明do-while循环执行的方式和while区别
1.do-while 的执行:
当程序执行到do-while循环的时候,首先会先执行do后面{}中的执行语句,然后循环变量会进行自增或自减,在去判断循环条件是否成,如果循环条件成立,会在此执行do后面{}中的语句,如果循环循环条件不成立,循环会终止
2.do-while 和 while 循环的区别
do-while 循环 先执行语句,然后在判断循环条件是否成立
while 循环 先执行判断循环条件是否成立,然后在执行语句
for循环
语法:
for(循环变量赋初值;循环条件;循环变量的自增或自减){
执行语句;
}
说明:
1. for 是关键字
2.循环变量赋初值【基本上都是整数】,作用定义循环开始位置即起始点
3.循环条件【表达式】,作用起到对循环次数的控制【即控制循环范围】
表达式组成: 一般是由关系和逻辑运算符组成
PS:
"1.既然是关系和逻辑运算符,组成的表达式结果只有 true 和 false"
"2.一般多使用关系运算符作为,循环范围出现,常使用运算符【> >= < <=】"
"3.偶尔可见关系和逻辑运算符一次使用,常使用运算符【 == != && ||】"
"4. for循环的循环条件也是boolean表达式,默认不写就是true"
4.循环变量的控制,就让循环趋于结束 ,让循环变量进行自增或自减"
5.{} 循环体,需要重复执行的代码都写到这个循环体中
PS:
"1.执行语句,就是重复代码【这个代码可以有N行】"
问题:
1.for循环中的循环变量赋初值
因为for循环的循环变量赋初值,定义在当前for的小括号中,所以这个变量只能在for中使用
这个变量在java中称为"局部变量"
PS:或者可以称为"密封变量" --》C#语言
2.for循环的基础条件都是写到小括号中,所以每一个条件写完都需要使用【;】
3.for循环也支持"死循环的写法",默认不写循环条件,就是死循环
执行过程:
当程序执行到for循环的时候,首先会进行循环变量和赋初值操作【1次】,然后会判断循环条件【多次】,如果循环条件成立【为true】,就执行{}循环体,执行重复操作的事情,会继续执行循环变量自增或自减【多次】,继续判断循环条件,直到循环条件不成立【为false】,循环才会结束
案例1:
/**
* for循环的基础案例
*/
public class ForDemo1 {
public static void main(String[] args) {
//1.打印从0开始到10结束,中间所有值输出
/*
分析:
重复次数 --》 因为是从0开始到10结束 所以范围就是0~10之间
重复操作的事情 --》 打印0~10之间的值
*/
// for(循环变量赋初值;循环条件;循环变量的自增或自减)
for(int i = 0;i<10;i++){
System.out.println(i);
}
}
}
案例2
求出1-100之间所有数的和包括100
/**
* for循环的案例【求和】
*/
public class ForDemo2 {
public static void main(String[] args) {
//1.计算1-100以内所以数的和包括100
/*
分析:
次数 --》100次 ---》范围 1~100之间包含100---》就不能只使用<【小于号】 需要是使用<=【小于等于】
重复事情: 求出1~100之内所有数据的和 有一个计数的变量 ,存储着数据和
*/
//1.创建一个变量,用来存储数据的和,这个变量的初始值不能影响最终计算结果
//PS:一般做求和计算的时候,存储和的变量初始值都为0,因为0不会影响计算结果
int sum = 0;
for (int i = 1; i<=100; i++){
//求和
// sum = sum+i;// 0+1+2+3+4+5+6+7+8+.....+100
//如果表达式的计算最终结果赋值给参与表达式计算变量,使用复合运算符
sum += i;
}
System.out.println("和是:"+sum);
}
}
案例3
求出5!? --》 相当于求出5的阶乘 ---》 1*2*3*4*5
/**
* for循环的案例【求阶乘】
*/
public class ForDemo3 {
public static void main(String[] args) {
//1.计算5! --》 1*2*3*4*5
/*
分析:
次数 --》5 ---》范围 1~5 因为阶乘是包含最后一位值,所以需要使用<=
重复事情: 求出1~5乘积 有一个计数的变量 ,存储着乘积
PS:千万不要小看乘积,因为就这个计算是恐怖的,轻易之间就会超过存储范围
*/
//1.创建一个变量,用来存储数据乘积的时候,这个变量的初始值不能影响最终计算结果
//PS:一般做求乘积计算的时候,存储和的变量初始值都为1,因为1不会影响计算结果
int num = 1;
for (int i = 1; i<=5; i++){
//如果表达式的计算最终结果赋值给参与表达式计算变量,使用复合运算符
num *= i;
}
System.out.println("乘积是:"+num);
}
}
练习:
/**
* 已知第一位和第二位都是1,从第三为开始 等于前前两位之和, 求出前20位之和
*/
public class FibonacciDemo {
public static void main(String[] args) {
//1.定义两个变量,这个两个变量存储就着1和1的值
int n1 = 1;
int n2 = 1;
//2.在定义一个变量这个变量存储存第三位的值
int n3 = 0;
//3. 求出当前菲波那切数列求出前20位和 1+1+2+3+5+8....
//在定义这个初始变量的时候,先求出前两位值和
int sum = n1 + n2;
//4.因为已经将前2两位的和计算了,所以循环次数就需要从原有20次变成18
for(int i = 0;i<18;i++){
//先求出第3位
n3 = n1+n2;
System.out.println("n3 = "+n3);
//累加计算和
sum = sum + n3; //第一次循环相当于是 n1+n2+n3的值
//5.需要循环求出以后的每一位n3, n3前两位之和
//为了求出全新的一位n3,只需要将原有n2的值赋值给n1 原有n3值赋值给n2
//这样做的话,相当于是移动位置
n1 = n2;
n2 = n3;
}
System.out.println("和是:"+sum);
}
}
for循环的6种写法
/**
* 6种写法
*/
public class ForDemo4 {
public static void main(String[] args) {
//1.标准写法
for(int i = 0;i<10;i++){
System.out.println(i);
}
//2.将循环变量赋初值,定义在循环体的外部
//2.1定义在外部并赋值,此时这个变量就在循环的外部可以访问了
int i = 1;
for(;i<10;i++){
System.out.println(i);
}
//2.2在外部定义,在内部赋值,此时这个变量就在循环的外部可以访问了
int i;
for(i = 0 ;i<10;i++){
System.out.println(i);
}
//PS:在外部获取的到的i值是,当前循环结束的值
//3.for循环死循环写法的第一种,不写循环条件【默认true】
for(int i = 0;;i++){
System.out.println(i);
}
//4.将循环变量的自增或自减写入到循环体中
for(int i = 0;i<10;){
System.out.println(i);
i++;
}
//5.仿照while循环书写
int i = 0;
for(;i<10;){
System.out.println(i);
i++;
}
//6.for循环死循环写法第二种
int i= 0;
for(;;){
System.out.println(i);
i++;
}
}
}
循环嵌套
PS:所有的循环都是允许嵌套,这里仅以for循环为例讲解
说明:
1.嵌套循环指的是在循环体内有另外一个循环,即重复执行事情时另外一个循环
2.在外层的循环 --> 外层循环
3.在外层循环的内部 --> 内层循环
例如:
for(int i = 1;i<10;i++){ // --> 外层循环
for(int j = 1;j<10;j++){ // --> 内层循环
//此时就是循环嵌套
}
}
ps:
1."外层循环执行1次,内层循环执行多次"
2."内层循环不结束,外层循环无法开启下一次"
3."外层循环的【循环变量】可以参与到内层循环中进行计算"
4."外层循环的【循环变量】可以对内层循环的【循环条件】进行限制"
通过嵌套循环可以解决:数据的排序,图形的打印,程序中访问位置的嵌套【使用循环方式遍历文件夹】
通俗理解:
将循环嵌套看做时一本书,外层循环相当于是书中每一页,内层循环相当于是每一页中每一个行内容,只有看完当前页的每一行内容,才可以翻页---》【相当于】---》 内层循环执行完毕之后,才能开启外层循环
需求:
输出一个矩阵:
1 2 3 4 5
2 4 6 8 10
3 6 9 12 15
4 8 12 16 20
/**
* 嵌套循环
*/
public class ForDemo5 {
public static void main(String[] args) {
/*
1 2 3 4 5
2 4 6 8 10
3 6 9 12 15
4 8 12 16 20
*/
for(int j = 1;j<=4;j++) {
for (int i = 1; i <= 5; i++) {
// 转义字符 --> \t --> tab【四个空格】
System.out.print(i*j + "\t");
}
System.out.println();
}
}
}
三个关键字break,continue,return
PS:这三个关键字都可以用来对循环进行操作**【return是一个特殊】**
break关键字
若不需要在通过循环条件停止循环的前提下,可以使用break关键字
PS:正常循环停止是因为,当前的循环添加为false,不想为false时停止循环,而是达到某个条件的时候停止,就可以使用break关键字
break关键字只能给循环和switch使用
break的一个小问题
break关键字只能停止当前循环【当前这层】,如果是嵌套循环,需要将循环都停止,就建议在最外层循环的位置添加一个“标签”,可以标记循环的名字,使用break的时候可以对这个带有标签名字循环进行终止,已达到对嵌套循环的停止
案例:
/**
* break关键字的使用
*/
public class BreakDemo {
public static void main(String[] args) {
//1.一层循环使用break
for(int i = 0;i<10;i++){
//当i值等于5的时候,让循环停止
if(i == 5){
break;
}
System.out.println(i);
}
//2. 嵌套循环中break在哪个循环中使用,停止哪个循环
EXIT:for(int n = 1;n<=3;n++){
for(int m = 1;m<=3;m++){
//当m等于2的时候让所有循环都停止,在外层循环的前面添加标签,使用break关键字 指定关闭哪个循环
if(m == 2){
break EXIT;
}
System.out.println("n="+n+","+"m="+m);
}
}
}
}
Continue关键字
continue关键字是跳过本次循环,开始下一次循环
/**
* continue关键字
*
*/
public class ContinueDemo {
public static void main(String[] args) {
//计算100~200之间不能被3整除数据
for(int i = 100;i<=200;i++){
if(i % 3 == 0){//判断条件是整除3
continue;
}
System.out.println("不能被3整数的数字:"+i);
}
}
}
说明:
break是完全终止循环,而Continue是停止当前循环,让循环开启下一次,它的式根据循环条件为false结束
return关键字
ps:return关键字本质是结束一个方法,而不是结束循环,为什么使用return关键可以让循环停止,因为循环是写在方法体的内部,方法都没有了,循环自然不存在了,无论是多少层循环都停止 。
/**
* 简单使用
*/
public class ReturnDemo {
public static void main(String[] args) {
for(int n = 1;n<=3;n++){
for(int m = 1;m<=3;m++){
//当m等于2的时候让所有循环都停止
if(m == 2){
//谨慎在main方法使用return
return;
// break EXIT;
}
System.out.println("n="+n+","+"m="+m);
}
}
}
}