我是靠谱客的博主 天真鞋子，最近开发中收集的这篇文章主要介绍语言基础第三四五天：运算符和分支结构(if/if...else) | 扫描仪sc、分支(if.else/swith.case)、循环(while/do.while)、循环结构、嵌套循环、数组语言基础第三天：语言基础第四天：语言基础第五天：，觉得挺不错的，现在分享给大家，希望可以做个参考。
概述
语言基础第三天：
回顾：
0.Java的8种基本数据类型是什么？
8种基本数据类型包括: byte,short,int,long,float,double,boolean,char
byte:字节型，用于存储整数的，占用1个字节，范围-128到127
*char:字符型，采用Unicode字符编码格式，存储单个字符，占用2个字节
*short:短整型，用于存储整数的，占用2个字节，范围-32768到32767
int:最常用的整型，用于存储整数的，占用4个字节，范围-2^31到231-1
long:长整型，用于存储较大的整数的，占用8个字节，范围-2^63到2^63-1
float:单精度浮点型，用于存储小数的，占用4个字节，不能表示精确的值
double:双精度浮点型，最常用的存储小数的类型，占用8个字节，不能表示精确的值
boolean:布尔型，存储true或false，占用1个字节
1.变量：存数的
int a; int b,c;
int a = 5; int a; a=5;
int b = a+10; System.out.println(a);
a = a+10; //在a本身基础之上增10
2.八种基本数据类型：byte,short,int,long,float,double,boolean,char
- int：整型，4个字节，5,10,10000000...
- long：长整型，8个字节，5L,100000000000000L...
- double：浮点型，８个字节，3.14,54.0,5.678...
- boolean：布尔型，1个字节，true,false
- char：字符型，2个字节，'你','y','4','*'...
3.类型间的转换：
两种方式：自动/隐式、强制 (要转换成为的数据类型)变量
两点规则：
shorts1=5;
shorts2=6;
shorts3=(short)(s1+s2);
笔记：
1.运算符：运算的符号
(1)算术：+，-，*，/，%，++，
- %:取模/取余，余数为0即为整除
- ++/--：自增1/自减1，可在变量前也可在变量后
- 单独使用时，在前在后都一样
- 被使用时，在前在后不一样
- a++的值为a--------(a--的值为a)
- ++a的值为a+1------(--a的值为a-1)
```java
//%的演示
System.out.println(8%2); //0，商4余0----整除
System.out.println(5%2); //1，商2余1
System.out.println(2%8); //2，商0余2
//++单独使用:
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6
//++被使用:
int a=5,b=5;
int c = a++; //1)保存a++的值5 2)a自增1变为6 3)将第1步保存的值5赋值给c--底层运算过程
//---粗暴记法:a++的值为5，c就是5
int d = ++b; //1)保存++b的值6 2)b自增1变为6 3)将第1步保存的值6赋值给d--底层运算过程
//---粗暴记法:++b的值为6，d就是6
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6
//--单独使用:
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4
//--被使用:
int a=5,b=5;
int c = a--; //a--的值为5，所以c的值为5
int d = --b; //--b的值为4，所以d的值为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4
```
(2)关系运算符：>，<，>=，<=，==，!
- 关系运算的结果为boolean型，
关系成立则为true，关系不成立则为false
```java
int a=5,b=10,c=5;
boolean b1 = a>b;
System.out.println(b1); //false
System.out.println(c<b); //true
System.out.println(a>=c); //true
System.out.println(a<=b); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false
System.out.println(a+c>b); //false
System.out.println(a%2==0); //false
System.out.println(c++>5); //false-------c自增1变为6
System.out.println(c++>5); //true--------c自增1变为7
```
(3)逻辑运算符：&&，||，!
&&：短路与(并且)，两边都为真则为真，见false则false
> 当第1个条件为false时，发生短路(后面的不执行了)
||：短路或(或者)，有真则为真，见true则true
> 当第1个条件为true时，发生短路(后面的不执行了)
!：逻辑非(取反)，非真则假，非假则真
int a=5,b=10,c=5;
//&&的演示:
boolean b1 = b>=a && b<c;
System.out.println(b1); //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true
int age = 25;
System.out.println(age>=18 && age<=50); //看age是否在18到50之间
//||的演示:
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false
int score = 89;
System.out.println(score<0 || score>100); //看score是否不合法
//!的演示
boolean b2 = !(a<b);
System.out.println(b2); //!true=false
System.out.println(!(a>b)); //!false=true
//短路的演示
int a=5,b=10,c=5;
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c); //5，发生短路了
boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c); //5，发生短路了
(4)赋值运算符：=，+=，-=，*=，/=，%
简单赋值运算符：=
扩展赋值运算符：+=，-=，*=，/=，%=
> 注：扩展赋值自带强转功能
int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5
//小面试题:
short s = 5;
//s = s+10; //编译错误，需强转: s=(short)(s+10);
s += 10; //相当于s=(short)(s+10)
(5)字符串连接：+
- 和 +：
- 若两边为数字，则做加法运算
- 若两边出现了字符串，则做字符串连接
- 任何类型与字符串相连，结果都会变为字符串类型----同化作用
//字符串拼接演示
int age = 38;
System.out.println("age="); //age=
System.out.println(age); //38
System.out.println("age="+age); //age=38
System.out.println("我的年龄是"+age); //我的年龄是38
System.out.println("我今年"+age+"岁了"); //我今年38岁了
String name = "WKJ";
System.out.println("name="+name); //name=WKJ
System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年38岁了
//同化作用演示
System.out.println(10+20+30+""); //60---------String
System.out.println(10+20+""+30); //3030-------String
System.out.println(""+10+20+30); //102030-----String
(6)条件/三目：?:
语法： boolean?数1:数2
执行过程： 注：整个表达式是有值的，它的值要么是?号后的数1，要么是:号后的数2
计算boolean的值：
- 若为true，则整个表达式的值为?号后的数1
- 若为false，则整个表达式的值为:号后的数2
int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1
int a=8,b=55;
int max = a>b?a:b;
System.out.println("max="+max);
2.分支结构：基于条件执行某语句
(1)if结构：1条路
语法：
if(boolean){
语句块
}
执行过程：
判断boolean的值:
若为true，则执行语句块1(if整个结束)
若为false，则if直接结束
//1)偶数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
System.out.println(num+"是偶数");
}
System.out.println("继续执行...");
//2)满500打8折:
double price = 300.0; //消费金额 带数(600.0,300.0)
if(price>=500){ //满500
price *= 0.8; //打8折
}
System.out.println("最终结算金额为:"+price);
//3)判断年龄是否在18到50之间，若满足则输出:"满足条件"
int age = 88; //带数(25,5,88)
if(age>=18 && age<=50){
System.out.println("年龄满足条件");
}
System.out.println("继续执行...");
(2)if…else结构：2条路
语法：
if(boolean){
语句块1
}else{
语句块2
}
执行过程：
判断boolean的值:
若为true，则执行语句块1(整个结束)
若为false，则执行语句块2(整个结束)
- 说明：
语句块1和语句块2，必走其中之一------------2选1
//1)偶数、奇数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
System.out.println(num+"是偶数");
}else{
System.out.println(num+"是奇数");
}
System.out.println("继续执行...");
//2)满500打8折，不满500打9折:
double price = 300.0; //带数(600.0,300.0)
if(price>=500){ //满500
price *= 0.8;
}else{ //不满500
price *= 0.9;
}
System.out.println("最终结算金额为:"+price);
//3)判断成绩是否合法，合法则输出"该成绩合法"，否则输出"该成绩不合法":
int score = 560; //带数(95,-90,560)
if(score<0 || score>100){
System.out.println("该成绩不合法");
}else{
System.out.println("该成绩合法");
}
System.out.println("继续执行...");
精华笔记：
-
运算符：运算的符号
-
算术：+，-，*，/，%，++，–
-
关系：>，<，>=，<=，==，!=
-
逻辑：&&，||，！
-
赋值：=，+=，-=，*=，/=，%=
-
字符串连接：+
-
条件/三目：?:
-
-
分支结构：基于条件执行某语句
- if结构：1条路
- if…else结构：2条路
补充：
- &为不短路与，|为不短路或
- 任何复杂的程序逻辑都可以通过三种结构来实现：
- 顺序结构：从上往下逐行执行，每句必走
- 分支结构：有条件的执行某语句，并非每句必走
- 循环结构：明天讲
语言基础第三天作业：
- 运算符的练习：算术、关系、逻辑、赋值、字符串连接、条件运算符
- if的练习：
- 偶数的判断
- 满500打8折
- 年龄在18到50之间
- if…else练习：
- 偶数、奇数的判断
- 满500打8折、不满500打9折
- 成绩合法性判断
1、运算符的练习：算术、关系、逻辑、赋值、字符串连接、条件运算符。 完整代码：
//运算符的演示
public class OperDemo {
public static void main(String[] args) {
/*
1.算术运算符:+,-,*,/,%,++,–
1)%:取模/取余，余数为0即为整除
2)++/–:自增1/自减1，可在变量前也可在变量后
2.1)单独使用时，在前在后都一样
2.2)被使用时，在前在后不一样
a++的值为a----------(a–的值为a)
++a的值为a+1--------(–a的值为a-1)
/
/
System.out.println(5%2); //1，商2余1
System.out.println(8%2); //0，商4余0----整除
System.out.println(2%8); //2，商0余2
/
/
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6
/
/
int a=5,b=5;
int c = a++; //1)将a++的值5赋值给c 2)a自增1变为6
int d = ++b; //1)将++b的值6赋值给d 2)b自增1变为6
System.out.println(a); //6
System.out.println(b); //6
System.out.println©; //5
System.out.println(d); //6
*/
/*
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4
*/
/*
int a=5,b=5;
int c = a--; //1)将a--的值5赋值给c 2)a自减1变为4
int d = --b; //1)将--b的值4赋值为d 2)b自减1变为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4
*/
/*
2.关系运算符:
1)>(大于),<(小于)
>=(大于或等于),<=(小于或等于)
==(等于),!=(不等于)
2)关系运算的结果为boolean型，
关系成立则为true，关系不成立则为false
*/
/*
int a=5,b=10,c=5;
boolean b1 = b>a;
System.out.println(b1); //true
System.out.println(c<b); //true
System.out.println(a>=c); //true
System.out.println(b<=a); //false
System.out.println(b==c); //false
System.out.println(a!=c); //false
System.out.println(a+c>10); //false
System.out.println(b%2==0); //true
System.out.println(c++>5); //false------c自增1变为6
System.out.println(c++>5); //true-------c自增1变为7
*/
/*
3.逻辑运算符:
1)&&:短路与(并且)，两边都为真则为真，见false则false
---当第1个条件为false时，则发生短路(后面的不执行了)
||:短路或(或者)，有真则为真，见true则true
---当第1个条件为true时，则发生短路(后面的不执行了)
!:逻辑非(取反)，非真则假，非假则真
2)逻辑运算是建立在关系运算的基础之上的，
逻辑运算的结果也是boolean型
*/
/*
boolean b1 = b>=a && b<c;
System.out.println(b1); //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false
boolean b2 = !(a<b);
System.out.println(b2); //!true=false
System.out.println(!(a>b)); //!false=true
*/
/*
int a=5,b=10,c=5;
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c); //5，发生短路了
boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c); //5，发生短路了
*/
/*
4.赋值运算符:
1)基本赋值运算符:=
2)扩展赋值运算符:+=,-=,*=,/=,%=
---扩展赋值运算符自带强转功能
*/
/*
int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5
short s = 5;
//s = s+10; //编译错误，需强转，改为: s=(short)(s+10);
s += 10; //相当于s=(short)(s+10)
*/
/*
5.字符串连接运算符:
1)+:
1.1)若两边为数字，则做加法运算
1.2)若两边出现了字符串，则做字符串连接
*/
/*
int age = 38;
System.out.println("age="); //age=
System.out.println(age); //38
System.out.println("age="+age); //age=38
System.out.println("我的年龄是"+age); //我的年龄是38
System.out.println("我今年"+age+"岁了"); //我今年38岁了
String name = "WKJ";
System.out.println("name="+name); //name=WKJ
System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年38岁了
System.out.println(10+20+""+30); //3030---------String
System.out.println(""+10+20+30); //102030-------String
System.out.println(10+20+30+""); //60-----------String
*/
/*
6.条件/三目运算符:
1)语法:
boolean?数1:数2
2)执行过程:
整个条件运算的值，要么是?号后的数1，要么是:号后的数2
计算boolean的值:
若为true，则整个条件运算的结果为?号后的数1
若为false，则整个条件运算的结果为:号后的数2
*/
int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1
int a=8,b=5;
int max = a>b?a:b;
System.out.println("max="+max);
}
}
2、if的练习：
-
偶数的判断
-
满500打8折
//if结构的演示
public class IfDemo {
public static void main(String[] args) {
//1)偶数的判断:
int num = 6; //带数(6,5)
if(num%2==0){
System.out.println(num+“是偶数”);
}
System.out.println(“继续执行…”);
//2)满500打8折
//带数(600.0,300.0)
double price = 300.0; //消费金额
if(price>=500){ //满500
price*=0.8; //打8折
}
System.out.println("最终结算金额为:"+price);
}
}
3、if…else的练习：
-
偶数、奇数的判断
-
满500打8折，不满500打9折
//if…else结构的演示
public class IfElseDemo {
public static void main(String[] args) {
//1)偶数、奇数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
System.out.println(num+“是偶数”);
}else{
System.out.println(num+“是奇数”);
}
System.out.println(“继续执行…”);
//2)满500打8折，不满500打9折:
double price = 300.0; //带数(600.0,300.0)
if(price>=500){ //满500，打8折
price*=0.8;
}else{ //不满500，打9折
price*=0.9;
}
System.out.println("最终结算金额为:"+price);
}
}
语言基础第四天：
回顾：
- 运算符：
- 算术：+，-，*，/，%，++，–
- 关系：>，<，>=，<=，==，!= boolean
- 逻辑：&&，||，! boolean
- 赋值：=，+=，-=，*=，/=，%=
- 字符串连接：+
- 条件/三目：boolean?数1:数2
- 分支结构：基于条件执行的语句
- if结构：1条路
- if…else结构：2条路
笔记：
1、Scanner接收用户输入的数据：共3步，不需要理解，先背下来
-
在package下：
import java.util.Scanner;
-
在main中：
Scanner scan = new Scanner(System.in);
-
在第2步之下：
System.out.println(“请输入年龄:”);
int age = scan.nextInt();
System.out.println(“请输入商品价格:”);
double price = scan.nextDouble();
package day04;
import java.util.Scanner; //1.导入一个扫描仪
//Scanner的演示
public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in); //2.新建一个扫描仪
System.out.println("请输入年龄:");
int age = scan.nextInt(); //3.扫描一个整数给age
System.out.println("请输入商品价格:");
double price = scan.nextDouble(); //3.扫描一个小数给price
System.out.println("年龄为:"+age+"，价格为:"+price);
}
}
2、分支结构：
-
if…else if结构：多条路
-
语法：
if(boolean-1){
语句块1
}else if(boolean-2){
语句块2
}else if(boolean-3){
语句块3
}else{
语句块4
} -
执行过程：
判断boolean-1，若为true则执行语句块1(结束)，若为false则
再判断boolean-2，若为true则执行语句块2(结束)，若为false则
再判断boolean-3，若为true则执行语句块3(结束)，若为false则 执行语句块4(结束) -
说明：
语句块1/2/3/4，只能执行其中之一------------多选1
-
public class ScoreLevel {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入成绩:");
double score = scan.nextDouble();
//带数(-25,888,95,85,65,45)
if(score<0 || score>100){
System.out.println("成绩不合法");
}else if(score>=90){ //合法
System.out.println("A-优秀");
}else if(score>=80){
System.out.println("B-良好");
}else if(score>=60){
System.out.println("C-中等");
}else{
System.out.println("D-不及格");
}
}
}
3、switch…case结构：多条路
- 优点：效率高、结构清晰
- 缺点：只能对整数判断相等
- break：
- 若case中有break：打印对应的case语句后，直接跳出switch
- 若case没有break：从对应命令的case开始往下贯穿打印每一句话
default：可以写在switch中的任何地方；写不写都可以；
若写了:在case没有匹配参数时会按顺序执行(此时不执行case，因为都未匹配成功先执行default再贯穿剩余case)；
:在case匹配了参数时不会执行default
若没写：会按顺序执行case匹配到的语句；若没有匹配的则全部执行
常见面试题：switch可以作用于什么类型的数据上
----byte,short,int,char,String,枚举类型
package ooday6.day04.switch0_0;
import java.util.Scanner;
/**
* //命令解析程序
* 创建commandBySwitch类 要求：接收用户输入的命令command(int),并输出
*
* switch…case结构：多条路 只能对整数进行判断
* 优点：效率高、结构清晰
* 缺点：只能对整数判断相等
*
* break：
* 若case中有break：打印对应的case语句后，直接跳出switch
* 若case没有break：从对应命令的case开始往下贯穿打印每一句话
*
* default：可以写在switch中的任何地方；写不写都可以；
* 若写了:在case没有匹配参数时会按顺序执行(此时不执行case，因为都未匹配成功先执行default再贯穿剩余case)；
* :在case匹配了参数时不会执行default
* 若没写：会按顺序执行case匹配到的语句；若没有匹配的则全部执行
*/
public class CommandBySwitch {
public static void main(String[] args) {
// System.out.println("请选择功能：1.取款 2.存款 3.查询余额");//-----注意：要想打印这句话，需放在扫描数的上边。
// Scanner scanner = new Scanner(System.in);
// int command = scanner.nextInt();
// System.out.println("请选择功能：1.取款 2.存款 3.查询余额 4.退卡操作");
// int command = new Scanner(System.in).nextInt();
// switch (command) { //byte,short,int,char,String,枚举类型
// case 1:
// System.out.println("取款操作...");
// break;
// case 2:
// System.out.println("存款操作...");
// break;
// case 3:
// System.out.println("查询余额...");
// break;
// case 4:
// System.out.println("退卡操作...");
// break;
// default:
// System.out.println("操作错误...");
// }
int num = 5;
switch (num) {
case 3:
System.out.println("555");
case 6:
System.out.println("8888");
default://default：可以写在switch中的任何地方；写不写都可以；
// 若写了:在case没有匹配参数时会按顺序执行；
// :在case匹配了参数时不会执行default
//若没写:会按顺序执行case匹配到的语句；若没有匹配的则全部执行
System.out.println("11");
//break;//若有break，直接跳出switch；若没有break，则贯穿执行全部输出语句
case 0:
System.out.println("22");
}
}
}
4、 循环：反复多次执行一段相同或相似的代码
循环三要素：
-
循环变量的初始化
-
循环的条件(以循环变量为基础)
-
循环变量的改变(向着循环的结束变)
循环变量：在整个循环过程中所反复改变的那个数
//跑3圈:
循环变量:所跑圈数count
1)int count=0;
2)count<3
3)count++;
count=0/1/2/ 3时结束
圈数为0
够3圈吗？ 不够 跑一圈 圈数为1
够3圈吗？ 不够 跑一圈 圈数为2
够3圈吗？ 不够 跑一圈 圈数为3
够3圈吗？ 够了
//打印机打印6份简历:
循环变量:所打份数num
1)int num=0;
2)num<6
3)num++;
num=0/1/2/3/4/5/ 6时结束
份数为0
够6份吗？ 不够 打印一份 份数为1
够6份吗？ 不够 打印一份 份数为2
够6份吗？ 不够 打印一份 份数为3
够6份吗？ 不够 打印一份 份数为4
够6份吗？ 不够 打印一份 份数为5
够6份吗？ 不够 打印一份 份数为6
够6份吗？ 够了
5、循环结构：
-
while结构：先判断后执行，有可能一次都不执行
-
语法：
while(boolean){
语句块-------------反复执行的代码
} -
执行过程：
判断boolean的值，若为true则执行语句块，
再判断boolean的值，若为true则再执行语句块，
再判断boolean的值，若为true则再执行语句块，
如此反复，直到boolean的值为false时，while循环结束 -
代码演示：
-
//1)输出5次"行动是成功的阶梯":
int times = 0; //1)循环变量的初始化
while(times<5){ //2)循环的条件
System.out.println("行动是成功的阶梯");//反复干的事必须放在第三要素之前
times++; //3)循环变量的改变
}
System.out.println("继续执行...");
/*
执行过程:----带数
times=0
true 输出 times=1
true 输出 times=2
true 输出 times=3
true 输出 times=4
true 输出 times=5
false while循环结束
输出继续执行...
*/
//2)输出9的乘法表:
int num = 1; //3*9=27
while(num<=9){
System.out.println(num+"*9="+num*9);
num++; //num+=2;
}
System.out.println("继续执行...");
6、猜数字小游戏代码：
package day04;
import java.util.Random;
import java.util.Scanner;
/** 猜数字小游戏 */
public class Guessing {
public static void main(String[] args) {
/*
int num = (int)(Math.random()*1000+1); //1到1000
Math.random()--------------0.0到0.9999999999999999...
*1000----------------------0.0到999.99999999999999...
+1-------------------------1.0到1000.9999999999999...
(int)----------------------1到1000
*/
Scanner scanner = new Scanner(System.in);
// int num = 250;//定死的数
int num = (int)(Math.random()*1000+1);//1~1000的随机数
System.out.println(num);//作弊 直接将生成的随机数显示在控制台
System.out.println("猜吧");
int guess = scanner.nextInt();
while(guess!=num){
if(guess>num){
System.out.println("猜大了！继续猜");
}else{
System.out.println("猜小了！继续猜");
}
guess = scanner.nextInt();
}
System.out.println("猜对了");
}
}
7、do…while结构：先执行后判断，至少执行一次
要素1与要素3相同时，首选do…while
语法：
do{
语句块
}while(boolean);
执行过程：
先执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，如此反复，直到boolean的值为false，则 do…while结束
猜数字小游戏代码：
public class Guessing {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
System.out.println(num); //作弊
//假设num=250
//300(大),200(小),250(对)
int guess;
do{
System.out.println("猜吧!");
guess = scan.nextInt(); //1+3
if(guess>num){
System.out.println("太大了");
}else if(guess<num){
System.out.println("太小了");
}else{
System.out.println("恭喜你猜对了");
}
}while(guess!=num); //2
}
}
补充：
-
变量的作用域/范围：
- 从变量的声明开始，到包含它最近的大括号结束
-
生成随机数：
int num = (int)(Math.random()*1000+1); //1到1000 Math.random()--------------0.0到0.9999999999999999... *1000----------------------0.0到999.99999999999999... +1-------------------------1.0到1000.9999999999999... (int)----------------------1到1000 -
任何复杂的程序逻辑都可以通过三种结构来实现：
-
顺序结构：从上往下逐行执行，每句必走
-
分支结构：有条件的执行某语句一次，并非每句必走
-
循环结构：有条件的执行某语句多次，并非每句必走
-
精华笔记：
-
Scanner接收用户输入的数据：共3步，不需要理解，先背下来
-
分支结构：
-
if…else if结构：多条路
-
switch…case结构：多条路
优点：效率高、结构清晰
缺点：只能对整数判断相等
break：跳出switch
常见面试题：switch可以作用于什么类型的数据上
-------------------------byte,short,int,char,String,枚举类型
-
-
循环：反复多次执行一段相同或相似的代码
-
循环三要素：
-
循环变量的初始化
-
循环的条件(以循环变量为基础)
-
循环变量的改变(向着循环的结束变)
循环变量：在整个循环过程中所反复改变的那个数
-
-
循环结构：
-
while结构：先判断后执行，有可能一次都不执行
-
do…while结构：先执行后判断，至少执行一次
要素1与要素3相同时，首选do…while
-
语言基础第四天作业：
1、ScoreLevel成绩等级判断
2、CommandBySwitch命令解析程序
3、Guessing猜数字之while版
4、Guessing猜数字之do…while版
1、ScoreLevel成绩等级判断。完整代码：
package day04;
import java.util.Scanner;
//成绩等级判断
public class ScoreLevel {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入成绩:");
double score = scan.nextDouble();
//带数(888,-45,95,85,65,45)
if(score<0 || score>100){
System.out.println("成绩不合法");
}else if(score>=90){ //合法
System.out.println("A-优秀");
}else if(score>=80){
System.out.println("B-良好");
}else if(score>=60){
System.out.println("C-中等");
}else{
System.out.println("D-不及格");
}
}
}
2、CommandBySwitch命令解析程序。完整代码：
package day04;
import java.util.Scanner;
//命令解析程序
public class CommandBySwitch {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请选择功能: 1.取款 2.存款 3.查询余额 0.退卡");
int command = scan.nextInt();
switch(command){
case 1:
System.out.println("取款操作...");
break;
case 2:
System.out.println("存款操作...");
break;
case 3:
System.out.println("查询余额操作...");
break;
case 0:
System.out.println("退出成功");
break;
default:
System.out.println("输入错误");
}
}
}
3、Guessing猜数字之while版。完整代码：
package day04;
import java.util.Random;
import java.util.Scanner;
/** 猜数字小游戏 */
public class Guessing {
public static void main(String[] args) {
/*
int num = (int)(Math.random()*1000+1); //1到1000
Math.random()--------------0.0到0.9999999999999999...
*1000----------------------0.0到999.99999999999999...
+1-------------------------1.0到1000.9999999999999...
(int)----------------------1到1000
*/
Scanner scanner = new Scanner(System.in);
// int num = 250;//定死的数
int num = (int)(Math.random()*1000+1);//1~1000的随机数
System.out.println(num);//作弊 直接将生成的随机数显示在控制台
System.out.println("猜吧");
int guess = scanner.nextInt();
while(guess!=num){
if(guess>num){
System.out.println("猜大了！继续猜");
}else{
System.out.println("猜小了！继续猜");
}
guess = scanner.nextInt();
}
System.out.println("猜对了");
}
}
4、Guessing猜数字之do…while版。。完整代码:
package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num = (int)(Math.random()*1000+1); //1到1000之内
System.out.println(num); //作弊
//假设num=250
//300(大),200(小),250(对)
int guess;
do{
System.out.println("猜吧!");
guess = scan.nextInt(); //1+3
if(guess>num){
System.out.println("太大了");
}else if(guess<num){
System.out.println("太小了");
}else{
System.out.println("恭喜你猜对了");
}
}while(guess!=num); //2
}
}
语言基础第五天：
回顾：
-
Scanner接收用户的数据：共3步
-
分支结构：
-
if…else if结构：多条路
-
switch…case结构：多条路
优点：效率高、结构清晰
缺点：只能对整数判断相等
break：跳出switch
-
-
循环：反复多次执行一段相同或相似的代码
-
循环三要素：
-
循环变量的初始化
-
循环的条件(以循环变量为基础)
-
循环变量的改变(向着循环的结束变)
循环变量：在整个循环过程中所反复改变的那个数
-
-
循环结构：
-
while结构：先判断后执行，有可能一次都不执行
-
do…while结构：先执行后判断，至少执行一次
要素1与要素3相同时，首选do…while
-
笔记：
-
循环结构：
-
for结构：应用率高、与次数相关的循环
-
语法：
// 1 2 3
for(要素1;要素2;要素3){
语句块/循环体----------------反复执行的代码 4
}
-
执行过程：
1243243243243243243…2
-
代码演示：
//for循环中的循环变量i，作用域仅在当前for中 for(int i=1;i<=9;i++){ System.out.println(i+"*9="+i*9); } for(int i=1;i<=9;i+=2){ System.out.println(i+"*9="+i*9); } for(int i=9;i>=1;i--){ System.out.println(i+"*9="+i*9); } for(int times=0;times<5;times++){ System.out.println("行动是成功的阶梯"); } System.out.println("继续执行..."); /* 执行过程: times=0 true 输出 times=1 true 输出 times=2 true 输出 times=3 true 输出 times=4 true 输出 times=5 false for循环结束 输出继续执行... */ //for的特殊格式:----------了解 int i=1; for(;i<=9;i++){ //可以把上边那句省略，此行变为： for(int i=1;i<=9;i++) System.out.println(i+"*9="+i*9); } for(int i=1;i<=9;){ System.out.println(i+"*9="+i*9); i++; } for(;;){ //没有条件的循环就是一个死循环 System.out.println("我要学习..."); } for(int i=1,j=5;i<=5;i+=2,j-=2){ } /* i=1,j=5 true i=3,j=3 true i=5,j=1 true i=7,j=-1 false */
-
-
-
三种循环结构的选择规则：
- 先看循环是否与次数相关：
- 若相关----------------------------直接上for
- 若无关，再看要素1与要素3是否相同：
- 若相同------------------------直接上do…while
- 若不同------------------------直接上while
- 先看循环是否与次数相关：
-
break：跳出循环
for(int i=1;i<=9;i++){ if(i==4){ //在某种特定条件下，提前结束循环 break; } System.out.println(i+"*9="+i*9); } /* i=1 true 1*9=9 i=2 true 2*9=18 i=3 true 3*9=27 i=4 true */continue：跳过循环体中剩余语句而进入下一次循环
//输出9的乘法表，只要不能被3整除的 for(int i=1;i<=9;i++){ if(i%3!=0){ System.out.println(i+"*9="+i*9); } } //输出9的乘法表，跳过能被3整除的 for(int i=1;i<=9;i++){ if(i%3==0){ continue; //跳过循环体中剩余语句而进入下一次循环 } System.out.println(i+"*9="+i*9); } /* i=1 1*9=9 i=2 2*9=18 i=3 i=4 4*9=36 i=5 5*9=45 i=6 i=7 7*9=63 i=8 8*9=72 i=9 i=10 */ -
随机加法运算器案例：
package day05; import java.util.Scanner; //随机加法运算器 public class Addition { public static void main(String[] args) { Scanner scan = new Scanner(System.in); int score = 0; //总分 for(int i=1;i<=10;i++) { //10次 int a = (int)(Math.random()*100); //加数a，0到99之间 int b = (int)(Math.random()*100); //加数b int result = a+b; //存正确答案 System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题 System.out.println("算吧!----输入-1可提前结束"); int answer = scan.nextInt(); //2)答题 if(answer==-1){ //3)判题 break; } if(answer==result){ System.out.println("答对了"); score += 10; //答对1题，加10分 }else{ System.out.println("答错了"); } } System.out.println("总分为:"+score); } } -
嵌套循环：
- 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
- 执行过程：外层循环走一次，内层循环走所有次
- 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题
- break只能跳出当前一层循环
for(int num=1;num<=9;num++){ //控制行 for(int i=1;i<=num;i++){ //控制列 System.out.print(i+"*"+num+"="+i*num+"t"); } System.out.println(); //换行 } /* 执行过程: num=3 i=1 1*3=3 i=2 2*3=6 i=3 3*3=9 i=4 false 换行 num=2 i=1 1*2=2 i=2 2*2=4 i=3 false 换行 num=1 i=1 1*1=1 i=2 false 换行 */ -
数组：
-
是一种数据类型(引用类型)
-
相同数据类型元素的集合
-
定义：
//声明int型数组arr，包含10个元素，每个元素都是int型，默认值为0 int[] arr = new int[10]; -
初始化：给数组中的元素做初始化
int[] arr = new int[3]; //0,0,0 int[] arr = {1,4,7}; //1,4,7 int[] arr = new int[]{1,4,7}; //1,4,7 int[] arr; //arr = {1,4,7}; //编译错误 int[] arr2; arr2 = new int[]{1,4,7}; //正确 -
访问：访问的是数组中的元素
-
通过(数组名.length)可以获取数组的长度(元素的个数)
int[] arr = new int[3]; System.out.println(arr.length); //3 -
通过下标/索引来访问数组中的元素
下标从0开始，最大到(数组的长度-1)
int[] arr = new int[3]; arr[0] = 100; //给第1个元素赋值为100 arr[1] = 200; //给第2个元素赋值为200 arr[2] = 300; //给第3个元素赋值为300 System.out.println(arr[arr.length-1]); //输出最后一个元素的值
-
-
遍历/迭代：从头到尾挨个走一遍
int[] arr = new int[10]; for(int i=0;i<arr.length;i++){ //遍历arr数组 //arr[i]代表arr中的每一个元素 //给每个元素赋值为0到99之间的随机数 arr[i] = (int)(Math.random()*100); System.out.println(arr[i]); //输出每个元素的值 }
-
精华笔记：
-
循环结构：
- for结构：应用率高、与次数相关的循环
-
三种循环结构的选择规则：
- 先看循环是否与次数相关：
- 若相关----------------------------直接上for
- 若无关，再看要素1与要素3是否相同：
- 若相同------------------------直接上do…while
- 若不同------------------------直接上while
- 先看循环是否与次数相关：
-
break：跳出循环
continue：跳过循环体中剩余语句而进入下一次循环
-
嵌套循环：
- 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
- 执行过程：外层循环走一次，内层循环走所有次
- 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题
- break只能跳出当前一层循环
-
数组：
-
是一种数据类型(引用类型)
-
相同数据类型元素的集合
-
定义：
-
初始化：给数组中的元素做初始化
-
访问：访问的是数组中的元素
-
通过(数组名.length)可以获取数组的长度(元素的个数)
-
通过下标/索引来访问数组中的元素
下标从0开始，最大到(数组的长度-1)
-
-
遍历/迭代：从头到尾挨个走一遍
-
补充：
- 变量的同名问题：
- 作用域重叠时，变量不能同名的
- t：水平制表位，固定占8位
- ArrayIndexOutOfBoundsException数组下标越界异常
- 数组下标范围为0到(数组长度-1)，超出范围则发生如上的异常
语言基础第五天作业：
1、Addition随机加法运算器
2、MultiTable九九乘法表
3、数组小代码：声明、初始化、访问、遍历
1、Addition随机加法运算器。完整代码：
package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int score = 0; //得分
for(int i=1;i<=10;i++){ //10次 (1)25+36=?
int a = (int)(Math.random()*100); //加数a(0到99的随机数)
int b = (int)(Math.random()*100); //加数b(0到99的随机数)
int result = a+b; //存正确答案
System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
System.out.println("算吧!");
int answer = scan.nextInt(); //2)答题
if(answer==-1){ //3)判题
break;
}
if(answer==result){
System.out.println("答对了");
score+=10; //答对1题加10分
}else{
System.out.println("答错了");
}
}
System.out.println("总分为:"+score);
}
}
2、MultiType九九乘法表。完整代码：
package day05;
//九九乘法表
public class MultiTable {
public static void main(String[] args) {
for(int num=1;num<=9;num++){ //控制行
for(int i=1;i<=num;i++){ //控制列
System.out.print(i+"*"+num+"="+i*num+"t");
}
System.out.println(); //换行
}
/*
int num = 9;//----1/2/3/4/5/6/7/8/9
for (int i=1;i<=num;i++) {
System.out.print(i+"*"+num+"="+i*num+"t");
}
执行过程：
num=1: 1*1=1
num=2: 1*2=2 2*2=4
num=3: 1*3=3 2*3=6 3*3=9
num=4: 1*4=4 2*4=8 3*4=12 4*4=16
num=5: 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
.
.
.
num=9: 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
*/
}
}
3、数组小代码练习：声明、初始化、访问、遍历。 完整代码：
package day05;
//数组的演示
public class ArrayDemo {
public static void main(String[] args) {
/*
//1)数组的定义:
//声明整型数组arr，包含10个元素，每个元素都是int型，默认值为0
int[] arr = new int[10];
//2)数组的初始化:--初始化的是数组中的数据
int[] arr1 = new int[3]; //0,0,0
int[] arr2 = {2,5,8}; //2,5,8
int[] arr3 = new int[]{2,5,8}; //2,5,8
int[] arr4;
//arr4 = {2,5,8}; //编译错误，此方式只能声明同时初始化
arr4 = new int[]{2,5,8}; //正确
*/
/*
//3)数组的访问:--访问的是数组中的数据
int[] arr = new int[3];
System.out.println(arr.length); //3，输出arr的长度
arr[0] = 100; //给arr中第1个元素赋值为100
arr[1] = 200; //给arr中第2个元素赋值为200
arr[2] = 300; //给arr中第3个元素赋值为300
//arr[3] = 400; //运行时发生ArrayIndexOutOfBoundsException数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素的值
*/
//4)数组的遍历:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99的随机数
System.out.println(arr[i]); //输出每个元素的值
}
}
}
***常见面试题：
面试题1、2、3：
//面试题1：
System.out.println("is"+20+3);//is 203 从左往右碰到字符串参与 后面都为字符模式
System.out.println(20+3+" is");//23 is 从左往右先算加法23
System.out.println("is "+(20+3));//is 23 从左往右，但是先算括号里边的
//面试题2：
int result = 0;
int i = 2;
switch(i){
case 1:
result = result+i;
case 2:
result = result+i*2;
case 3:
result = result+i*3;
}
System.out.println(result);//10
//面试题3：
①do...while先执行再判断
int a=0,b=0;
do{
--b; //b-1=0-1=-1
a--; //a-1=0-1=-1
}while(a>0);
System.out.println(b);//-1
②先判断再执行...
int a=0,b=0;
while(a>0){
--b;
a--;
}
System.out.println(b);
面试题3:
int a=0,b=0;
do{
a--; //a-1=0-1=-1
--b; //b-1=0-1=-1
}while(a>0);
System.out.println(a);//-1 a--;表达式： a先输出(输出本身的值0)，再自减1(0-1等于-1)，最后输出为-1
System.out.println(b);//-1 --b;表达式： b先自减1(本身为0,0-1等于-1)，再输出为-1
最后
以上就是天真鞋子为你收集整理的语言基础第三四五天：运算符和分支结构(if/if...else) | 扫描仪sc、分支(if.else/swith.case)、循环(while/do.while)、循环结构、嵌套循环、数组语言基础第三天：语言基础第四天：语言基础第五天：的全部内容，希望文章能够帮你解决语言基础第三四五天：运算符和分支结构(if/if...else) | 扫描仪sc、分支(if.else/swith.case)、循环(while/do.while)、循环结构、嵌套循环、数组语言基础第三天：语言基础第四天：语言基础第五天：所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复