定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词） 特点：关键字中所字母都为小写 具体关键字：
现Java版本尚未使用，但以后版本可能会作为关键字使用。 具体哪些保留字：goto 、const 注意：自己命名标识符时要避免使用这些保留字
定义：凡是自己可以起名字的地方都叫标识符。
涉及到的结构：包名、类名、接口名、变量名、方法名、常量名
规则：
规范：
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写： XxxYyyZzz(小驼峰式)
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写： xxxYyyZzz(大驼峰式)
常量名：所有字母都大写。多单词时每个单词用下划线连接： XXX_YYY_ZZZ
注意点： 在起名字时，为了提高阅读性，要尽量意义，“见名知意”。
按数据类型分类
按声明位置分类
变量必须先声明，后使用
变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了
同一个作用域内，不可以声明两个同名的变量
package com.atguigu.java;
public class VariableTest1 {
public static void main(String[] args) {
//1.整型 byte(单字节) short(双字节) int(四字节) long(八字节)
//byte 范围 -128 ---- 127
byte b1 = 12;
byte b2 = -128;
//b2 = 128; 编译错误
System.out.println(b1);
System.out.println(b2);
//声明long型变量必须以"l"或"L"结尾
//通常定义整型变量时 使用int即可
short s1 = 128;
int i1 = 1234;
long l1 = 1234656l;
System.out.println(l1);
//2.浮点型 float(四字节) double(八字节)
//浮点型：表示带有小数点的数值
//float表示数值的范围要比long的范围还大
double d1 = 123.3;
System.out.println(d1);
//定义float类型时 变量必须以"f"或"F"结尾
float f1 = 123.2f;
System.out.println(f1);
//通常，定义浮点型变量时 优先使用double
//3.字符型 (双字节)
//定义char型变量时 通常使用一对‘‘,内部只能写一个字符
char c1 = ‘a‘;
//c1 = ‘ab‘; 编译不通过
System.out.println(c1);
//表示方式 1.声明一个字符 2.转义字符 3.直接使用Unicode来表示字符型常量
char c5 = ‘\n‘;
c5 = ‘\t‘;
System.out.print("hello" + c5);
System.out.println("World");
//4.布尔型 boolean
//只能取两个值之一：ture or false
//常常在条件判断,循环结构中使用
boolean bb1 = true;
System.out.println(bb1);
boolean isMarried = true;
if(isMarried) {
System.out.println("不能参加单身party");
}else {
System.out.println("多找找对象！");
}
}
}
/*
//结果
12
-128
1234656
123.3
123.2
a
hello World
true
不能参加单身party
*/
强制类型转换：自动类型提升的逆运算
? 需要使用强转符 ??)
? 注意点:强制类型转换,可能导致精度损失
? 说明：此时的容量大小指的是,表示数的范围和大小 例 容量(float) > 容量(long)
String类型变量的使用
1.String属于引用数据类型,意为字符串
2.声明String类型变量时,使用一对""
3.String可以和8种基本数据类型变量做运算,且只能是连接"+"运算
4.运算结果仍然是String类型
package com.atguigu.java;
public class StringTest1 {
public static void main(String[] args) {
String s1 = "Hello world";
System.out.println(s1);
String s2 = "a";
String s3 = "";
int number = 1001;
String numberStr = "学号：";
String info = numberStr + number;
System.out.println(info);
boolean b1 = true;
String info1 = info + b1;
System.out.println(info1);
}
}
/*
//结果
Hello world
学号：1001
学号：1001true
*/
package com.atguigu.java;
//关于String类型 的练习题
public class StringExer1 {
public static void main(String[] args) {
//练习1
char c = ‘a‘;//97
int num = 10;
String str = "hello";
System.out.println(c + num + str);//107hello
System.out.println(c + str + num);//ahello10
System.out.println(c + (num + str));//a10hello
System.out.println((c + num) + str);//107hello
System.out.println(str + num + c);//hello10a
//练习2
//控制台输出这种格式 ： * *
System.out.println("* *");
System.out.println(‘*‘ + ‘\t‘ + ‘*‘);
System.out.println(‘*‘ + "\t" + ‘*‘);
System.out.println(‘*‘ + ‘\t‘ + "*");
System.out.println(‘*‘ + (‘\t‘ + "*"));
//注：+ 两端都不是String类型,为加法运算
// + 两端若存在一着者 为String类型 ,为拼接运算
// char与char 类型的加法运算 结果为 int型(自动类型提升)
}
}
/*
//结果
107hello
ahello10
a10hello
107hello
hello10a
* *
93
* *
51*
* *
*/
package com.atguigu.java;
public class StringExer2 {
public static void main(String[] args) {
String str1 = 4; //判断对错：no 字符串必须用双引号标识
String str2 = 3.5f + “”; //判断str2对错：yes "3.5"
System.out.println(str2); //输出：”3.5”
System.out .println(3+4+“Hello!”); //输出：7Hello!
System.out.println(“Hello!”+3+4); //输出：Hello!34
System.out.println(‘a’+1+“Hello!”); //输出：98Hello!
System.out.println(“Hello”+‘a’+1); //输出：Helloa1
}
}
二进制------>十进制
十进制------>二进制
二进制------>八进制
二进制------>十六进制
十六进制、八进制------>二进制
package com.atguigu.java;
public class AriTest1 {
public static void main(String[] args) {
// 除号:/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2 ;//int运算结果为int 2
System.out.println(result1);
double result2 = (double)num1 / num2;//double与 int 运算结果为double 2.4
System.out.println(result2);
// %:取余运算
//结果的符号与被模数的符号相同
//开发中，经常使用%来判断能否被除尽
System.out.println("12 % 5 = "+ (12%5));
System.out.println("-12 % 5 = "+ (-12%5));
System.out.println("12 % -5 = "+ (12%-5));
System.out.println("-12 % -5 = "+ (-12%-5));
//运算顺序从右往左
//++(前): b = ++a; 先自增一,后运算
//(后)++: b = a++; 先运算,后自增一
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = "+ b2);
//注意点:
short s1 = 10;
//s1 = s1 + 1;//编译错误
//s1 = (short)(s1+1);//编译正确
s1++;//自增一 不会改变本身变量的数据类型
System.out.println(s1);
}
}
/*
//结果
2
2.4
12 % 5 = 2
-12 % 5 = -2
12 % -5 = 2
-12 % -5 = -2
a1 = 11,b1 = 11
a2 = 11,b2 = 10
11
*/
运算符之二:赋值运算符
= += -= *= /= %=
package com.atguigu.java;
public class SetVauleTest1 {
public static void main(String[] args) {
//连续赋值
int i1,j1;
i1 = j1 = 10;
int i2 = 10,j2 = 10;
//扩展运算符
int num1 = 10;
num1 += 2;//num1 = num1 + 2;
System.out.println(num1);//12
short s1 = 12;
s1 += 2;//不会改变变量本身的数据类型
System.out.println(s1);//14
//开发中 如果希望变量实现自增2的操作 int num = 10;
//一:num = num + 2;
//二:num += 2;推荐
//开发中 如果希望变量实现自增1的操作 int num = 10;
//一:num = num + 2;
//二:num += 2;推荐中
//三:num++;
}
}
package com.atguigu.java;
public class CompareTest {
public static void main(String[] args) {
int i = 10,j = 20;
System.out.println(i == j);//false
System.out.println(i = j);// 20
boolean b1 = true;
boolean b2 = false;
System.out.println(b1 == b2);//true
System.out.println(b1 = b2);//false
}
}
package com.atguigu.java;
public class LogicTest {
public static void main(String[] args) {
//区分 & 与 &&
//相同点1： &与 && 运算结果相同
//相同点2：当符号左边是true时,二者都会执行符号右边的操作
//不同点：当符号左边是false时,&会继续执行符号右边的操作,&&不在执行符号右边的操作
// 开发中推荐使用 && ||
boolean b1 = false;
int num1 = 10;
if(b1 & (num1++ >0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}//我现在在南京
System.out.println("num1 = " + num1);//num1 = 11
boolean b2 = false;
int num2 = 10;
if(b2 && (num2++ >0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}//我现在在南京
System.out.println("num2 = " + num2);//num2 = 10
//区分 | 与 ||
//相同点1： | 与 || 运算结果相同
//相同点2：当符号左边是false时,二者都会执行符号右边的操作
//不同点：当符号左边是true时,|会继续执行符号右边的操作,||不在执行符号右边的操作
boolean b3 = true;
int num3 = 10;
if(b3 | (num3++ >0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}//我现在在北京
System.out.println("num3 = " + num3);//num3 = 11
boolean b4 = true;
int num4 = 10;
if(b4 || (num4++ >0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}//我现在在北京
System.out.println("num4 = " + num4);//num4 = 10
}
}
package com.atguigu.java;
public class LogicExer1 {
public static void main(String[] args) {
int x = 1;
int y=1;
if(x++==2 & ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);//x=2 y=2
//解析 1.x++==2 先运算 (x=1) ==2 false 后自增 x = 2
//2. &运算 前者为false 需要继续看后者
//3.++y==2 先 自增 y = 2 后运算(y=2)==2 true
//4.条件为false 不执行if语句 所以 x=2 y=2
int x = 1,y = 1;
if(x++==2 && ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);//x=2 y=1
//解析1.x++==2 先运算 (x=1) ==2 false 后自增 x = 2
//2. &&运算 前者为false 不需要看后者 此时y=1
//3.条件为false 不执行if语句 所以 x=2 y=1
int x = 1,y = 1;
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);//x=7,y=2
//解析:1.x++==1 先运算(x=1)==1 true 后自增 x=2
//2.|运算 前者为true 还需要执行后者
//3.++y==1 先自增 y=2 在运算(y=2)==1 false
//4.条件为true 执行if语句 所以 x=7,y=2
int x = 1,y = 1;
if(x++==1 || ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);//x=7,y=1
解析:1.x++==1 先运算(x=1)==1 true 后自增 x=2
//2.||运算 前者为true 不需要执行后者 此时y=1
//3.条件为true 执行if语句 所以 x=7,y=1
}
}
package com.atguigu.java;
public class LogicExer2 {
public static void main(String[] args) {
boolean x =true;
boolean y =false;
short z=42;
if((z++==42)&&(y=true)) z++;
if((x = false) || (++z==45)) z++;
System. out.println("z="+z);//z=46
//解析
//1. 赋值 x,y,z
//2 if((z++==42)&&(y=true)) z++;
//2.1 (z++==42) 先运算 (z=42)==42 true 后自增 z = 43
//2.2 &&运算 前者为 true 还需要执行后者
//2.3 (y=true) 将true赋值给y 并判断y是否等于true 结果为true
//2.4条件整体为true 执行 z++; 结果为z = 44
//3 f((x = false) || (++z==45)) z++;
//3.1 (x = false) 结果为false
//3.2 ||运算 前者为false 还需要执行后者
//3.3 (++z==45) 先自增z=45 后运算(z=45)==45 结果为true
//3.4 条件整体为true 执行 z++; 结果为z = 46
//4 输出结果 z=46
}
}
面试题：最高效方式的计算2 * 8 ？ 2 << 3 或 8 << 1
class BitTest {
public static void main(String[] args) {
int i = 21;
i = -21;
System.out.println("i << 2 :" + (i << 2));
System.out.println("i << 3 :" + (i << 3));
System.out.println("i << 27 :" + (i << 27));
int m = 12;
int n = 5;
System.out.println("m & n :" + (m & n));
System.out.println("m | n :" + (m | n));
System.out.println("m ^ n :" + (m ^ n));
//练习：交换两个变量的值
int num1 = 10;
int num2 = 20;
System.out.println("num1 = " + num1 + ",num2 = " + num2);
//方式一：定义临时变量的方式
//推荐的方式
int temp = num1;
num1 = num2;
num2 = temp;
//方式二：好处：不用定义临时变量
//弊端：① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
//num1 = num1 + num2;
//num2 = num1 - num2;
//num1 = num1 - num2;
//方式三：使用位运算符
//有局限性：只能适用于数值类型
//num1 = num1 ^ num2;
//num2 = num1 ^ num2;
//num1 = num1 ^ num2;
System.out.println("num1 = " + num1 + ",num2 = " + num2);
}
}
运算符之六：三元运算符
1.结构 : (条件表达式)?表达式1:表达式2
2.说明
2.1 条件表达式的结果为boolean类型
2.2 根据条件表达式真或假,决定执行表达式1,还是表达式2
如果表达式为true,则执行表达式1
如果表达式为false,则执行表达式2
2.3.表达式1 和 表达式2 要求是一致的
2.4.三元运算符是可以相互嵌套的
3.凡是可以使用三元运算符的地方,都可以改写为if-else.反之,不成立
4.如果程序即可以使用三元运算符,又可以使用if-else结构.那么优先使用三元运算符。原件：简单 高效
if(条件表达式){
表达式1
}else{
表达式2
}
package com.atguigu.java;
public class SanYuanTest {
public static void main(String[] args) {
//获取两个整数中较大值
int m = 25,n = 12;
int max = (m > n)? m:n;
System.out.println(max);//25
String maxStr = (m > n)?"m大":((m == n)?"m等于n":"m小");
System.out.println(maxStr);// m大
//获取三个数的最大值
int n1 = 12,n2 = 30,n3 = -43;
int max1 = (n1 > n2)?n1:n2;
int max2 = (max1 > n3)?max1:n3;
System.out.println(max2);//30
//不建议这样写
int max3 = (n1 > n2)?((n1 > n3)?n1:n3):((n2>n3)?n2:n3);
System.out.println(max3);//30
}
}
顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转。
选择结构
根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句。
循环结构
根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。
分支结构中的if-else结构
存在三种结构
第一种
if(条件表达式){
执行表达式
}
第二种：二选一
if(条件表达式){
执行表达式1
}
else{
执行表达式2
}
第三种：多选一
if(条件表达式1){
执行表达式1
}
else if(条件表达式2){
执行表达式2
}else if(条件表达式3){
执行表达式3
}
...
else{
执行表达式n
}
package com.atguigu.java;
public class IFTest {
public static void main(String[] args) {
//举例1
int heartBeats = 79;
if(heartBeats < 60 || heartBeats > 100) {
System.out.println("需要做进一步检查");
}
System.out.println("检查结束");
//举例2
int age = 23;
if(age < 18) {
System.out.println("多看看动画片");
}else {
System.out.println("多工作");
}
}
}
如何从键盘获取不同属性的变量：需要使用Scanner类
具体实现步骤：
1.导包 import java.util.Scanner;
2.Scannner的实例化
3.调用Scanner类的相关方法(next()/nextXXX()),来获取指定类型的变量
注意：
需要根据相应的方法,来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时,
可能会导致异常，使得程序终止。
package com.atguigu.java;
/*
如何从键盘获取不同属性的变量：需要使用Scanner类
具体实现步骤：
1.导包 import java.util.Scanner;
2.Scannner的实例化
3.调用Scanner类的相关方法(next()/nextXXX()),来获取指定类型的变量
注意：
需要根据相应的方法,来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时,、
可能会导致异常，使得程序终止。
*/
import java.util.Scanner;
public class ScannerTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入你的姓名");
String name = scan.next();//scan实例获取字符型变量
System.out.println(name);
System.out.println("请输入你的芳龄");
int age = scan.nextInt();//scan实例获取整型变量
System.out.println(age);
System.out.println("请输入你的体重");
double weight = scan.nextDouble();//scan实例获取浮点型变量
System.out.println(weight);
System.out.println("你是否相中我了呢？(true/false)");
boolean result = scan.nextBoolean();//scan实例获取布尔型变量
System.out.println(result);
//对于char型的获取,Scanner没有提供相关的方法,只能获取字符串
System.out.println("请输入你的性别:(男/女)");
String gender = scan.next();
char genderChar = gender.charAt(0);
System.out.println(genderChar);//获取索引位置为0位置上的字符
}
}
/*
//结果
请输入你的芳龄
20
20
请输入你的体重
80
80.0
你是否相中我了呢？(true/false)
false
false
请输入你的性别:(男/女)
男
男
*/
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断
package com.atguigu.java;
import java.util.Scanner;//导包
public class IfExer1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//实例化
System.out.println("请输入岳小鹏的成绩(0-100)");
int score = scan.nextInt();//调用
if(score == 100) {
System.out.println("奖励一辆BMW");
}else if(score > 80 && score <= 99) {
System.out.println("奖励一台iphone xs max");
}else if(score >= 60 && score <= 80) {
System.out.println("奖励一个 iPad");
}else {
System.out.println("什么奖励也没有");
}
}
}
/*
//结果
请输入岳小鹏的成绩(0-100)
79
奖励一个 iPad
*/
说明:
1.else结构是可选的。
2.针对于条件表达式
如果多个条件表达式之间是"互斥"关系,那个判断和执行语句声明在上面还是下面,无所谓
如果多个条件表达式之间有交集关系,需要根据实际情况,考虑清楚应该将那个结构声明在上面
如果多个条件表达式之间有包含关系,通常需要将范围小的声明在范围大的上面
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。
先比较num1 和 num2,得到num1 和 num2的大小关系,再把num3 插入到他们之间
说明：
1.if-else结构是可以嵌套的
2.如果if-else结构中的执行语句只有一行时,可以省略大括号,不建议采用
package com.atguigu.java;
import java.util.Scanner;//导包
public class IfExer2 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个整数");
int num1 = scan.nextInt();
System.out.println("请输入第二个整数");
int num2 = scan.nextInt();
System.out.println("请输入第三个整数");
int num3 = scan.nextInt();
if(num1 >= num2) {
if(num3 >= num1) {
System.out.println(num2 + "," + num1 + "," + num3);
}else if (num3 >= num2) {
System.out.println(num2 + "," + num3 + "," + num1);
}else {
System.out.println(num3 + "," + num2 + "," + num1);
}
}else {
if(num3 >= num2) {
System.out.println(num1 + "," + num2 + "," + num3);
}else if (num3 >= num1) {
System.out.println(num1 + "," + num3 + "," + num2);
}else{
System.out.println(num3 + "," + num1 + "," + num2);
}
}
}
}
/*
//结果
请输入第一个整数
30
请输入第二个整数
-50
请输入第三个整数
98
-50,30,98
*/
我家的狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前两年每
一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗
相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。
编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人
类的年龄。如果用户输入负数，请显示一个提示信息。
package com.atguigu.java;
import java.util.Scanner;//导包
public class IfExer3 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//实例化
System.out.println("请输入狗的年龄");
int dogAge = scan.nextInt();//调用
double dogtopersonAge;
if(dogAge <= 0) {
System.out.println("输入不合法");
}else {
if(dogAge <= 2) {
dogtopersonAge = dogAge*10.5;
}else{
dogtopersonAge = 2*10.5 + (dogAge-2)*4;
}
System.out.println("相当于人的年龄：" + dogtopersonAge);
}
}
}
/*
//结果
请输入狗的年龄
5
相当于人的年龄：33.0
*/
package com.atguigu.java;
/*
随机数的产生：10-99
*/
public class IfExer4 {
public static void main(String[] args) {
double value1 = Math.random()*100;// [0.0 1.0)-->[0.0 100.0)
double value2 = (int)(Math.random()*90 + 10);// 10-99
System.out.println(value2);
// 公式 [a,b] : (int)(Math.random()*(b-a+1) + a)
}
}
大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出
一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”
package com.atguigu.java;
import java.util.Scanner;//导包
public class IfExer5 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//实例化
System.out.println("请输入你的身高(cm):");
int height = scan.nextInt();//
System.out.println("请输入你的财富(千万):");
double wealth = scan.nextDouble();
System.out.println("请输入你是否帅(true/false):");
boolean isHandsome = scan.nextBoolean();
if(height >= 180 && wealth >= 1 && isHandsome) {
System.out.println("我一定要嫁给他!!!");
}else if(height >= 180 || wealth >= 1 || isHandsome) {
System.out.println("嫁吧，比上不足，比下有余。");
}else {
System.out.println("不嫁！");
}
}
}
/*
//结果
请输入你的身高(cm):
172
请输入你的财富(千万):
0.3
请输入你是否帅(true/false):
true
嫁吧，比上不足，比下有余。
*/
分支结构之二：switch-case
1.格式
switch(表达式){
case 常量1:
执行语句1;
//break;
case 常量2:
执行语句2;
//break;
...
default:
执行语句n;
//break;
}
说明：
1.根据switch表达式中的值,依次匹配各个case中的常量,一旦匹配成功,则进入相应case中的语句去执行
当调用完执行语句以后,则仍然继续向下执行其他case结构中的执行语句,直到遇到break或switch-case结构结束
2.break关键字,可以使用在switch-case结构中,表示一旦执行到此关键字,就跳出switch-case结构
3.switch结构中的表达式,只能是如下的6种数据类型：
byte,short,char,int,枚举类型,String类型
4.case之后声明常量,不能声明范围
5.break关键字是可选的
6.default 相当于if-else结构中的else
default结构是可选的
package com.atguigu.java;
public class SwitchCaseTest {
public static void main(String[] args) {
int number = 2;
switch(number) {
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("other");
}
}
}
package com.atguigu.java;
/*
对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
*/
import java.util.Scanner;//导包
public class SwitchCaseExer1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入学生的成绩(0-100):");
int score = scan.nextInt();
switch(score/60) {
case 0:
System.out.println("不合格");
break;
case 1:
System.out.println("合格");
break;
default:
System.out.println("输入有误");
}
}
}
/*
//结果
请输入学生的成绩(0-100):
80
合格
*/
根据用于指定月份，打印该月份所属的季节。
3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季
package com.atguigu.java;
import java.util.Scanner;//导包
public class SwitchCaseExer2 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//实例化
System.out.println("请输入月份(1-12)：");
int month = scan.nextInt();//调用
switch(month) {
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
default:
System.out.println("输入有误");
}
}
}
/*
//结果
请输入月份(1-12)：
10
秋季
*/
编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序
输出输入的日期为2019年的第几天。
算法分析：
利用 switch-case中break结构是可选的,并且在无break结构中,程序会从某个case接口进入,然后执行后续所有的case
举例 ：计算5月20 需要1-4月的天数 + 20
计算 7月18 需要 1-6月的天数 + 18
....
可以看出来 1.2.3月需要执行的频率比较高 所以往下边放
package com.atguigu.java;
import java.util.Scanner;//导包
public class SwitchCaseExer3 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//实例化
System.out.println("请输入2019年的月份(1-12):");
int month = scan.nextInt();//调用
System.out.println("请输入2019年的天数(1-31):");
int days = scan.nextInt();//调用
//定义变量来保存总天数
int sumDays = 0;
switch(month) {
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
sumDays += 28;
case 2:
sumDays += 31;
case 1:
sumDays += days;
}
System.out.println("2019年的" + month + "月" + days + "日" + "2019年的第"+ sumDays+"天");
}
}
/*
//结果
请输入2019年的月份(1-12):
4
请输入2019年的天数(1-31):
3
2019年的4月3日2019年的第93天
*/
package com.atguigu.java;
/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
*/
import java.util.Scanner;
public class SwitchCaseExer4 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//实例化
System.out.println("请输入年份:");
int year = scan.nextInt();//调用
System.out.println("请输入月份(1-12):");
int month = scan.nextInt();//调用
System.out.println("请输入天数(1-31):");
int days = scan.nextInt();//调用
//定义变量来保存总天数
int sumDays = 0;
switch(month) {
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
if((year % 4 == 0 && year % 100 != 0)|| year % 400 == 0) {
sumDays += 29;
}else {
sumDays += 28;
}
case 2:
sumDays += 31;
case 1:
sumDays += days;
}
System.out.println(year + "年的" + month + "月" + days + "日是" + year + "年的第"+ sumDays+"天");
}
}
/*
//结果
请输入年份:
2018
请输入月份(1-12):
3
请输入天数(1-31):
20
2018年的3月20日是2018年的第79天
*/
编写程序：从键盘上读入一个学生成绩，存放在变量score中，根据score的
值输出其对应的成绩等级：
score>=90 等级: A
70<=score<90 等级: B
60<=score<70 等级: C
score<60 等级: D
package com.atguigu.java;
import java.util.Scanner;//导包
public class SwitchCaseExer5 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//实例化
System.out.println("请输入你的成绩(0-100):");//不能超过100 或者 小于0 没有进行异常数据检测
int score = scan.nextInt();//调包
switch(score/10) {
case 10:
case 9:
System.out.println("等级: A");
break;
case 8:
case 7:
System.out.println("等级: B");
break;
case 6:
System.out.println("等级: C");
break;
default:
System.out.println("等级: D");
}
}
}
/*
//结果
请输入你的成绩(0-100):
99
等级: A
*/
for循环结构的使用
一 循环结构的4个要素
1初始化条件
2循环条件 ---Boolean类型
3循环体
4迭代条件
二 for循环结构
for(1初始化条件;2循环条件;4迭代条件){
3循环体
}
执行过程：1-->2-->3-->4-->2--->4--->2.....-->2
package com.atguigu.java;
public class ForTest1 {
public static void main(String[] args) {
for(int i = 1;i <= 5;i++) {
System.out.println("Hello World!");
// i:在for循环内有效,出了for循环就失效了
}
//练习 熟悉循环结构的执行过程
int num = 1;
for(System.out.print(‘a‘);num <= 3;System.out.print(‘c‘),num++) {
System.out.print(‘b‘);
}
// a --> b -->c -->b--->c--->b----c
//遍历100以内的偶数,并输出所有偶数的和
int sum = 0;
for(int j = 1;j <= 100;j++) {
if(j % 2 == 0) {
sum += j;
System.out.println(j);
}
System.out.println(sum);
}
}
}
编写程序从1循环到150，并在每行打印一个值，
另外在每个3的倍数行上打印出“foo”,
在每个5的倍数行上打印“biz”,
在每个7的倍数行上打印输出“baz”
package com.atguigu.java;
public class ForExer1 {
public static void main(String[] args) {
String printValue;
for(int i = 1;i <= 150;i++) {
printValue = "";
printValue += i;
if(i % 3 == 0) {
printValue += " foo";
}
if(i % 5 == 0) {
printValue += " biz";
}
if(i % 7 == 0) {
printValue += " baz";
}
System.out.println(printValue);
}
}
}
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用
package com.atguigu.java;
import java.util.Scanner;//导包
public class ForExer2 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//实例化
System.out.println("请输入第一个正整数:");
int m = scan.nextInt();//调用
System.out.println("请输入第二个正整数:");
int n = scan.nextInt();//调用
//获得两个数中的较小值
int min = (m > n)?n:m;
for (int i = min;i >= 1;i--) {
if(m % i == 0 && n % i == 0) {
System.out.println("最大公约数是"+ i);
break;//一旦在循环中执行到break,就跳出
}
}
//获得两个数中的较大值
int max = (m > n)?m:n;
for (int i = max;i <= m*n;i++) {
if(i % m == 0 && i % n == 0) {
System.out.println("最小公倍数是"+ i);
break;//一旦在循环中执行到break,就跳出
}
}
}
}
/*
//结果
请输入第一个正整数:
20
请输入第二个正整数:
12
最大公约数是4
最小公倍数是60
*/
public class ForExer3 {
public static void main(String[] args) {
//打印1~100之间所有奇数的和
int sum = 0;
for(int i = 1;i <= 100;i++) {
if(i % 2 == 1) {
sum += i;
}
}
System.out.println("1~100之间所有奇数的和为" + sum);
//1~100之间所有奇数的和为2500
//打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数器的思想）
int sumSeven = 0;
int countSeven = 0;
for(int i = 1;i <= 100;i++) {
if(i % 7 == 0) {
sumSeven += i;
countSeven++;
}
}
System.out.println("1~100之间7的倍数的整数的总和为" + sumSeven);
System.out.println("1~100之间7的倍数的个数为" + countSeven);
//1~100之间7的倍数的整数的总和为735
//1~100之间7的倍数的个数为14
}
}
While循环结构的使用
一 循环结构的4个要素
1初始化条件
2循环条件 ---Boolean类型
3循环体
4迭代条件
二 while循环结构
1循环初始条件;
while(2循环条件){
3循环体;
4迭代条件;
}
执行过程：1-->2-->3-->4-->2--->4--->2.....-->2
说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了 可能导致死循环。
2.写程序要注意避免出现死循环
3.for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件作用域不一样
package com.atguigu.java;
public class WhileTest {
public static void main(String[] args) {
//遍历 100 以内的所有偶数
int i = 1;
while(i <= 100) {
if(i % 2 == 0) {
System.out.println(i);
}
i++;
}
}
}
do-while循环结构的使用
一 循环结构的4个要素
1初始化条件
2循环条件 ---Boolean类型
3循环体
4迭代条件
二 do-while循环结构
1初始化条件;
do{
3循环体;
4迭代条件;
}while(2循环条件);
执行过程：1-->3-->4-->2-->3--->4--->2.....-->2
package com.atguigu.java;
public class DoWhileTest {
public static void main(String[] args) {
//遍历100以内的偶数
int i = 1;
do {
if(i % 2 == 0) {
System.out.println(i);
}
i++;
}while(i <= 100);
}
}
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入
为0时结束程序。
说明:
1.不在循环条件部分限制次数的结构:for(;;),while(true)
2.结束循环有几种方式？
方式一:在循环条件部分返回false
方式二:在循环体中,执行break
package com.atguigu.java;
import java.util.Scanner;//导包
public class AllExer1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//实例化
int sumPositive = 0,sumNegative = 0;
//sumPositive 记录正数的个数
//sumNegative 记录负数的个数
while(true) {
int number = scan.nextInt();//调包
//判断正负情况
if(number == 0) {
break;
}else if(number > 0) {
sumPositive++;
}else {
sumNegative++;
}
}
System.out.println("读入正数的个数为" + sumPositive);
System.out.println("读入负数的个数为" + sumNegative);
}
}
/*
//结果
5
-2
92
12
-2138
0
读入正数的个数为3
读入负数的个数为2
*/
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
2.外层循环:B
内层循环:A
3.说明
3.1内层循环结构遍历一遍,只相当于外层循环体执行了一次
3.2假设外层循环需要执行m次,内层循环需要执行n次,此时内层循环的循环体一共执行了m*n次
4.技巧
外层循环控制行数
内层循环控制列数
package com.atguigu.java;
public class ForForExer1 {
public static void main(String[] args) {
//输出 ******
for(int i = 1;i <= 6;i++) {
System.out.print("*");
}
System.out.println("\n");
//输出
/*
******
******
******
******
*/
for(int j = 1;j <= 4;j++) {
for(int i = 1;i <= 6;i++) {
System.out.print("*");
}
System.out.println();
}
}
}
输出
i(行数) j(列数)
* 1 1
** 2 2
*** 3 3
**** 4 4
package com.atguigu.java;
public class ForForExer2 {
public static void main(String[] args) {
for(int i = 1;i <= 4;i++) {
for(int j = 1;j <= i;j++) {
System.out.print("*");
}
System.out.println();
}
}
}
九九乘法表
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
....
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27
package com.atguigu.java;
public class NineNineTable {
public static void main(String[] args) {
for(int i = 1;i <= 9;i++) {
for(int j = 1;j <= i;j++) {
System.out.print(i + " * " + j + " = " + (i*j) + " ");
}
System.out.println();
}
}
}
输出100以内的质数
package com.atguigu.java;
public class PrimeNumberTest {
public static void main(String[] args) {
boolean isFlag;//标识符
for(int i = 2;i <= 100;i++) {//遍历100以内的自然数
isFlag = true;
for(int j = 2;j <= Math.sqrt(i);j++) {//j:被i去除
//Math.sqrt(i) 优化二:针对本身是质数自然数有效
if(i % j == 0) {//i被j除尽
isFlag = false;
break;//优化一：只对本身非质数的自然数是有效的
}
}
if(isFlag) {
System.out.println(i);
}
}
}
}
break和continue关键字的使用
适用范围 循环中的作用
break: switch-case,循环 结束当前循环
continue: 循环 结束当次循环
package com.atguigu.java;
public class BreakTest {
public static void main(String[] args) {
for(int i = 1;i <= 10;i++) {
if(i % 4 == 0) {
//break;123
continue;//123567910
}
System.out.print(i);
}
System.out.println();
//*************
label:for(int i = 1;i <= 4;i++) {
for(int j = 1;j <= 10;j++) {
if(j % 4 == 0) {
//break;//默认跳出包裹此关键字的最近一次循环
//continue;//默认结束包裹此关键字的最近一次循环
break label;//结束指定标签的一层循环
//continue label;
}
System.out.print(j);
}
System.out.println();
}
}
}
/*
//结果
123567910
123
*/
原文：https://www.cnblogs.com/ccc-code/p/14727956.html