Java学习第二章——Java基本语句

最新推荐文章于 2022-01-16 20:47:09 发布

缥缈一叶舟

最新推荐文章于 2022-01-16 20:47:09 发布

阅读量1.1k

点赞数

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/u014681502/article/details/113874116

版权

JAVA 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

代码，改变世界。让我们开启Java学习之路，遇见更好的自己~

关键字与保留字

关键字(keyword)的定义和特点

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写

下图中的内容了解即可，在后续的学习中会有针对性讲解

保留字(reserved word)
Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 goto、const

标识符(Identifier)

Java对各种变量、方法和类等要素命名时使用的字符
技巧：凡是自己可以起名字的地方都叫标识符

定义合法标识符规则：
由26个英文字母大小写,0-9,_或$组成
数字不可以开头
不可以使用关键字和保留字，但能包含关键字和保留字
Java中严格区分大小写，长度无限制。
标识符不能包含空格。

Java 中的名称命规范
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法：多单词组成时，第一个首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接： XXX_YYY_ZZZ

注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。
更多细节可阅读书籍《代码整洁之道》

变量

变量的概念：
内存中的一个存储区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

变量的作用：
用于在内存中保存数据

使用变量注意：
Java中每个变量必须先声明，后使用
使用变量名来访问这块区域的数据
变量的作用域：其定义所在的一对{ }内
变量只有在其作用域内才效
同一个作用域内，不能定义重名的变量

声明变量
语法：<数据类型> <变量名称>
例如：int var;

变量的赋值
语法：<变量名称> = <值>
例如：var = 10;

声明和赋值变量
语法： <数据类型 ><变量名 >= <初始化值 >
例如： int var = 10;

变量的分类-按数据类型
对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间。

补充：变量的分类-按声明的位置不同（详见第四章）
在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。

注意：二者在初始化值方面的异同同：都有生命周期异：局部变量除形参外，需显式初始化。

整数类型： byte、short 、int 、long
Java各整数类型有固定的表示范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
java的整型常量默认为int型，声明long型常量须后加‘l’或‘L’
java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

浮点类型：float、double
与整数类型类似，Java浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
浮点型常量有两种表示形式：
十进制数形式：如5.12 512.0f .512 (必须有小数点）
科学计数法形式 :如：5.12e2 512E2 100E-2
float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double: 双精度，精度是float的两倍。通常采用此类型。
Java的浮点型常量默认为double型，声明float型常量，须后加‘f’ 或‘F’ 。

字符类型：char
char型数据用来表示通常意义上“字符”(2字节)
Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字或其他书面语的一个字符。
字符型变量的三种表现形式：
字符常量是用单引号(' ')括起来的单个字符。例如：char c1 = 'a';char c2 = '中';char c3 = '9';
Java中还允许使用转义字符'\'来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // '\n'表示换行符
直接使用Unicode值来表示字符型常量：‘\uXXXX ’。其中，XXXX代表一个十六进制整数。如：\u000a表示\n。
char类型是可以进行运算的。因为它都对应有Unicode码。

扩展内容(了解即可):

在计算机内部，所有数据都使用二进制表示。每一个二进制位(bit)有0和1两种状态，因此8个二进制位就可以组合出256种状态，这被称为一个字节 (byte)。一个字节一共可以用来表示256种不同的状态，每一个状态对应一个符号，就是256个符号，从0000000到11111111。

ASCII码

ASCII码：上世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定，这被称为ASCII码。ASCII码一共规定了 128个字符的编码，比如空格“SPACE”是32位（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括 32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。
缺点：
不能表示所有字符。
相同的编码表示的字符不一样：比如，130在法语编码中代表é，在希伯来语编码中却代表ג

乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。

Unicode编码
Unicode：一种编码，将世界上所有的符号都纳入其中。每个符号给予一个独一无二的编码，使用Unicode没有乱码的问题。

缺点：Unicode只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储:计算机无法区分三个字节表示一个符号还是分别表示三个符号；无法区别Unicode和ASCII；浪费存储空间

UTF-8

UTF-8是在互联网上使用最广的一种Unicode的实现方式。
UTF-8是一种变长的编码方式。它可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度。
UTF-8的编码规则（了解即可）：
对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于 ASCII码）。
对于多字节的UTF-8编码，如果包含n个字节，那么第一个字节的前n位为1，第一个字节的第n+1位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为 "10"，其余 6位用来对字符进行编码。（对细节想有进一步认识可参考计算机字符编码）

布尔类型：boolean
boolean类型用来判断逻辑条件，一般用于程序流程控制：
if条件控制语句；
while循环控制语句；
do-while循环控制语句；
for循环控制语句；

boolean类型数据只允许取值true和false,无null。
不可以使用0或非0的整数替代false和true，这点和C语言不同。
Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。——《java虚拟机规范8版》

基本数据类型转换
自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：（容量大小为表示数的范围大小）

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大那种数据类型，然后再进行计算。
byte,short,char之间不会相互转换，他们三者在计算时首先转为int类型。
boolean 类型不能与其它数据运算。
当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。

强制类型转换
自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出，格外要注意。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。(此部分内容会在对象章节详细介绍)
如：String a = "43"; int i= Integer.parseInt(a);
boolean类型不可以转换为其它的数据类型。

字符串类型：String
String不是基本数据类型，属于引用数据类型
使用方式与基本数据类型一致。例如：String str = "abcd";
一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：

str = str + “xyz” ;
int n = 100; 
str = str + n;

练习

String str1 = 4;  // 判断对错 ：no
String str2 = 3.5f + “”; 判断str2 对错 ：yes
System.out.println(str2); //输出 ：”3.5” 
System.out.println 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 

判断是否能通过编译
1）short s = 5; 
s = s-2;  // 判断 ：no，s-2为int
2） byte b = 3;
b = b + 4; // 判断 ：no
b = (byte) (b+4 );// 判断 ：yes
3）char c = ‘a’; 
int i = 5;
float d = .314F;
double result = c+i+d; 判断：yes
4）byte b = 5; 
   short s = 3; 
   short t = s + b; // 判断 ：no,s+b为int

运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
运算符有算术运符、赋值运算符、比较运算符（关系）、逻辑运算符、位运算符、三元运算符

算术运算符

算术运符的注意问题
如果对负数取模，可以把模数负号忽略不记：5%-2=1。但被模数是负数则不可忽略。此外取模运算的结果不一定总是整数。（结果的符号与被模数的符号相同）
对于除号"/"，它的整数除和小数除是有区别的：整数之间做除法时只保留整数部分而舍弃小数部分。
"+"除字符串相加功能外，还能把非字符串转换成字符串。

练习:自加自减

public class  SignTest{
    public static void main(String[] args){
        int i1 = 10 
        int i2 = 20; 
        int i = i1++; 
        System.out.print("i="+i);  //i= 10 ，i1的值先赋给i,而后加
        System.out.println("i1="+i1); //i1=11
        i = ++i1; 
        System.out.print("i="+i); //i= 12
        System.out.println ("1i="+i1); //i1=12
        i = i2-- ;
        System.out.print("i="+i); //i= 20
        System.out.println("i2="+i2); //i2=19
        i = --i2; 
        System.out.print("i="+i);  //i=18
        System.out.println("i2="+i2); ; //i1=18
    }
}

练习：

随意给出一个整数 ，打印显示它的个位数 ，十位数 ，百位数的值 。
格式如下：
数字 xxx 的情况如下：
个位数：
十位数：
百位数

public class Test1{
	public static void main(String[] args){
		int a =153;
		System.out.println("数字"+a+"的情况如下:");
		System.out.println("个位数:"+a%10);
		System.out.println("十位数:"+(a%100)/10);
		System.out.println("百位数:"+a/100);
	}
}

赋值运算符

符号：=
当"="两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
支持连续赋值 i1=j1=10;
扩展赋值运算符：+=，-=，*=，/=，%=

练习

思考 1：
short s = 3; 
s = s+2; ①
s += 2;② 
①和②有什么区别？
①改变了数据类型，无法编译 
②可以编译。不改变本身的数据类型.2转为short类型运算

思考 2：
int i = 1; 
i *= 0.1;
System.out.println(i); //截断，0
i++; 
System.out.println(i）; //1

思考 3：
int m = 2; 
int n = 3;
n *= m++; 
System.out.println("m=" + m); //3
System.out.println("n=" + n); //6

*思考 4：
int n = 10;
n += (n++) + (++n);
System.out.println(n); //32 10+10+12

比较运算符

比较运算符的结果都是boolean型，也就是要么true，要么false。
比较运算符“ ==” 不能误写成"=" 。

逻辑运算符

&—逻辑与 | —逻辑或！—逻辑非

&& —短路与 || —短路或 ^ —逻辑异或

逻辑运算符用于连接布尔型表达式，在 Java中不可以写成 3<x<6，应该写成x>3 & x<6 。
“&” 和“ &&” 的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
异或(^)与或(|)的不同之处是：当左右都为true时，异或结果为false。理解：异或，追求的是“异” !

练习

int x = 1; 
int y = 1; 
if(x++==2 & ++y==2){ 
    x =7;
}
System.out.println("x="+x+",y="+y); //2 2

int x = 1,y = 1;
if(x++==2 && ++y==2){
    x =7;
}
System.out.println("x="+x+",y="+y); //2 1

int x = 1,y = 1; 
if(x++==1 | ++y==1){ 
    x =7;
}
System.out.println("x="+x+",y="+y); //7 2

int x = 1,y=1; 
if(x++==1 || ++y==1){ 
    x =7;
}
System.out.println("x="+x+",y="+y); //7 1


【面试题】
class Test {
    public static void main (String[] args) { 
     boolean x=true;
     boolean y=false;
     short z=42; 
     //if(y == true)
     if((z++==42)&&(y=true))z++; //注意是赋值
     if((x=false) || (++z==45)) z++; 
     System.out.println(“z=”+z); //46
    }
}

位运算符(了解即可)

位运算符是直接对整数的二进制进行的运算

交换两个变量的值
方式一：定义临时变量(推荐)
int temp = num1;
num1 = num2;
num2 = temp;

方式二:（有溢出风险，局限性数值型）
num1 = num1+num2;
num2 = num1-num2;
num1 = num1-num1;

方式三：使用位运算符(局限数据类型，原理见下图)
num1 = num1^num2;
num2 = num1^num2; //等于原num1的值
num1 = num1^num2;

三元运算符

格式 :
(条件表达式)?表达式1:表达式2；
条件表达式为true，运算后的结果是表达式1；
条件表达式为false，运算后的结果是表达式2；
表达式1和表达式2为同种类型（会自动转为同种类型）

运算符的优先级
运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下图，上一行运算符总优先于下一行。
只有单目运算符、三元运算符、赋值运算符是从右向左运算的。运算顺序可以使用括号来控制。

程序流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完一定功能的小逻辑模块。

顺序结构

if -else 结构

分支结构： if -else 使用说明

条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
语句块只有一条执行语句时，一对 {} 可以省略，但建议保留
if -else语句结构，根据需要可以嵌套使用
当if -elseelse 结构是“多选一”时，最后的 else是可选的，根据需要以省略
当多个条件是“互斥”关系时，判断语句及执行间顺序无所谓
当多个条件是“包含”关系时，“小上大下 / 子上父下”（条件包含范围）

补充知识点：从键盘获取不同类型的变量

/*具体实现步骤
  1.导包import.util.Scanner
  2.Scanner的实例化
  3.调用Scanner类的相关方法，获取指定类型的变量
*/

import java.util.Scanner;
class ScannerTest{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
    }
}

//字符串，字符 .next()
//.nextInt()
//.nextDouble()
//.nextBoolean()

练习

1.岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW ；
成绩为 (80 ，99] 时，奖励一台 iphone xs 
当成绩为 [60,80]时，奖励一个 iPad；
其它时，什么奖励也 没有。
请从键盘输入岳小鹏的期末成绩

import java.util.Scanner;
public class Score{
	public static void main(String[] args){
		Scanner scan= new Scanner(System.in);
		System.out.printl("输入乘积：")
		int score = scan.nextInt();
		if (score==100)
			System.out.println("BMW");
		else if (score>80 && score<=99)
			System.out.println("iphone X");
		else if (score>60 && score<=80)
			System.out.println("Ipad");
		else
			System.out.println("nothing");	
	 }
}


2.编写程序：由键盘输入三个整数分别存变量 num1、num2、num3 ， 对它们进行排序 (使用 if -else ), 并且从小到大输出。
import java.util.Scanner;
public class Score{
	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);
			}
		}				
	 }
}


2.我家的狗 5岁了， 5岁的狗相当于人类多大呢？其实，前两年每一年相当于人类的 10.5岁，之后每增加一年就增加四岁。那么 5岁的狗相当于人类多少年龄呢？应该是： 10.5 + 10.5 + 4 + 4 + 4 = 33
编写一个程序，获取用户输入的狗年龄通过显示其相当于人的年龄
import java.util.Scanner;
public class Score{
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		System.out.println("输入狗的年龄");
		int age = scan.nextInt();
		if(age<0)
			System.out.println("输入有误");
		else if (age<=2)
			System.out.println("相当于人的年龄"+10.5*age);
		else
			System.out.println("相当于人的年龄"+(10.5*2+4*(age-2)));		
	}
}

3.假设你想开发一个玩彩票的游戏，程序随机地产生两位数的彩票 ，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
1) 如果用户输入的数匹配彩票实际顺序，奖金 10 000 美元。
2) 如果用户输入的所有数字匹配彩票，但顺序不一致奖金 3 000美元。
3) 如果用户输入的一个数字仅满足顺序情况下匹配彩票，奖金 1 000美元。
4) 如果用户输入的一个数字仅满足非顺序情况下匹配彩票，奖金 500 美元。
5) 如果用户输入的数字没有匹配任何一个，则彩票作废 。

import java.util.Scanner;
public class Score{
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入彩票数字");
		int num = scan.nextInt();
		//int value = (int)(Math.random()*90+10);
		int value = 89;
		System.out.println("彩票开奖号码是："+value);
		int num_shi = num/10;
		int num_ge = num%10;
		int value_shi = value/10;
		int value_ge = value%10;
		if((num_shi == value_shi) && (num_ge == value_ge) )
			System.out.println("奖金10 000");
		else if((num_shi == value_ge) && (num_ge == value_shi))	
			System.out.println("奖金3 000");
		else if ((num_shi == value_shi)||(num_ge == value_ge))	
			System.out.println("奖金1 500");	
		else if ((num_shi == value_ge)||(num_ge == value_shi))
			System.out.println("奖金 500");
		else
			System.out.println("谢谢参与");
	}
}

switch-case结构

switch(表达式){
case 常量 1:
    语句 1;
    // break ;
case 常量 2:
    语句 2;
    //break ;
… …
case 常量 N:
语句 N;
    //break ;
defaultd:
    语句 ;
    // break break ;
}

switch语句有关规则
switch(表达式 )中表达式的值必须是下述几种类型之一： byte ,short,char,int ，枚举 (jdk 5.0),String (jdk 7.0)(不能放浮点);
case子句中的值必须是常量，不能是变量名或确定的表达式值；
同一个switch语句，所有 case 子句中的常量值互不相同；
break语句用来在执行完一个case分支后使程序跳出switch 语句块；如果没有break ，程序会顺序执行到 switch结尾
default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default。
例题：

1. 使用 switch把小写类型的char型转为大写。只转换 a,b,c,d,e. 其它的输出“other ”。
提示： String word = scan.next(); char c = word.charAt(0); switch(c){} 

import java.util.Scanner;
public class Score{
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		String word = scan.next();
		char c = word.charAt(0);
		switch(c){
		case 'a':
			System.out.println('A');
			break;
		case 'b':
			System.out.println('B');
			break;
		case 'c':
			System.out.println('C');
			break;
		case 'd':
			System.out.println('D');
			break;
		case 'e':
			System.out.println('E');
			break;
		default:	
			System.out.println("other");
		}			
	}
}

2*.对学生成绩大于 60 分的，输出“合格”。低于 60 分的，输出“不合格” 。
int score = scan.nextInt();
		switch(score/60){
		case 0:
			System.out.print("不及格")；
		case 1:
			System.out.print("及格")；

3. 根据用于指定月份，打印该所属的季节 。
3,4,5 春季 6,7,8 6,7,8 夏季 9,10,11 9,10,11 9,10,11 秋季 12, 1, 2 12, 1, 2 12, 1, 2 冬季

Scanner scan = new Scanner(System.in);
		int month = scan.nextInt();
		switch(month){
		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;
		case 12:
		case 1:	
		case 2:
			System.out.println("冬季");
			break;
		}
4*. 编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序输出输入的日期为2019年的第几天 。
public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		System.out.println("输入month"：);
		int month = scan.nextInt();	
		System.out.println("输入day"：);
		int day = scan.nextInt();
		int sumDays = 0;
		switch(month){
		case 12:
			sumDays += 30;
		... ...
		case 4:
			sumDays += 31;
		case 3:
			sumDays += 28;
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}		
	}

switch语句练习

从键盘分别输入年、月、日，判断这一天是当年的第几天
注： 判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除，
或
2）可以被 400 整
Scanner scan = new Scanner(System.in);
		System.out.println("输入year"：);
		int year = scan.nextInt();
		System.out.println("输入month"：);
		int month = scan.nextInt();	
		System.out.println("输入day"：);
		int day = scan.nextInt();
		int sumDays = 0;
		switch(month){
		case 12:
			sumDays += 30;
		... ...
		case 4:
			sumDays += 31;
		case 3:
			if((year%400==0) ||(year%4==0 && year%100 !=0)){
			sumDays += 29;
			}else{
			sumDays += 28;
			}
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}	

编写一个程序，为给定的年份找出其对应中国生肖。基于12年一个周期， 每年用一个动物代表

if 和switch语句很像，具体什么场景下应用哪个呢？
如果判断的具体数值不多，而且符合 byte、short、cha、int 、String 、枚举等几种类型。虽然两个语句都可以使用，建议swtich语句。因为效率稍高。
其他情况：对区间判断，对结果为 boolean类型判断，使用 if ，if 的使用范围更广。也就是说，使用 switch case 的，都可以改写为 if -else，反之不成立。

循环结构

循环结构
在某些条件满足的情况下，反复执行特定代码的功能
循环语句分类
for 循环
while循环
do -while循环

循环语句的四个组成部分
初始化部分 (init_statement)
循环条件部分 (test_exp)
循环体部分 (body_statement )
迭代部分 (alter_statement)

循环结构之for循环

语法格式

for (①初始化 部分 ;②循环条件部分 ;④迭代部分 )｛
      ③循环体部分 ;
｝

执行过程：
①-②-③-④-②-③-④-②-③-④-..... -②
说明：
②循环条件部分为 boolean类型表达式，当值为 false 时，退出循环
①初始化部分可以声明多个变量，但必须是同一类型，用逗号分隔
④可以有多个变量更新，用逗号分隔

例题

1.编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行打印出"foo", 在每个5的倍数行上打印"biz", biz”, 在每个7的倍数行上打印输出"baz"。
for (int i = 1;i<=150;i++){
			System.out.print(i);	
			if(i%3==0){
				System.out.print(" "+"foo");	
			}
			if (i%5==0){
				System.out.print(" "+"biz");	
			}
			if (i%7==0){
				System.out.print(" "+"baz");	
			}
		System.out.println("\n");
}

2*：输入两个正整数m和n，求其最大公约数和最小公倍数
比如 ：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用。
Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		int m = 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;//跳出循环
			}
		}
		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;
			}
		}

输出所有的水仙花数，所谓水仙花数是指一 个3位数，其各个位上数字立方和等于其本身。
例如： 153 = 1*1*1+5*5*5+3*3*3

int ge;
		int shi;
		int bai;
		for (int i =100;i<1000;i++){
			ge = i %10;
			shi = i/10%10;
			bai = i/100;
			if (i == ge*ge*ge+shi*shi*shi+bai*bai*bai){
				System.out.println(i);
			}
		}

while循环

语法格式
①初始化部分

①初始化部分
while( ②循环条件部分 )｛
    ③循环体部分 ;
    ④迭代部分 ;
}

执行过程：
①-②-③-④-②-③-④-②-③-④-... -②
说明：
注意不要忘记声明 ④迭代部分。否则，循环将不能结束，变成死循环。
for循环和whil循环可以相互转换。

do -while循环

语法格式
①初始化部分 ;

①初始化部分 ;
do{
    ③循环体部分
    ④迭代部分
}while(②循环条件部分 );

执行过程：
①-③-④-②-③-④-②-③-④-...... ②
说明：
do -while循环至少执行一次循环体。

循环语句综合例题

最简单“无限”循环格式： while(true),for(;;),无限循环存在的原因是并不知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。

结束循环的方式：

一：循环条件部分返回false

二：在循环体内，执行break

题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序 。
//法一：
        int cnt1  = 0;
		int cnt2  = 0;
		System.out.println("请输入整数");
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		while (n !=0){
			if(n >0)
				cnt1++;
			else
				cnt2++;
			System.out.println("请再次输入");
			n = scan.nextInt();
		}
		System.out.println("正数个数"+cnt1);
		System.out.println("负数个数"+cnt2);	

//法二(推荐)：
        int cnt1  = 0;
		int cnt2  = 0;
        Scanner scan = new Scanner(System.in);
		System.out.println("请输入整数");
		for(;;)//while (true){
		    int n = scan.nextInt();
			if(n >0)
				cnt1++;
			else if
				cnt2++;
			else
                break;
		}
		System.out.println("正数个数"+cnt1);
		System.out.println("负数个数"+cnt2);

嵌套循环 (多重循环 )
将一个循环放在另一个循环体内，就形成了嵌套循环。其中for ,while ，do…while均可以作为外层循环或内层循环。
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内存循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为 m次，内层为 n次，则内层循环体实际上需要执行 m*n 次。

例题：

1.输入如下图案
*
**
***
****
*****
for (int i =1;i <=5; i++){
			for (int j =1;j<=i;j++){
				System.out.print("*");
			}
			System.out.println("\n");
}	

2.如下图案
*****
****
***
**
*

for (int i =1;i <=5; i++){
			for (int j = 6-i;j >=1;j--){
				System.out.print("*");
			}
			System.out.println("\n");
}	

3*.如下图案
    *
   * *
  * * *
 * * * *
* * * * *
 * * * *
  * * *
   * *
    *
for (int i=1;i<=5;i++){
			for(int j=1;j<=5-i;j++)
				System.out.print(' ');
			for(int k=1;k<=2*i-1;k++){
		 		if(k%2==1){
					System.out.print('*');
				}else{
					System.out.print(" ");
				}	 
			}
			System.out.println();
		}
		for(int i =1;i<=4;i++){
			for(int j=1;j<=i;j++)
				System.out.print(' ');
		
			for(int k=1;k<=9-2*i;k++){
		 		if(k%2==1){
					System.out.print('*');
				}else{
					System.out.print(" ");
				}
			
			}
			System.out.println();
		}	

4.九九乘法表
for(int i=1;i<=9;i++){
			for (int j =1;j<=i;j++){
				System.out.print(i+" * "+j+" = "+(i*j)+" ");
			}
			System.out.println();
		}

5*.100以内的所有质数

//效率不高
public static void main(String[] args){
		boolean isFlag = true;
		for (int i=2;i<=100;i++){
			for (int j=2;j<i;j++){
				if (i%j==0){//需要在所有的j完成判断才输出
					isFlag = false;
				}
			}
		if(isFlag){
			System.out.print(i+" ");
		}
		isFlag = true;
		}	
	}

//优化一
boolean isFlag = true;
		for (int i=2;i<=100;i++){
			for (int j=2;j<=Math.sqrt(i);j++){//优化二,范围缩小到边界值的开方
				if (i%j==0){//需要在所有的j完成判断才输出
					isFlag = false;
					优化一：只对本身非质数的自然数有效
				}
			}
		if(isFlag){
			System.out.print(i+" ");
		}
		isFlag = true;
		}	


//方法二
label:for (int i=2;i<=100;i++){
			for (int j=2;j<=Math.sqrt(i);j++){
				if (i%j==0){//需要在所有的j完成判断才输出
					continue label;
				}
			}
        System.out.print(i+" ");
}

特殊关键字的使用：break 、continue

break 语句

break语句用在switch- case和循环结构中

break语句用于终止某个语句块的执行，结束当前循环，关键字后面不能再声明执行语句

continue 语句
continue只能使用在循环结构中
continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环，关键字后面不能再声明执行语句

break语句出现在多层嵌套的块中时，可以通过标签指明要终止是哪一层语句块
label1:{……
label2:    {……
label3:        {……
        break label2;
……
                }
            }
        }

附加：特殊流程控制语句：return的使用
return ：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到return语句时，这个方法将被结束。
与break和continue不同的是， return直接结束整个方法，不管这个return 处于多少层循环之内

项目：

至此，本章节内容结束。试试身手，去完成本章的小项目“家庭记账软件”吧。

缥缈一叶舟

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
1
评论
Java学习第二章——Java基本语句

Java基本语句关键字与保留字关键字 (keyword)的定义和特点定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）特点：关键字中所有字母都为小写保留字 (reserved word)Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使这些保留字goto 、const标识符 (Identifier)Java对各种变量、方法和类等要素命名时使用的字符技巧：凡是自己可以起名字的地方都叫标识符定义合法...
复制链接

扫一扫