基础

一.名词解释

1JDK,JRE,JVM分别是什么?（JDK > JRE > JVM）
JDK:是Java程序开发工具包，包含JRE和开发人员使用的工具
JRE:是Java程序的运行时环境，包含JVM和运行时所需要的核心类库。
jvM:虚拟机，Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java 
程序的运行环境，是Java最具吸引力的特性之一。我们编写的Java代码，都运行在JVM上
2.简述Java语言是跨平台的一种语言
java语言可以跨平台，java语言可以通过各个系统上的java虚拟机运行java代码，说明java语言可以跨平台。
3.为什么配置环境变量
所有java文件都需要在jdk安装目录的bin去书写,比较麻烦,不好管理!进行环境变量配置后,
系统就可以找到编译和运行代码的工具在任何文件夹运行和编译.class文件和.java文件。
4.常量的分类以及分别表示对应的常量
1)字面值常量
		 字符串常量
				使用双引号括起来的内容，举例:"我爱高圆圆","JAVA_HOME","AA"
		 字符常量
				使用单引号括起来的单个内容，'0','a','A'
		 整数常量
				整数:默认十进制数据，100,65,1000
		 小数常量
				3.141592654
		 布尔常量(boolean)
				true/false
		 空常量:null
 2)自定义常量
 5.计算机由硬件和软件组成
 6.常用dos命令：
 	d:：盘符切	换盘符名称+:
 	cd：进入文件夹	cd qianfeng	进入多个文件夹：cd qianfeng\kecheng\day01\exercise
 	dir：罗列出当前文件夹下的所有文件夹及文件
 	md：新建文件夹  md+文件夹名称
 	rd：删除空文件夹
 	rd/s：是否删除非空文件夹确认
 	rd/s/q：暴力删除非空文件夹（不推荐使用）
 	del ：删除文件   del+文件名.后缀		删除多个同类型的文件：del+*后缀名
 	新建有内容的文件：copy con 文件名.后缀名
                      输入文件内容 ctrl+z结束
 	exit：退出dos命令窗口
 	cls：清屏
 7.java语言的特点：开源：开放源代码，向个人，企业，公司免费开放
 				   跨平台：	java语言可以跨平台，java语言可以通过各个系统上的java虚拟机运行java代码，说明java语言可以跨平台。
 				   可移植性：根据不同操作系统上的JVM运行java文件
 8.人机交互：方式：图形界面化：直观简单   删除文件夹/文件   新建文件夹/文件
 9.计算机语言：人与计算机之间进行交流的一种特殊语言
 10.java语言的版本：J2SE（标准版）	J2ME（小型版）	J2EE（企业版）
 11.单行注释：//	多行注释：/*  需要注释的内容  */		文档注释：/** 需要注释的文档 */
 12.关键字：被java语言赋予特殊意义的单词
 13.1.逻辑单与&和逻辑双与&&的区别?
	逻辑单与和逻辑双与:
	都表示并列关系,有false,则false
	逻辑双与&&连接的表达式:左边为false,右边就不执行了(具有短路效果)

14.比较运算符—关系运算符

>,<,>=,<=,==,!=
变量x范围: 
		数学表达式:  3<=x<=5
		Java表表达式:
					x>=3 &&(逻辑运算符) x<=5
						 || (逻辑运算符)				
比较运算符:连接的表达式无论是简单还是复杂的,最终结果要么true/false
注意事项:

	==不能写成= 

15.逻辑运算符

	基本的逻辑运算符:
			逻辑单与 &  (并列关系)
					结论:有false,则false
			逻辑单或 | (或关系:有一个满足条件就成立了)
					 结论:有true,则true
						
			逻辑异或 ^
					结论:相同则为false,不同则为true
					简单记:
						男女关系
							男男 
							女女
							男女
							女男
				
			逻辑非   !
					非true,则false
					非false,则true
					
					偶数个非,是当前结果本身!

16.位运算符

   基本的运算符号
	  位与:&
	  位或:|
	  位异或:^位异或运算符的特点:一个数据被另一个数据位异或两次,其值是它本身
		a = a ^ b ; 
		b = a ^ b ;//b = a^ b ^ b = a
		a = a ^ b ;//a = a ^ b ^ a = b
		a=b	b=a
	  ~(反码:按位取反:全部1变0,0变1):
	  左移:<<
			左移动,将最高符合位丢弃掉,在右边补齐0
			特点:将<<符号左边的数据乘以2的移动次幂
	右移:>> :
	       右移动,如果最高符号位为0,左边补0,如果最高符号位为1,左边补齐1			   
		   特点:将>>符号左边的数据除以2的移动次幂 
	无符号右移:	>>>		
			向右移动,无论最高符合位为0还是1,左边补0!
			
			2 << 3(2*2^3=16)
			2数据对应的二进制数据:原码
	00000000 00000000 00000000 00000010  (原码,反码,补码相同的)
	
	补码 :左移动3位
	
	00000000 00000000 00000000 00000010
 (000)00000 00000000 00000000 00000010 000(右边补0:少三位,补三位)   补码
	
	
	00000 00000000 00000000 00000010 000   补码(----->反码---->原码)
	
	
	16
	
	
	24 >> 2(24/2^2=6)
	//24数据的二进制数据
	00000000  00000000 00000000  00011000   (原码,反码,补码都相同)
	
	补码: 右移动2位
	
	00000000  00000000 00000000  00011000
	  0000000000  00000000 00000000  000110(00)
	  
	  
	 移动后的补码:
	 0000000000  00000000 00000000  000110  (补--->反---原)
	 
	 6
	 
	 	 
1	      1 			1 		1		 1 		1		 1 		1		 1 
128*2	  128             64    32       16      8      4       2        1



-24 >> 2(-24/2*4=-6)
10000000  00000000 00000000  00011000    (-24的原码)
---------------------------------------------------------
11111111  11111111 11111111  11100111    (-24的反码)	
								   +1
----------------------------------------------
11111111  11111111 11111111  11101000    (-24的补码)

右移2位

11111111  11111111 11111111  11101000 
  1111111111  11111111 11111111  111010(00)   (补码)
  
  1111111111  11111111 11111111  111010		(补码)
								     -1
---------------------------------------------------------
  1111111111  11111111 11111111  111001    (反码)
  
  ---------------------------------------------
  1000000000  00000000 00000000  000110   (原码)
  
  -									6
  
  
  
- 24 >>>2
 
10000000  00000000 00000000  00011000    (-24的原码)
---------------------------------------------------------
11111111  11111111 11111111  11100111    (-24的反码)	
								   +1
----------------------------------------------
11111111  11111111 11111111  11101000    (-24的补码)
	
	
	
	11111111  11111111 11111111  11101000
	  0011111111  11111111 11111111  111010(00) (补码----反码---原码)
		
		
	十进制的结果:	1,073,741,818

17.三目运算符

单目: int a  = 5 ;
二目:  两个变量进行比较  x == y
三元运算符---三目运算符
格式
	(表达式) ? 执行true的结果:执行false的结果
	表达式:可以是简单的或者复杂的表达式------>true/false
	执行流程:
		1)先判断表达式是否成立,如果成立,执行true的结果
		2)如果不成立,执行false的结果
	一般没有要求是什么数据类型,默认int类型	

需求:
				1)求两个数据的最大值
				2)求三个数据的最大值
				3)求两个数据是否相等

	class OperatorTest{
	public static void main(String[] args){
		
		//两个变量
		int x  = 3 ;
		int y = 5 ;
		
		//接收结果
		int result = (x > y )? x : y ;
		System.out.println("这两个数据中的最大值是:"+result) ;
		System.out.println("-------------------------------") ;
		
		//求三个数据的最大值
		int a = 10 ;
		int b = 30 ;
		int c = 5 ;
		
		//使用中间变量的方式(推荐)
		//分步执行:
		//定义变量temp
		int temp = (a > b) ? a: b ;
		//在使用temp变量和c进行比较
		int max = (temp > c) ? temp : c ;
		System.out.println("这三个数据中的最大值是:"+max) ;
		System.out.println("-------------------------------") ;
		
		//方式2:一步执行
		//直接三元运算符
		int max2 = (a > b) ? ((a>c)? a: c) : ((b>c)? b: c) ;
		System.out.println("这三个数据中的最大值是:"+max2) ;
		
		System.out.println("-------------------------------") ;
		//比较两个数据是否相等
		
		int m = 10 ;
		int n = 20 ;
		//boolean  flag = (m==n)? true: false ;
		boolean flag = m==n ;
		System.out.println("flag:"+flag) ;
	}
}

二.进制转换

进制的组成规则分别是什么?
	二进制：	0，1组成			以0b开头
	八进制：	0，......7组成		以0开头
	十进制：	整数默认十进制
	十六进制：	0...9,a...f组成		以0x开头
1.将52转换成二进制,八进制,以及十六进制(十进制到任意进制转换规则)
1）规则：用十进制数字除于需要转换的进制数，得到的余数留下，用商在进行上述操作，直至商为零结束，将余数取反的到需要转换的进制数。
	十进制二进制:52%2=0 26%2=0 13%2=1 6%2=0 3%2=1 1%2=1  二进制为00110100
	十进制转八进制:  52%8=4 6%8=6   八进制为64
	十进制转十六进制:52%16=4  3%16=3	十六进制为34
2）8421码规则：在每一个位上的数据对应一个二进制数据一，每个一都代表一个十进制数据的具体值，十进制转换为二进制时，二进制数值所对应十进制数据相加等于十进制数值，则二进制对应位为1，没有则为0.
	二进制数据为一时		1		1		1		1		1		1		1		1
	对应十进制的数据		128	64	32	16	8		4		2		1
	52二进制
	1		1		1		1		1		1		1		1
	128	64	32	16	8		4		2		1
	0		0		1		1		0		1		0		0
=	0+	0+	32+	16+	0+	4+	0+	0
=52
	十进制数据相加为52，对应二进制位上的数值为：00110100
二进制转八进制的简便操作（例如：00110100）（规则：将八进制的二进制数拆分为三个为一组分别求出每组位上十进制数据之和）
	00110100	
	八进制数据三个为一组：000	110	100
											0	6		4
	00110100的八进制为：64
二进制转十六进制的简便操作（例如：00110100）（规则：将十六进制的二进制数拆分为四个为一组分别求出每组位上十进制数据之和）
	十六进制数据四个为一组：0011	0100
												3		4
	00110100的十六进制为：34

2.将0b1010101 转换成十进制（）；（x进制转换为十进制规则：x进制位上的数值*x的从右往左依次数的位数（从	零开始）次幂相加等于x进制的十进制数值）
1*2^6+0*2^5+1*2^4+0*2^3+1*2^2+0*2^1+1*2^0
=85
3.将0100转成十进制
1*8^2+0*8^1+0*8^0
=64
4.将0x2d转换成十进制
2*16^1+13*16^1
=45

三. 键盘录入

Scanner：是Java核心类: java.util.Scanenr;  (Java中只要不是java.lang包下的类都需要导包)
1、导包：格式：import.java.util.Sanner;
2、创建键盘录入对象：格式：Scanner sc = new Scanner(System.in);
3、通过对象获取数据：格式：int x = sc.nextInt();//输入是整型

​

键盘录入比较两个值的大小：

import java.util.Scanner;//导包
class HomeWork{
	public static void main(String[] args){
		Scanner number = new Scanner(System.in);//创建键盘录入对象
		System.out.println("请您输入第一个int类型的数据:");//提示输入数据
		int num1 = number.nextInt();//接收数据
		System.out.println("请您输入第二个int类型的数据:");
		int num2 = number.nextInt();
		int max = (num1>num2)?num1:num2;//三元运算符比较大小
		System.out.println("输入的两个数据的最大值为："+max);//输出结果
	}
}
	3）获取三个数中最大值
	import java.util.Scanner;
class HomeWork{
	public static void main(String[] args){
		Scanner number = new Scanner(System.in);
		System.out.println("请您输入第一个int类型的数据:");
		int num1 = number.nextInt();
		System.out.println("请您输入第二个int类型的数据:");
		int num2 = number.nextInt();
		System.out.println("请您输入第三个int类型的数据:");
		int num3 = number.nextInt();
		int temp = (num1>num2)?num1:num2;
		int max = (temp>num3)?temp:num3;
		

​	System.out.println("输入的两个数据的最大值为："+max);
}

}

四.流程控制语句

顺序结构语句 (简单）

	一旦进入main方法中(由Jvm 调用),从有效行开始依次从上往下执行!
	2)选择结构语句
				分两种:
						if语句
								三种格式
									if(表达式){}
									if(表达式){
									
									}else{
									
									}
									
									if(表达式1){
									
									}else if(表达式2){
									
									}else if(表达式3){
										....
									}else{
									
									}
									
						switch语句
									
									
		
	3)循环结构语句
			for循环(使用最多)
			while循环(其次)
			do-while循环(很少使用)

一. 顺序结构语句
```java
//顺序结构语句
class OrderDemo{
	public static void main(String[] args){
		//顺序结构语句	(简单)
		//一旦进入main方法中(由Jvm 调用),从有效行开始依次从上往下执行!
		System.out.println("程序开始了....") ;
		
		System.out.println("爱Java,爱高圆圆....") ;
		
		System.out.println("程序结束了....") ;
	}
}

二.if语句

if语句整体的注意事项:
		1)有if的地方需要有一对{}  
				有{}的地方不能分号; 
		2)在一个方法中(main() )定义一个{xxxd代码}---->局部代码块 (了解)
		作用:限定局部变量的生命周期
		局部变量:在方法定义中的变量---->随着方法的调用完毕而消失
		内存中:GC 垃圾回收器(自动回收这些对象或者变量)
if格式1)应用场景:
	针对单个业务场景进行判断

选择结构语句

if语句

if语句的第一种结构

if(表达式){
			语句;
	}
	
执行流程:
判断表达式是否成立,如果是true,成立,执行语句;
如果不成立,不执行!


if语句整体的注意事项:
		1)有if的地方需要有一对{}  
			有{}的地方不能分号;	

	import java.util.Scanner ;
	class IfDemo{
	public static void main(String[] args){
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并接收
		System.out.println("请你输入一个数据:");
		int a = sc.nextInt() ;
		
		//if格式1
		if(a >= 10){
			System.out.println("a的值大于等于10") ;
		}
		
		System.out.println("over") ;
		
	}
}

if语句的第二种结构

:

if(表达式){
	语句1;
}else{
	语句2;
}

执行流程:
1)首先判断表达式是否成立,如果是true,执行语句1
2)如果不成立,执行语句2;
需求:
键盘录入一个数据,判断这个是否是偶数!

应用场景
		针对两种情况进行判断
		
		需求: 键盘录入两个数据,求最大值!
		
				(使用if...else.../三元)

//导包
import java.util.Scanner;
class IfDemo3{
	public static void main(String[] args){
	//定义一个变量
	int x = 10 ;
	if(x >=10){
		System.out.println("x大于等于10") ;
	}else{
		System.out.println("x小于10") ;
	}
	System.out.println("over...") ;
	//创建键盘录入对象
	Scanner sc = new Scanner(System.in) ;
	//提示并接收
	System.out.println("请输入一个数据:") ;
	int num = sc.nextInt() ;
	
	if(num %2 == 0){ //%:求余: 能够被2整数,余数为0
		System.out.println(num+"是偶数!") ; 
	}else{
			System.out.println(num+"是奇数!") ; 
	}
}
}

if语句格式二的嵌套:

if(表达式){
			//表达式成立
			if(表达式1){
					语句1;
			}else{
					语句2;
			}
		}else{
			//不成立
			if(表达式11){
				语句11;
			}else{
				语句22;
			}
		}
		
流程:
首先判断外层if中表达式是否成立,
如果成立,执行表达式2是否成立
如果表达式2成立,执行语句1;否则,执行语句2;
外层if中表达式不成立,就执行else中的语句
		首先判断表达式11是否成立,如果成立,执行语句11,
		否则执行语句22;

需求:键盘录入三个数据:求三个数据最大值

import java.util.Scanner ;
	class IfTest{

	public static void main(String[] args){
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		//提示,并接收数据
		System.out.println("请输入第一个数据:");
		int a = sc.nextInt() ;
		System.out.println("请输入第一个数据:");
		int b = sc.nextInt() ;
		System.out.println("请输入第一个数据:");
		int c = sc.nextInt() ;
	int max3 ;
		if( a > b){
			//a>b成立
			if(a > c){
					//a比c大
				max3 = a ;	
			}else{
				//c比a大
				max3 = c ;
			}
		}else{
			//不成立
			if(b > c){
				//b比c大
				max3 = b ;
			}else{
				//c比b大
				max3 = c ;
			}
		}
		System.out.println("三个数据中的最大值是:"+max3) ;
	}
	}

if语句的第三种结构:

	if(表达式1){
		语句1;
	}else if(表达式2){
		语句2;
	...
	...
	...
	}else{
		语句n+1 ;
	}
	
执行流程:
1)首先判断表达式1是否成立,如果成立,执行语句1,if语句结束!
2)如果表达式1不成立,再次判断表达式2是否成立,如果成立,执行语句2,语句结束!
3)如果上述表达式都不成立,就执行else中的语句,if语句结束!
应用场景:
针对多种情况进行判断

90~100    突出
			80~90之间 优秀
			70~80之间  良好
			60~70     及格
			60以下    不及格
	//导包
	import java.util.Scanner ;
	class IfDemo4{
		public static void main(String[] args){
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示,并接收数据
		System.out.println("请您录入学生的成绩: ") ;
		int score = sc.nextInt() ;
		if(score >= 90 && score <=100){
			System.out.println("该学生成绩十分突出...") ;
		}else if(score >=80 && score< 90){
			System.out.println("该学生成绩优秀...") ;
		}else if(score >= 70 && score <80){
			System.out.println("该学生成绩良好...") ;
		}else if(score >= 60 && score <70){
			System.out.println("该学生成绩及格...") ;
		}else{
			System.out.println("该学生成绩不及格...") ;
		}
		
		/*
			写好一个程序:自己测试
			测试错误数据,正确数据以及边界数据
			目的:让程序更符合真实场景,保证用户的体验!
		*/
		if(score >100 || score < 0){
			System.out.println("您录入的是一个非法数据...") ;
		}else if(score >= 90 && score <=100){
			System.out.println("该学生成绩十分突出...") ;
		}else if(score >=80 && score< 90){
			System.out.println("该学生成绩优秀...") ;
		}else if(score >= 70 && score <80){
			System.out.println("该学生成绩良好...") ;
		}else if(score >= 60 && score <70){
			System.out.println("该学生成绩及格...") ;
		}else{
			System.out.println("该学生成绩不及格...") ;
		}
		
		
	}
}

使用if...else...嵌套比较三个键盘录入数据的最大值

import java.util.Scanner;
class HomeWork{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("输入第一个数据:");
int a = sc.nextInt();
System.out.println("输入第二个数据:");
int b = sc.nextInt();
System.out.println("输入第三个数据:");
int c = sc.nextInt();
if(a>b){
	if(a>c){
	System.out.println("三个数据最大值为:"+a);
	}else{
	System.out.println("三个数据最大值为:"+c);
	}
}else{
	if(b>c){
	System.out.println("三个数据最大值为:"+b);
	}else{
	System.out.println("三个数据最大值为:"+c);
	}
	}
}
}

switch语句的格式

switch(表达式){


	case 值1:
			语句1;
			break ;
	case 值2:
			语句2;
			break ;
			
	...
	...
	default:
			语句n;
			break ;
	

}

执行流程:
	1)先判断表达式的值它和case语句值1,是否匹配
		如果匹配,执行语句1,遇见break ,switch语句结束了!
	2)如果值1不匹配,继续判断值2是否和表达式中的值是否匹配,如果匹配,执行语句2
			遇见break,switch语句结束!
	3)如果上面的所有case语句都不匹配,执行default语句,执行语句n,直接结束

面试题:
	switch表达式可以是byte类型吗?
	可以是String类型吗?
	可以是char类型吗?
	可以是枚举类型吗?
	答案：
	switch(表达式)---->本身可以使用的类型:byte,short,char,int类型
	JDK5以后可以枚举enum(引用类型--->定义常量)  后面讲(Java高级部分多线程Thread类: State(枚举类型))
	JDK7以后:可以使用String类型

键盘录入一个数据,判断星期 (使用switc语句完成)

需求:
 键盘录入一个数据,判断星期 (使用switc语句完成)

		1,星期一
		2,星期二
		3,星期三
		4,星期四
		5,星期五
		6,星期六
		7,星期天

	import java.util.Scanner;
	class SwitchDemo{
	public static void main(String[] args){
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并接收数据
		System.out.println("请您输入一个数据:") ;
		int weekDate = sc.nextInt() ;
		
		switch(weekDate){
		case 1:
			System.out.println("星期一") ;
			break ;
		case 2:
			System.out.println("星期二") ;
			break ;
		case 3:
			System.out.println("星期三") ;
			break ;
		case 4:
			System.out.println("星期四") ;
			break ;
		case 5:
			System.out.println("星期五") ;
			break ;
		case 6:
			System.out.println("星期六") ;
			break ;
		case 7:
			System.out.println("星期天") ;
			break ;
		default : //末尾
			System.out.println("非法数据!!") ;
			break ;
			
		}
	}
}

看程序,写结果（switch语句一些运算）

```java
class SwitchTest{
		public static void main(String[] args){
		
		
		//两个变量
		int a = 2 ;
		int b = 3 ;
		switch(a){//寻找case a=2,如果有执行以下代码，
					//直至遇见break;结束语句，如果没有寻找default;直至遇见break;结束语句
		default :
			b ++ ;   //b=3     --> 4 
			break ; //遇见break:switch语句
		case 3:
			b ++ ;
		case 4: 
			b ++ ;
		}
		System.out.println("b:"+b) ;
		//b=4

//两个变量
		int x = 2 ;
		int y = 3 ;
		switch(x){//寻找case x=2,如果有执行以下代码，直至遇见break;结束语句，如果没有；
					//寻找default;直至遇见break;结束语句,没有break;则一直执行，直至代码结束
		default :
			y++ ; //y=3 ++ ===>4
		case 3:
			y ++ ; //4 +1===>5
		case 4: 
			y ++ ;//5+1 ===>6
		}
		System.out.println("y:"+y) ;
		//y=6

		int m = 2 ;
		int n = 3 ;
		switch(m){//m=2//寻找case m=2,如果有执行以下代码，直至遇见break;结束语句，如果没有；
					//寻找default;直至遇见break;结束语句,没有break;则一直执行，直至代码结束
		default :
			n++ ; 
		case 2:
			n ++ ; 	//n++ --->4
			//break ;
		case 4: 
			n ++ ; //n++--->4+1 = 5
		}
		
		System.out.println("n:"+n) ; 
	}
}
		//n=4

使用switch语句，键盘录入学生成绩，判断学生等级：

使用switch语句，键盘录入学生成绩，判断学生等级：
		90-100  A
		80-90   B
		70-80   C
		60-70   D
		60以下  E

import java.util.Scanner;
	class HomeWork{
	public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
	System.out.println("输入你的成绩判断等级:");
	int score = sc.nextInt();	
	if(score>100||score<0){
	
	System.out.println("非法字符!");
	}else{
	int dj = score/10;
	switch(dj){
	case 10:
	case 9:
		System.out.println("A等");
	break;
	case 8:
		System.out.println("B等");
	break;
	case 7:
		System.out.println("C等");
	break;
	case 6:
		System.out.println("D等");
	break;
	case 5:
	case 4:
	case 3:
	case 2:
	case 1:
	case 0:
		System.out.println("E等");
	break;
	}
	}
	}
}

循环结构

for循环

for循环格式
	for(初始化语句;条件表达式;步长语句){
		  循环体语句;
	}
	
	
执行流程:
1)初始化语句给变量进行赋值,只执行一次
2)判断这个条件表达式是否成立,
	如果成立,就执行循环体语句,在去执行步长语句 (++,--)
3)再次判断条件表达式是否成立,如果成立,继续上面执行方式...
4)一直循环到条件表达式不成立的时候,for循环结束!
需求:

请求在控制台输出10次 "helloworld"(明确循环次数了)

	class ForDemo{
	public static void main(String[] args){	
	//  初始化语句    条件表达式      步长语句(控制体语句)
	for(int x = 1 ;   x <= 10 ;  x ++){ //x = 1  1 <=10    x++ :1++ = 2
														//x=2 <=10 
														//x=3 <=10
														//...
														//x = 10  x++ = 11 <= 10(不成立)
		
			//循环体语句
			System.out.println("helloworld") ;//1次 //第二次 第三次........第十次									
		}
	}
}
//先执行初始化语句，然后执行条件表达式，条件表达式满足后执行步长语句，执行X++，依次循环以上操作，直至条件表达式不满足，结束语句

while循环

class SwitchTest {
public static void main(String[] args) {
	int  a = 1;
	int sum = 0;
	while(a<=100){
		if(a%2==0){
		sum = sum + a;
		}	
	a ++;
	}
	System.out.println("sum="+sum);		
}
}