JAVA语言组成及详细知识点

最新推荐文章于 2022-12-26 09:36:30 发布

原创最新推荐文章于 2022-12-26 09:36:30 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了Java语言的基础组成部分，包括关键字、标识符、常量、变量、数据类型、运算符等内容，适合初学者入门。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. Java语言基础组成：

Ø 关键字，标识符，注释，变量和常量，运算符，语句，函数，数组。

2. 关键字：

2.1. 关键字的定义及特点：

Ø 定义：被Java语言赋予了特殊含义的单词。

Ø 特点：关键字所有字母都是小写。

2.2. java中的关键字：

Ø 用于定义数据类型的关键字： class ，interface ，byte ，short ，int ，long ，float ，double ，char ，boolean ，void。

Ø 用于定义数据类型值的关键字：true ，false ，null。

Ø 用于定义流程控制的关键字：if ，else ，switch ，case ，default ，while ，do ，for ，break ，continue ，return。

Ø 用于定义访问权限修饰符的关键字：private ，protected ，public；

Ø 用于定义类，函数，变量修饰符的关键字：abstract ，final ，static ，synchronized；

Ø 用于定义类与类之间的关键字：extends ，implements；

Ø 用于定义建立实例及引用实例，判断实例的关键字：new ，this ，super ，instanceof；

Ø 用于处理异常的关键字：try ，catch ，finally ，throw ，throws；

Ø 用于包的关键字：package ，import；

Ø 其他修饰符关键字：native ，strictfp ，transient ，volatile ，assert。

Ø 注意goto 和 const是java是保留字

3. 标识符:

3.1. 标识符的概述：

Ø 在程序中自定义的一些名称；

Ø 由26个英文字母大小写，数字：0到9 ，符号：_$组成；

Ø 定义合法标识符的规则：

Ø 数字不可以开头；

Ø 不可以使用关键字。

Ø Java中严格区分大小写，另外还要注意，起名字时为了提高阅读性，要尽量有意义。

3.2. Java中的名称规范：

Ø 包名：多单词组成时所有字母都小写。如：xxxyyyzzz；

Ø 类名和接口名：多单词组成时，所有单词的首字母大写。如：XxxYyyZzz；

Ø 变量名和函数名：多单词组成时，第一个单词首字母小写，从第二个单词开始，每个单词首字母大写。如xxxYyyZzz；

Ø 常量名：所有字母都大写，多单词时，每个单词用下划线联接。如：XXX_YYY_ZZZ。

4. 常量：

Ø 常量表示不能改变的值；

Ø Java中常量的分类： ① 整数常量，所有整数；

② 小数常量，所有小数；

③ 布尔型常量。只有两个数值，true 和false。

④ 字符常量，将一个数字、字母或者符号用（‘ ’）表示：a’,’2’,’我’，注意：‘’ ，‘ ’，‘hh’这些写法是错的，字符常量，有，必须有，且只能有一个；

⑤ 字符串常量，用“”标示，可以写多个字符，也可以没有；

⑥ null常量，只有一个数值null。

Ø Java中，整数有三种变现形式：

① 十进制，0--9,满十进一；

② 八进制，0--7，满八进一，用0开头表示，如025,022；

③ 十六进制，0--9，A--F,满16进一，用0x开头标示，如0x32;

5. 进制转换：

5.1. 十进制与二进制互转：

Ø 十进制转二进制，除以2取余数，如下图，最终6的二进制是110；

Ø 二进制转十进制，乘以2的次幂，如下图：

5.2. 十进制与八进制互转：

Ø 先把十进制转换成二进制，然后再把二进制转换成八进制；

Ø 三个二进制位代表一个八进制位，如果不足，就到前面添0补齐三位；

Ø 先把十进制转换成二进制，然后再把二进制转换成八进制；

5.3. 十进制与十六进制互转：

Ø 把十进制数转换成二进制，然后再把二进制数转换成16进制；

Ø 四个二进制位代表一个十六进制位，如果不足，就到前面添0；

6. 变量：

6.1. 变量的概念：

Ø 内存中的一个存储区域；

Ø 该区域有自己的名称（变量名）和类型（数据类型）；

Ø 该区域的数据可以在同一类型范围内不断变化。

6.2. 为什么定义变量？

Ø 用来不断的存放同一类型的常量，并可以重复使用。

6.3. 使用变量注意：

Ø 变量的作用范围（一对{}之间有效）；

Ø 初始化值。

6.4. 定义变量的格式：

Ø 数据类型变量名 = 初始化值；如 int a = 5; char b = ‘a’;等。

7. 数据类型：

7.1. java中的数据类型分类：

Ø 基本数据类型

Ø 引用数据类型；

7.2. 基本数据类型（4类8种）：

Ø 整数类型：

byte字节型，在内存中占有1个8位，取值范围-128~127；一个字节的范围是0到255, 而一个8位的二进制最大正数是 01111111,在二进制中,第一位表示符号位, 0是正,1是负, 而0111111换算成10进制就是127, 既然这样, 因为只能占一个字节,那么负数的最小值就只能是-128了.

short短整型，在内存中占有2个8位，取值范围-32768~32767；

int整型，在内存中占4个8位，取值范围-2147483648~~2147483647，整数默认类型都是int类型；

long，长整型，在内存中占8个8位。

Ø 浮点类型：

单精度浮点类型：float，内存中占4个8位，数据定义的时候加上F或f，例如：float f = 3.32f或 float f = 32.4F; 关于浮点型float能够装下long的原因是, 整数类型在内存中是0101存在的, 而浮点型不是,long的范围没有float的范围大;

双精度浮点类型：double，内存中占8个8，浮点类型默认是double。

Ø 字符型：

char，存储单一字符，内存中占2个8位；注意 char a = ‘我’；这个是可以的，一个中文字符两个字节；给char赋值的几种情况, 直接附上数值,如: char a = 34; 这样赋值,其实默认的是ascii码值, 一共两个字节, 0到65535, 也就是说给char 直接赋值数字, 那么char = 0 到char = 655535都是可以的; 如过直接赋值字符如:char c = ‘a’,那么这时里面必须有且只能有一个,即使空格也可以, 但不管怎样, 必须得有一个, 如, char c = ‘’ 这样的写法就是错误, 因为’ ‘(单引号)里面什么也没有 , 如果是赋值转义字符, 那么分8进制和16进制, 其中赋值8进制的范围是十进制的0到255, 换算成八进制就是’\0’ 到 ‘\377’, 也就是说如果赋值 char c = ‘\0’ 到char c = ‘\377’ 都是可以的, 但是赋值的范围一定要是十进制的0 到 255, 如果不是, 那么就是错误的, 例如char c = ‘\400’就是错误的, 因为八进制的400 表示的是十进制的256, 超过了范围, 还有要注意的就是, 千万不要写成 char c = ‘\80’ 这种带8的值, 8进制中逢八进一, 那么8进制中怎么可能出现8这个值呢? 然后就是赋值16进制转义字符, char c = ‘\u0’ 到 char c = ‘\uFFFF\’, 也就是十进制的0到65535范围类的16进制都可以, 赋值16进制转义字符要注意的情况, 1, 其中 \u 不要忘记写, 如果不写, 代表的是8进制的转义字符; 2, 不要把十进制和16进制搞混了, 例如:char c = ‘\u1000’, 这就是错误的, 因为16进制中的1000表示形式是3E8, 而不是1000; 3, 赋值16进制转义字符一定要是四位数, 如果没有, 那么前面加0, 例如 char c = ‘\u7’这个是错误的,只有1位数, 正确写法是, char c = ‘\u0007’’; 最后就是一些特殊的转移字符, 例如 char c = ‘\t’, char c = ‘\r’ 等这些特殊转移字符都可以这样赋值

Ø 布尔型：boolean，2个值，真（true），假（false），两个值都是关键字。

7.3. 引用数据类型：

Ø 类(class)，接口（interface），数组（[] )。

8. 数据类型转换：

8.1. 自动类型转换（也叫隐式类型转换）；

Ø byte a = 5，int b = 5；

b = a + b；//a会自动提升为int类型进行运算

8.2. 强制类型转换（也叫显示类型转换）；

Ø byte a = 5，int b = 5；

a = a + b；//报错

a = （byte）a + b；//强制类型转换，强制将a + b的结果转换为byte类型，再赋值给a。

Ø 注意：强制转换要损失精度，慎用。

8.3. 面试题:

Ø 判断float f = 12.5f 与 float f = (float)12.5的区别? 前面是直接定义为float类型, 后者是强制转换成float类型, 后者可能会损失精度;

8.4. 表达式的数据类型自动提升：

Ø 所有的byte型，short型，char型的值都将被提升到int型；

Ø 如果一个操作数是long型，计算结果就是long型；

Ø 如果一个操作数是float型，计算结果就是float型；

Ø 如果一个操作数是double型，计算结果就是double型。

9. 运算符：

9.1. 运算符的种类：

Ø 算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三元运算符；

9.2. 算术运算符：

Ø 算术运算符注意的问题：
  ① 如果负数取模，可以把模数负号忽略不计，如5 % -2 = 1；但被模数是负数另当别论，如 -5 % -2 = -1，即被模数是负数，结果就是负数；
  ② 除号“/”，整数除和小数除是有区别的，整数间做除法，只保留整数部分，舍弃小数部分，如5 / 2 = 2,而不是2.5，小数就按正常数学中的一样；
  ③“+”号，有正号，加号，除此之外，还有字符串相加的功能，如”he” + “llo” = hello;除此之外，还能把非字符串转换成字符串，如：
  “5 + 5 = ” + 5 + 5，这里的结果是5 + 5 =55，而不是 5 + 5 = 10；

9.3. 赋值运算符：

Ø “=”号可以多个连用，例如x = y = z = 1；“+=” a += 5相当于a = a + 5；但是不能写成 5 += a, 原因是常量不能被赋值;

Ø byte i = 5, i = i + 5, 这个编译失败,提示损失精度, byte i = 5; i += 5;这个没问题, 至于原因, 用反编译器查看, 其实这种写法, 编译器会把byte i = 5 改成 int i = 5;

9.4. 关于运算符的一个面试题：

Ø 以下代码正确的是? (多选) a, c

a. byte b = 1 + 1;

b. byte b = 1;b = b + 1;

c. byte b = 1;b += 1;

d. byte b = 1;b = ++b;

9.5. 转义字符：

Ø 转义字符：通过 “ \ ” 来转变后面后面字母或者符号的含义，如：

\n:换行；

\b：退格，相当于backspace。

\r：按下回车键。windows系统，回车符是由连个字符来表示\r\n;

\t:制表符，相当于tab键。

Ø 如果要打印“Hello World”，应该是Sytem.out.println(“\”Hello World\””); 而不是Sytem.out.println（“”Hello World””);

9.6. 逻辑运算符：

Ø 逻辑运算符用于连接boolean型表达式，返回值结果也是boolean型的，在java中，3 < x < 6 这种写法是错误的，应该写成 x > 3 & x < 6;

① “&”运算符，当两边的boolean表达式结果都位true，结果才为true，如果有一边false，那么结果就是false；&运算符还可以做位运算符，&&不可以；

② “|”运算符，有一边的结果为true，结果为true，只有两边都位false，结果才位false；| 运算符还可以做位运算符，|| 也不可以；

③ “^”运算符，两边都相同（结果都为true或false），结果为false，两边不相同，结果为true；也可以做位运算符；

④ “！”运算符，取反， !true结果是false， !false结果是true；

⑥ “&&”运算符，和“&”结果相同，具有短路效果，如果前面是false，结果一定是false，不运算后面；

⑦ “||”运算符，和“|”结果相同，具有短路效果，如果前面是true，结果一定是true，不运算后面。

9.7. 位运算符：

Ø 任何信息在计算机中都是以二进制的形式保存的，&、|、^除了可以作为逻辑运算符，也可以做为位算符。它们对两个操作数中的每一个二进制位都进行运算，0当做false，1当做true。

① & 将两个二进制数每一位进行与运算，两边都为1结果才为1，只要有一边是0，结果就为0。

② | 将两个二进制数每一位进行或运算，两边都为0结果才为0，只要有一边是1，结果就为1。

③ ^ 将两个二进制数每一位进行异或运算，只要两边不同结果就为1，相同则为0。注意，一个数异或另一个数两次，结果还是这个数本身，如5 ^ 3 ^ 3 = 5;

④<< 左移将二进制的每一位向左移，低位补0。左移几位就相当于乘以2的几次方。

⑤>> 右移将二进制的每一位向右移，原来高位是0就补0，原来高位是1就补1。右移几位就相当于除以2的几次方。

⑥>>> 无无符号右移将二进制的每一位向右移，高位补0。正数移动没区别，负数移动后变为正数。

⑦~ 反码一个二进制数取反，如~6 = -7，因为6的二进制数取反加1是 -1，所以6的反码是 -1.

Ø 练习一：最有效率的方式算出2乘以8等于几？2<<3;

Ø 练习二：对两个整数变量的值进行互换(不需要第三方变量)，代码如下：

int a = 5;

int b = 3;

a = a ^ b;

b = a ^ b;

a = a ^ b;

System.out.println(a);//a的结果是3

System.out.println(b);//b的结果是5

9.8. 运算符的优先级及习题：

Ø 运算符习题：

System.out.println(1 + 2 * 3); //7

System.out.println(false && true || true); //true

System.out.println(true || true && false);//true

int a = 2;

int b = a + 3 * a++;

System.out.println(b);//8

int a = 2;

int b = 3 * a++ + a;

System.out.println(b);//9

int a = 2;

int b = a++ + 3 * a;

System.out.println(b);//11

int a = 2;

int b = ++a + 3 * a;

System.out.println(b);//12

int a = 1;

int b = 2;

System.out.println(a++ + b);//3

System.out.println(a + ++b);//4

Ø 尽量写简单的表达式，遇到运算符优先级的问题使用括号解决。

Ø += 运算符练习的特点: 如下代码:

class Demo {
	public static void main(String[] args) {
		int a = 1, b = 10, c = 100, d = 1000;
		// 这种情况只要从右往左算就好了
		a += b += c += d;
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
	}
}

9.9. 用&及>>>运算符求60的16进制：

/*
求60的16进制：
			1, 60的二进制是： 0000-0000 0000-0000 0000-0000 0011-1100；

			2, 4个二进制位是一个16进制位，所以可以通过&15（因为15的二进制是1111）运算来获取，如下：
			     0000-0000 0000-0000 0000-0000 0011-1100
			&   0000-0000 0000-0000 0000-0000 0000-1111
		结果：         0000-0000 0000-0000 0000-0000 0000-1100

			3，发现1100转换成10进制是12，那么12在16进制中是C，怎么转换成C呢？
			A   B	C	D	E	F
对应10进制：		10  11	12       13	14	15
对应ASCII码：	           65  66	67	68	69	70
				所以，可以这样来求 （char）（12-10）+ A；
				因为12-10 + A = 67，刚好对应C。

			4，接着右移4位，得到一个数，这个数用变量temp来接受，然后再&15，获取下一个4位

*/
public class Demo {
	public static void main(String[] args) {

		int a = 60;

		//获取第一个4位2进制数
		System.out.println((char)((a & 15 )- 10 + 'A'));

		//获取下一个4位数，结果是3，所以就不用上面的方法来转换了。
		int temp = a >> 4;
		System.out.println(temp);

		//因为是从左往右，所以最后转换的结果应该倒过来，这样就求出了60的16进制
		System.out.println(temp + "" + (char)(((a &15) - 10) + 'A'));

	}
}

9.10. 三元运算符：

Ø 语法：表达式 ? 结果1 : 结果2 ；

如果表达式结果为true，取结果1；表达式结果为false，取结果2；

Ø 用三元运算符求两个数中较大的哪一个：

int a = 3, b = 5, c;

c = a < b ? b : a;

9.11. 练习:

Ø 判断下列代码打印结果:

public class Demo {
	public static void main(String[] args) {
		int sum = 0;
		for (int i = 10, j = ++i; i < j; i -= 2, j += 2) {
			sum = i + j;
		}
		// 打印结果为0, 因为 j = ++i 这句代码执行后, i的值也变成了11
		System.out.println(sum);
	}
}

public class Demo {
	public static void main(String[] args) {
		int sum = 0;
		int a = 0;
		int b = 0;

		for (int i = 10, j = ++i; i <= j; i -= 2, j += 2) {
			a = i;
			b = j;
			sum = i + j;
			// System.out.println("a");
		}
		// 这个代码打印结果是22, 咋一看的时候,是死循环, 其实不然, 只要循环里面没有输出语句, 那么就不会死循环
		// 原因分析,因为int的范围是-2147483648~~2147483647, 根据打印i 和 j 的值发现,
		// i=-2147483625,j=2147483647 ,那么这个时候j的值已经达到int型最大了, 所以程序会停止
		// 那么 i + j, 这个时候就是22, 对于这种题,  其实sum的最终结果就是 i的第一次值和j的第一次值的和
		System.out.println("i=" + a + "," + "j=" + b + "," + sum);
	}
}

10. 程序流程控制语句：

10.1. 表达式的概念:

Ø 把变量或常量用运算符连接起来的式子就是表达式;

Ø 用算术运算符连接起来的式子叫算术表达式;

Ø 用赋值运算符连接起来的式子叫赋值表达式;

10.2. 判断结构：

Ø if语句的三种格式：

① if(条件表达式) {

执行语句；

}

② if(条件表达式) {
　　执行语句；
　　} else {
　　执行语句；
　　}

③ if(条件表达式) {

执行语句；

} else if(条件表达式) {

执行语句；

}

……

else {

执行语句；

}

Ø 上述第②中格式可以简写成三元运算符变量 = 条件表达式？表达式1 ：表达式2；

好处：可以简化if else代码；

弊端：因为是一个运算符，所以必须是赋值操作,不能能是输出语句;

注意事项：if语句可以独立存在，else语句不允许独立存在，必须跟随if，if语句的任何一种格式都是一个整体，是一条完整的语句，所以上述第3种格式，当第一个else if 条件满足时，即使后面的条件表达式也不会执行，如下：

class Demo {
	public static void main(String[] args) {
		int a = 3;
		if(a > 1) {
			System.out.println("a大于1");//只会执行这句代码
		} else if (a > 2){
			System.out.println("a大于2");//这句条件表达式为true，也不执行。
		} else {
			System.out.println("a等于3");
		}
	}	
}

Ø if else语句练习小程序春夏秋冬:

　　/*
　　	if else 结构练习春夏秋冬；
　　	1，春季是3到5月份，夏季是6到8月份，秋季是9到11月份，冬季是12月，1月，2月。
　　	2，小于1，大于12的月份不存在
　　*/
　　class Demo {
　　	public static void main(String[] args) {
　　		int quarter = 18;
　　		if(quarter < 1 || quarter >12) {
　　			System.out.println("不存在这样的季节");
　　		} else if (quarter >= 3 && quarter <= 5) {
　　			System.out.println(quarter + "月是春季");
　　		} else if (quarter >= 6 && quarter <= 8) {
　　			System.out.println(quarter + "月是夏季");
　　		} else if (quarter >= 9 && quarter <= 11 ) {
　　			System.out.println(quarter + "月是秋季");
　　		} else {
　　				System.out.println(quarter + "月是冬季");
　　			}	
　　	}	
　　}

10.3. 判断语句与局部变量使用注意事项:

class Demo {
	public static void main(String[] args) {
		int max = getMax(5,5);
		System.out.println(max);
	}
	
	public static int getMax(int a, int b) {
		//if...else 语句, 局部变量可以不用先赋值
		int max;
		if(a < b) {
			max = b;
		} else {//这里为什么可以, 因为else没有判断,加入前面不满足, 这句代码一定会执行,所以不会报错
			max = a;
		}
		return max;
		
		/*
		//if...else if语句,局部变量必须马上赋值,否则报错
		int max;
		if(a <= b) {//这里是判断,很有可能不执行
			max = b;
		} else if(a > b) {//这里也是判断,也很有可能不执行,虽然我们知道会执行, 但是jvm不知道
			max = a;
		}
		return max;//如果都步执行,那么就会报错,尚未初始化变量
		*/
	}
}

10.4. 选择结构：

Ø switch语句:

switch(表达式) {

case 取值1:

执行语句;

break;

case 取值2:

执行语句;

break;

case 取值3:

执行语句;

break;

``````

default:

执行语句;

break;

}

Ø 注意事项:

① 表达式可以取的类型,byte,short,char,int及这些类型的包装类,JDK5以后可以是枚举,JDK7后可以是String;

② case与default之间没有顺序,不管default写在哪里,都是先执行第一个case,没有匹配的case执行default;

③ 结束switch的两种情况:遇到break;执行到switch语句结束;

④default后面的break可以省略,但是case后面的不可以,否则会有case穿透.

Ø 用switch语句练习春夏秋冬小程序:

　　class Demo {
　　	public static void main(String[] args) {
　　		int quarter = 5;
　　		switch(quarter) {
　　
　　			case 3:
　　			case 4:
　　			case 5:
　　				System.out.println(quarter + "月是春季");
　　				break;
　　
　　			case 6:
　　			case 7:
　　			case 8:
　　				System.out.println(quarter + "月是夏季");
　　				break;
　　
　　			case 9:
　　			case 10:
　　			case 11:
　　				System.out.println(quarter + "月是秋季");
　　				break;
　　
　　			case 12:
　　			case 1:
　　			case 2:
　　				System.out.println(quarter + "月是冬季");
　　				break;
　　
　　			default:
　　				System.out.println(quarter + "不是月份");
　　				break;//这个break可以省略
　　		}
　　	}	
　　}

Ø if和switch到底该选用哪个?

if语句和switch语句很像,很多时候两者都可以用,但是,如果判断的具体数值不多,满足switch表达式,建议使用switch语句,因为这样效率稍高,

其他情况:对区间判断,对结果为boolean类型判断,用if,if的使用范围更广.

10.5. 循环结构:

Ø while语句格式:

while(条件表达式) {

执行语句;

}

具体执行流程:先判断while条件表达式是否为true,true就执行循环体,执行后再次判断,直到条件表达式为false才结束循环;

Ø do ... while语句格式:

do {

执行语句;

} while(条件表达式);

具体执行流程:先执行一次循环体,然后判断表达式,如果是true,继续执行,如果是false,跳出循环;

Ø while与do...while的区别:do...while无论条件是否满足,都会执行一次.

Ø for循环语句格式

for(初始化表达式;循环条件表达式;循环后的操作表达式) {

执行语句;

}

for里面的表达式执行顺序:初始化表达式只读一次,判断循环条件,为true就执行循环体,然后再执行循环后的操作表达式,接着继续判断循环条件,重复这个过程,直到判断条件为false.

Ø while循环与for循环的区别:

① while循环可以和for循环进行互换,通常不知道循环次数的时候用while循环;

② for循环定义的变量在循环执行完后,便在内存中释放;而while循环在循环结束后还可以使用;

Ø 什时候使用循环结构?

当要对某些语句执行很多次,就用循环结构.

Ø for循环的一个小程序:

　　class ForDemo {
　　	public static void main(String[] args) {
　　		int i = 1;
　　		for(; i < 5 ; i++) {
　　			System.out.println(i);
　　		}
　　		System.out.println(i);
　　	}	
　　}

Ø 无限循环的最简单表达式:

for(; ; ;) {}

while(true){}

10.6. 累加思想:

Ø 原理:通过变量记录住每次变化的结果,通过循环进行累加动作;

Ø 用累加思想求1~10的和.

/*
	求1到10的和;
	1,定义一个变量,用于储存不断变化的和;
	2,定义一个被加数
	3,定义循环重复加法
*/
class Demo {
	public static void main(String[] args) {
		//定义一个变量,用于储存不断变化的和
		int sum = 0;
		//定义被加数
		int x = 1;
		while(x <= 10) {
			sum += x;
			x++;
		}
		System.out.println(sum);
	}	
}

10.7. 计数器思想:

Ø 通过一个变量记录住数据状态的变化,也需要通过循环.

Ø 通过计数器思想求1到100能被7整除的数有多少个.

　　/*
　　	求1到100 能被7整除的数的个数:
　　	1,定义一个变量,用于记录能被7整除的数的个数;
　　	2,用for循环进行遍历1到100的数,并且用遍历出来的数%7,判断是否能被7整除
　　	
　　*/
　　class Demo {
　　	public static void main(String[] args) {
　　		//定义一个变量,用于记录能被7整除的数的个数
　　		int count = 0;
　　		//定义for循环遍历
　　		for(int x = 1; x <= 100; x++) {
　　			//判断是否能被7整除
　　			if(x % 7 == 0) {
　　			//如果能被7整除,记录数据的变量就自增一次
　　				count++;
　　			}
　　		}
　　		System.out.println(count);
　　	}	
　　}

10.8. for嵌套循环及练习:

Ø 就是语句中还有语句.

Ø 用for嵌套循环打印下列图形:

***

public class Demo {
	public static void main(String[] args) {
		for(int i = 0; i < 4; i++) {
			for(int j = 0; j < 3; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}
}
规律:外循环控制行数,内循环控制列数.

Ø 用for循环打印三角形练习一:

***

****

public class Demo {
	public static void main(String[] args) {
		for (int x = 0; x < 4; x++) {
			for (int y = 0; y <= x; y++) {// 尖朝上,内循环循环条件变
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

Ø 用for循环打印三角形练习二:

****

***

class Demo {
	public static void main(String[] args) {
		for(int x = 0; x < 4; x++) {
			for(int y = x; y < 4; y++) {//尖朝下,内循环初始化条件变
				System.out.print("*");
			}
			System.out.println();
		}	
	}
}

Ø 用for循环打印三角形练习三:

* *

* * *

* * * *

class Demo {
	public static void main(String[] args) {
		for(int x = 0; x < 4; x++) {
			for(int y = x; y < 3; y++) {
				System.out.print(" ");
			}
			for(int z = 0; z <= x; z++) {
				System.out.print("* ");
			}
			System.out.println();
		}
	}	
}

Ø 用for循环,打印九九乘法表:

class Demo {
	public static void main(String[] args) {
		for(int x = 1; x <= 9; x++) {
			for(int y = 1; y <=x; y++) {
				System.out.print(y + "*" + x + "=" + x * y + "\t");
			}
			System.out.println();
		}
	}	
}

10.9. 其他流程控制语句(break,continue):

Ø break:应用范围:选择结构和循环结构;作用是结束循环.

Ø continue:应用于循环结构;结束本次循环,继续下次循环;

Ø 这两个语句离开应用范围就,存在就没有意义;

Ø 这两个语句单独存在下面不可以有语句,因为执行不到;

Ø 标号,可以让这两个语句作用于指定范围.

10.10. 水仙花数练习:

Ø 打印所有的水仙花数, 所谓水仙花数, 就是一个三位数,的各个为的立方和等于本身, 例如153;

public class Demo {
	public static void main(String[] args) {
		/*
		 * 获取各位上的数:
		 * 规律 个位 = %10; 
		 * 十位 = /10 %10; 
		 * 百位 = / 10 / 10 % 10;
		 */
		for (int i = 100; i <= 999; i++) {
			int ge = i % 10;
			int shi = i / 10 % 10;
			int bai = i / 10 / 10 % 10;
			int k = ge * ge * ge + shi * shi * shi + bai * bai * bai;
			if (i == k) {
				System.out.println(i);
			}
		}
	}
}

10.11. 练习:

Ø 有一张足够大的纸, 该纸厚0.01米, 珠穆朗玛峰搞8848米, 问不停的对着这张纸, 折多少次可以达到珠穆朗玛峰的高度;

public class Demo {
	public static void main(String[] args) {
		double i = 0.01;
		// 定义一个计数器
		int count = 0;
		while (i <= 8848) {
			i *= 2;
			count++;
		}
		System.out.println(count);
	}
}

1.1.1. 打印回数练习:

Ø 打印所有5位数的回数, 所谓回数, 就是从前往后看一样, 从后往前看一样, 例如: 10001

public class Demo {
	public static void main(String[] args) {
		for (int i = 10000; i <= 99999; i++) {
			// 获取各个位置上的数
			int ge = i % 10;
			int shi = i / 10 % 10;
			int qian = i / 10 / 10 / 10 % 10;
			int wan = i / 10 / 10 / 10 / 10 % 10;
			// 进行判断,各位和万位一样, 且十位和千位一样, 百位因为一位数, 不用比;
			if (ge == wan && shi == qian) {
				System.out.println(i);
			}
		}
	}
}