Java基础

Java中的注释:提高代码阅读性, 解释说明程序!
多行注释 /星星/
单行注释 //
文档注释:/星星 文档注释 星/ 后期:jdk安装目录bin目录:javadoc.exe: 解析文档注释的指令.
被Java语言赋予特定含义的单词
关键字的字母都是小写!

在notepad++/editpuls:高级记事本
针对Java代码的关键字有一种"颜色标记"
1)Java中最基本的单元"类"
书写格式:class 类名{}
class KeyWord{} 表示:定义一个了KeyWord这个类
2)public: 公共的,公开的: 权限很大

	权限修饰符 :(面向对象部分讲解)
		public :现在目前先使用这个
		private:私有的 
		默认修饰符
		protected:受保护的

3)static:静态修饰符
(面向对象部分讲解): 被静态修饰的—“共享,共用”
跟类的加载机制有关系
4)void : 格式是和Java中方法的定义相关 (本周讲解决"方法"时候讲)

5)数据类型
基本数据类型:都是关键字
6)流程控制语句中: 选择结构,循环结构等存在关键字
标识符:
在Java语言中,给类,给接口,给变量,给方法起名字的字符序列!

起名字("见名知意")的时候,字符序列的组成规则:
	1)26个英文字母(大小写均可)
	2)可以是数字字符
	3)可以是$符号		
	4)可以是下划线_
	
	
给类和接口起名字一致:
		如果是单个单词: 单词首字母大写,其余小写
				举例:jdk提供的这些类:  class Socket{}
					   class Demo{}
					   
		如果是多个单词:遵循 "大驼峰命名法"
							每个单词首字母都大写,其余小写
						
				
				举例:class MakeNameDemo{}
				
				
包:package(关键字)	:  "面向对象后面讲解"
		实际开发中:通过 "包(目录)" 要进行代码的分层概念(真实项目开发中)
				
给变量和方法起名字符序列一致:
		如果是单个单词: 单词全部小写
					举例:   
							int num = 10 ; 

		如果是多个单词:遵循"小驼峰命名法"
							第一个单词全部小写,从第二个单词开始:每个单词首字母大写;
							int applePrice = 5 ; 
							
给常量命名 :(Java源码:一般都是多个单词)
		如果是单个单词: 字母全部大写 
					   AGE    
		如果是多个单词:每个单词字母全部大写,中间使用下划线隔开
				
				举例
						Java常用类:Integer:int类型的包装类类型
							MIN_VALUE:最大值
							MAX_VALUE:最小值
							
						JavaSE高级部分:多线程 Thread
							优先级的常量字段:
								字段摘要 
								MAX_PRIORITY 
								线程可以具有的最高优先级。 
								MIN_PRIORITY :最低优先级
								NORM_PRIORITY:默认优先级



	注意事项:
			1)标识符组成可以是数字,但是不能以"数字开头"
			2)标识符不能是Java中的关键字
			3)Java严格区分大小写(Java语言是一种"强类型":语法结构非常严谨)

常量:
程序在执行过程中,其值是固定不发生改变的量!

  分类:
	1)字面值常量
			a)字符串常量 :	"hello"  双引号包含起来
			b)字符常量 : 'a','A','0' 单引号包含起来的内容
					不参与运算:它就是固定的字符(键盘上的按键---字符)
					
					会存在ASCII码表
							当字符'a',参与运算:就需要找ASCII码表的值: 97(小写字母字符)
							'A':65(大写字母字符),'B':66 'C' :67
							'0':48(数字字符),'1':49...
					
			
			c)整数常量: 100,50 	
						34   (整数--- 默认:十进制)
						
								进制:也是常理
										二进制
										八进制
										十进制:默认整数
										十六进制
						
			d)小数常量:	
					3.14
					5.125
			e)布尔常量:true/false
			f):null:空常量   应用在"引用数据类型"	的默认值	
	
	2)自定义常量: 面向对象部分讲:  跟 关键字final有关系
	什么是进制
数据进位一种方式



二进制,逢二进1,由0,1组成 ,以"0b"开头
八进制,逢八进1,由,0,1,2,3,4,5,6,7组成 ,以"0"开头
十六进制,逢十六进1,由0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,以"0x"开头
十进制:逢十进1, 整数默认

单位换算
		1byte = 8bit (8个比特位:8个电信号 ) :最基本二进制数据
		1kb = 1024 byte
		1m  = 1024 kb
		1g  = 1024m 
		1t  = 1024g
		在程序的执行过程中,其值发生改变的量!
变量的三要素
	1)数据类型 ----- "一种限定"
	2)变量名称 -----  "符合 标识符的规则"
	3)初始化值 ----- 根据数据类型,给变量名称赋值!
	
	格式1:定义并且初始化
			数据类型 变量名称  =  初始化值;
				int    num     =  10 ;    (分号在Java语言中,表示当前行语句结束!)
			
	格式2:先定义,在使用之前必须初始化
			数据类型  变量名称  ;	
				int num2 ;
				num2 =  10 ;
			变量名称 = 初始化值;	(使用这个变量之前,必须赋值; )
			
			
			
Java中的数据类型的划分:
		基本数据类型:(第一周:研究的基本数据类型)
		四类八种:一些变量,没有提示使用什么类型,默认int(根据具体需求)
				
			整数类型
					byte	字节类型			使用范围:-128~127		占用1个字节
					short	短整型										占2个字节
					int     整数默认类型		(-2^31 - 2^31-1)						占4个字节
					long	长整型		(定义系统时间---换算毫秒值)								占8个字节
							注意事项:定义long类型,需要在初始化值的后面加上一个标记(L/l)
			浮点类型:默认double
					float	单精度										占4个字节
					
							注意事项:需要定义的float 需要在值的后面加标记:F/f
					double	双精度(默认类型) 场景:商品价格				占8个字节
			字符类型	
					char   字符											占2个字节
					
			布尔类型(不会进行类型转换:仅仅只是表示逻辑判断! 结果不是true/false)
					boolean												占1个字节
		
		
		引用数据类型:(以后研究:引用类型)
					数组(基本类型,引用类型),类(具体类,抽象类),接口
					int[] arr 
					String[] args定义变量的注意事项:
	1)目前来说:我们定义 "局部变量"
		在方法定义中或者方法声明上的变量
	2)
		a)先定义,在使用前去赋值
				如果没有报错,系统 "可能尚未初始化变量"
		b)直接给变量初始化
		
	3)Java是强类型语言:							javascript(js):
			不能够将一个变量定义多次				若类型语言:一个变量重复定义的
		
	4)定义变量: 推荐格式: 一行定义一个变量 
						 也可以一行定义多个变量
						 	
	基本数据类型 除了 boolean,不参与运算!
变量在进行运算的时候,需要保证数据类型一致!
Java中的隐式类型转换 :默认类型提升
		byte,short,char三者之间不转换,一旦参与运算,先转换为int类型!
 

int a  = 3 ;
byte b = 4 ;

int c = a + b ;



int a  = 3 ;
byte b = 4 ;

byte c = a + b ; //报错: 结果为int值,但是接收byte类型


Java中的强制类型转换

目标数据类型(目前使用基本类型) 变量名称 = (目标数据类型)(初始化值);

			byte c = (byte)(a + b) ;
			*
面试题:
	定义三个变量
	byte b , b1 = 3 , b2 = 4 ;
	1)b = b1 + b2 ;
	2)b = 3 + 4;
	
	1)和2)哪句会编译失败!
	
	1)属于变量相加,需要考虑数据类型问题, 默认类型提升
	byte,char,short,三者不转换,一旦参与运算,优先提升int
	解决方案:
			强制类型转换(显示转换)
			目标类型 变量名 = (目标类型)(初始化值);
		
	2)正常编译通过:
		b = 3 + 4 ; 常量相加,---先相加,然后看其结果是否在byte类型的范围内
		byte :-128 ~127      b = 7 

*/
class DataTypeDemo4{
public static void main(String[] args){
byte b , b1 = 3 , b2 = 4 ;
//b = b1 + b2 ; //不兼容的类型: 从int转换到byte可能会有损失
//b = (byte)(b1+b2) ;

		b = 3 + 4 ;
		System.out.println(b) ;
}

}

• :
  作用:
  1)算术运算符 :加法运算
  2)表示一个数据:正数 +7
  3)字符串的拼接符号

    	//字符串 (String:非常重要的类)
    	//网页的数据:--"表单提交"的数据---->String类型
    	//网页中地址栏 :http://ip地址/login?username=xx  String类型
    	运算符:
      变量在程序的运行中使用的一些符号!
      
     算术运算符:
     
    		基本的算术运算符
    				+,-,*,/(默认取整),%(取余数)
    				
    		扩展的算术运算符:
    				++,--    场景:统计 / 循环语句中使用
    				举例:
    				水仙花:三位数 范围:100-999     
    							个位的立方+十位的立方 + 百位的立方 = 数据本身
    							153
    				
     赋值运算符
     关系(比较)运算符
     逻辑运算符
     位运算
     三元(三目)运算符
  

扩展的算术运算符:
++,-- 场景:统计 / 循环语句中使用

	结论:
		单独使用++/--:无论数据前还是后,都是自增1或者自减1
		
		
		参与运算:
			参与运算使用:++/--数据的后面:先进行运算,然后自增或者自减1!
			参与运算使用:++/--数据的前面:先进自增1或者自减1,然后参与运算!

---

		int a = 3 ;

		(--a) << 2
			2 << 2		= 8

欢迎使用Markdown编辑器

赋值运算符:
最基本的赋值运算符
=
将=右边的数据赋值左边的变量

		int x = 10 ;
		将10这个数据赋值给int类型的变量x
		
	注意:=不能写成==(比较运算符)
	
扩展的赋值运算符:
		+=,-=,*=,/=,%=
		
		int y = 20 ;
		y += 30 ;     	--- 类似于 :y = y + 30 ;
		将+=右边的数据和左边的数据相加,在将结果赋值给左边的变量y
		

面试题:
		short s = 1 ;
		1)s = s + 1 ;
		2)s +=1 ; 
		哪一句代码编译失败,如何解决;哪一行代码编译成功,说明原因!
		
		考点: 扩展的赋值运算的特点
				+=,-=,*=,/=,%= :存在特点 :隐藏了强制类型转换
				s += 1 ;  <==>等价于 s = (short)(s+1) ;		
				比较运算符(关系)
	
	<,<=,,>,>=,==,!=
	
	数学表达式:
			3<=x<=5 


	计算机语言:
			Java语言
					int x  ;
					x >= 3 &&(逻辑符号) x <= 5
					
					3<=x<=5 (报错:不是语句!)


比较运算符连接的表达式:不管简单的还是复杂的表达式:结果都是true/false	

逻辑符号:
基本的逻辑运算符
			逻辑单与&:  并列关系 
				特点:有false,则false!
			逻辑单或|: :满足一个即可
				特点: 有true,则true
			逻辑异或^:
				 特点:相同则为false,不同则为true
				 简单记:男女关系
					男女,女男  : true
					女女,男男  : false
			逻辑非!:
				非true,则false;非false,则true;偶数给非是它本身!
				应用场景:
						
			
			
扩展的逻辑运算符
			逻辑双与&&:
			逻辑双或||:
			
逻辑非!:
				非true,则false;非false,则true;偶数给非是它本身!
				应用场景:
						在登录的时候,如果用户名和密码不一致,提示"登录失败"
						
需求:
	已知 用户名"admin" :字符串  
	键盘录入数据,判断录入的数据和已知的数据一致,如果一致,提示"登录成功!"
	,不一致,提示"登录失败" ;
	
	
	

	键盘录入数据的操作步骤: java.util.Scanner; (文本扫描器)
		1)导包:以后在Java语言中:
				只要不是java.lang.*包下的类,都需要导包
			书写位置:在class上面	
			import java.util.Scanner;
				
		2)创建文本扫描器对象:
				Scanner 对象名  = new Scanner(System.in) ;
		3)提示用户,并接收数据  (回车---告诉jvm "录入完毕")
				System.out.println("请您输入一个数据:") ;
				int 变量名 =  对象名.nextInt() ;
				
		4)使用这个变量		
		mport java.util.Scanner ;

class OperatorTest110{
public static void main(String[] args){
//创建文本扫描器对象:
/*
Scanner sc = new Scanner(System.in) ;

	//3)提示用户,并接收数据
	System.out.println("请您输入一个数据:") ;
	int num = sc.nextInt() ;
	
	System.out.println("您输入的是:"+num) ;
	*/
	
	
	//模拟登录操作
	//已经有一个用户名
	String username = "admin" ;  //admin
	
	//创建文本扫描器对象
	Scanner sc  = new Scanner(System.in) ;
	
	//键盘录入:处理char不能直接,其他都可以:
	//String录入的:String  nextLine() 
	System.out.println("请输入用户名:") ;
	String name = sc.nextLine() ; //录入字符串数据
	
	//判断:----- 流程控制语句 之 if: if...else
	//String类的有很多功能: equals(字符串)
	if(!username.equals(name)){ //已经存在的用户名如果录入的数据不匹配
		System.out.println("对不起,用户名不正确!")
		;
	}else{
		System.out.println("恭喜您,登录成功了!") ;
	}
	
}

}

扩展的逻辑运算符:
	&&(逻辑双与),||(逻辑双或)

面试题:
逻辑双与&&和逻辑单与&

共同点:当多个条件,有一个不满足,就不成立! 并列关系
		有false,则false
		
		
逻辑单与&:无论符号左边的表达式是true还是false,右边都需要执行!	
逻辑双与&&: 
			具有短路效果!
			如果符号左边的表达式为false,则右边的表达式不会执行了!
			逻辑性比单与&更强一些,开发经常使用逻辑双&& !
			
	
逻辑双或||: 
			左边的表达式如果为true,右边不执行!
	
	位运算符:
		针对具体的数据值进行运算!
		
	位与&:
			有0,则0
    位或|:	
			有1,则1
	位异或^:
			相同则为0,不同则为1
	~反码  :对一个数据进行反码:按位取反(全部0变1,1变0)

*/位运算之位移符号(了解)

Java源码中会有这些位移符号
				

<<:左移
		将数据的补码进行左移动,右边不够的补0,左边多余丢弃掉
		
		特点:将 <<符号左边的数据乘以2的移动次幂
		
		面试题:
			请用有效的数据方式写出2 * 8的结果 16 
			
			2 << 3        2 * 2 ^3 
		
>>:右移 
		将数据的补码右移动;如果最高符号位为0,左边补0;如果最高符号位为1,左边补1...

			特点:
					将>>符号左边的数据 除以2的移动次幂
					
>>>:无符号右移
		将数据的补码右移动,无论最高符号位为0还是1,左边都补0...
		位异或的特点^: 一个数据被另一个数据位异或两次:其值是它本身!
		import java.util.Scanner ;

class OperatorDemo3{
public static void main(String[] args){

	//定义两个变量
	int x = 4 ;
	int y = 10 ;
	
	System.out.println(x ^ y ^ y) ; 
	
	
	System.out.println("-----------------------------") ;
	
	
	//需求:键盘录入两个数据,实现数据的交换
	//2)创建文本扫描器对象
	Scanner sc = new Scanner(System.in) ;
	
	//提示并录入数据
	System.out.println("请您输入第一个数据:") ;
	int num1 = sc.nextInt() ;
	

	System.out.println("请您输入第二个数据:") ;
	int num2 = sc.nextInt() ;
	System.out.println("数据交换前:") ;
	System.out.println("num1:"+num1+",num2:"+num2) ;
	System.out.println("---------------------------") ;
	
	//方式1:使用中间变量的方式 (开发中经常用到)
	//定义一个中间变量:temp 
	/*
	int temp = num1 ; //temp记录num1的值
	num1 = num2 ; //num2的值赋值给num1
	num2 = temp ; //temp记录的num1的值--赋值num2 
	*/
	
	//方式2:使用位异或^特点  一个数据被另一个数据位异或两次:其值是它本身!
	num1 = num1 ^ num2 ;
	num2 = num1 ^ num2 ; //num1 ^ num2 ^ num2 
	num1 = num1 ^ num2 ; //num1 ^ num2 ^ num1 
	
	System.out.println("数据交换后:") ;
	System.out.println("num1:"+num1+",num2:"+num2) ;
}

三元运算符(三目)

格式
	(表达式)? 执行成立的结果:执行false的结果;
	
执行流程:
	1)首先判断表达式是否成立
	2)如果成立,执行成立的结果
	3)如果不成立,就false的结果

需求:
键盘录入两个数据,判断两个数据是否相等! (true/false:布尔类型) (三元)
:三元运算符和if…else的区别?

//三元运算符---运算符:操作的具体的数据进行对比判断
//能够使用三元操作的,一定能够使用if...else...

		流程控制语句:
	顺序结构语句(最基本的语句) 
		当前xxx.java文件---jvm 编译  -----> 类名.class(字节码文件)
		执行程序: java  类名.class;  (编译+运行: 底层原理是一种反射:Java高级部分)
											后期:反射贯彻于JavaEE
		jvm调用main方法:代码从上而下依次加载(源顺序)
	
	选择结构语句
	循环结构语句

*/选择结构语句
if语句
switch语句

if语句
		三种格式
		
	第一种格式
	应用场景:针对单个条件进行判断
	格式:
		if(表达式){
			语句;
		}
		
		
执行流程:
		首先判断表达式是否成立,
		如果成立,则执行语句;
		否则不成立,不会执行!
		
注意事项:
		1)if的后面不能有;
				if(表达式);{}  错误语法
		有左大括号的地方不能有分号;有分号的地方不能有左大括号	

		2)如果使用if格式1,里面的语句是条语句,
			{}是可以省略的!,不建议省略!if语句格式2
if(表达式){
	语句1;
}else{
	语句2;
}

执行流程:
	首先判断表达式是否成立,
	如果成立,执行语句1;
	否则,执行语句2

应用场景:针对两种情况进行判断	

需求:
键盘录入一个字符串 username 以及密码 password
使用这个用户名以及密码和已知存在用户名和密码进行匹配,
如果一致,提示"用户登录成功",否则"登录失败!"

if格式3
场景:针对多个情况进行判断
格式
	if(表达式1){
		语句1;
	}else if(表达式2){
		语句2;
	}else if(表达式3){
		语句3;
		
		
	...
			
	}else{
		语句n+1 ;
	}
	
	流程:
		首先,判断表达式1是否成立,成立,执行语句1
		否则,判断表达式2是否成立,成立,执行语句2
		否则,判断表达式3是否成立,成立,执行语句3
		
		....
		如果上述都没有匹配的结果:执行else的语句;
		switch语句

格式:
	switch(表达式){
	case 值1:
		语句1;
		break ;
	case 值2:
		语句2;
		break;
	...

	default:
		语句n+1;
		break ;
	}
执行流程:
	首先表达式接收一个值
	然后和case语句 值1比较,如果成立,执行语句1,break 结束switch
	值1不匹配,判断和值2是否匹配,如果匹配成功,执行语句2,结束switch
	...
	...
	上面case 语句都不成立,
	执行default语句,执行语句n+1,结束switch!
	

面试:
	switch(表达式):表达式它可以是什么数据类型?
			最基本的类型:int,byte,char
			jdk5以后:可以跟枚举类(enum)
			JDK7以后:String类型
			


	1)case语句的后面只能是常量	(Java是一个强类型语言)					
							前端:javascript :switch语句的case后面可以常量也可以变量
	
	2)break语句:不要轻易省略掉,  会造成case 穿透现象(此时,
		如果跟某个case已经匹配,但是没有语句break,下面的case就不会对比,直接执行语句)
			break:结束,中断  :结束switch
			
	3)switch语句的结束条件
			a)语句break结束
			b)程序默认执行的到末尾!
			
	4)default语句可以在switch语句中的任何位置,不影响执行流程!	
			当前case后面的都匹配,执行default语句
			
			如果default语句在语句中的话,break语句 不能省略!
			如果default语句在switch末尾的话,break语句是可以省略!
			辑器** 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

for循环的格式:
for(1)初始化语句;2)条件语句;4)步长语句(控制体语句)){

			3)循环体语句;
	}
	
	流程:
		1)初始语句给当前循环中的变量赋值:执行一次
		2)接下来执行条件语句,判断条件语句是否成立
		3)如果条件语句结果成立:true,执行3)循环体语句
		4)执行控制体语句++/--,
		循环了
		5)继续去判断条件语句是否成
		6)成立,继续执行循环体语句...
		...
		...
		
		当前条件语句不成立,for循环结束!
		在控制台打印出所有的水仙花数!
	
什么是水仙花数:
		1)是三位数		可以使用for循环:明确了范围 100-1000(不包含1000)
		2)每一个位上的数据的立方相加的结果是该数据本身!
			153 = 1*1*1 + 5*5*5 + 3*3*3 
			
			
1)明确了范围 x >=100 && x<1000
2)每一个位上的数据如何确定 

		定义三个变量:ge,shi,bai:分别代表个位,十位,白为
		int ge = x % 10 ; //求余数 		//153 % 10 = 3 
		int shi = x / 10  % 10 ;       // 153 / 10 = 15   % 10 = 5
		int bai = x / 10 /10 % 10     // 153 / 10 /10 = 1%10 = 1
		
		在循环中加入判断
		如果当前x数据==(ge*ge*ge+shi*shi*shi+bai*bai*bai)
		求出所有的水仙花有多少个

	1)定义一个统计变量 count  从0开始
	2)水仙花数:明确范围:for循环
	3)确定每个位数据
			int ge  = 数据 %10 ;
			int shi = 数据/10 % 10 ;
			int bai = 数据 /10 /10 %10 ;
	4)当满足条件
			ge*ge*ge+shi*shi*shi+bai*bai*bai == 数据本身
			
				统计变量++ ;
				
	5)输出统计变量			

*/
while循环的通用格式

初始化语句;
while(条件表达式){
	循环体语句
	控制体语句;
}

//执行流程
初始化语句:给变量进行赋值
当前条件表达式成立,执行循环体语句;
继续控制体语句, 再次执行条件表达式
...
...
当条件表达式不满足条件,while循环结束

注意事项:
	while循环在使用的时候:
	注意事项
		不要忘了控制体语句,否则死循环

撤销：Ctrl/Commawhile和for循环的区别什么?

	1)应用场景的区别:
		是否明确循环次数
		如果明确循环次数,优先使用for循环 (开发中经常使用)
		当不明确循环的次数,使用while循环
	2)从格式---(内存角度) :for优于 while
		for循环结束之后,不能够访问到for循环中的变量;
		循环结束了, 变量(内存中变量:临时变量)就需要被回收了, 节省内存(栈内存)
		
		while循环:由于存在初始化语句是在while外面定义的,
		所有当前while循环,依然访问到while循环中的变量
		死循环:
	循环语句没有结束条件---恒成立!
	
while循环格式(推荐)
for循环格式
	for(;;){
		循环体语句;
	}
	

灵活使用死循环:当不明确次数,使用while循环
	while(true){
		
		//判断
		满足条件,退出死循环 
		break ; 
	}
	需求:
	//需求:键盘录入数据,玩猜数字游戏   
			java.lang.Math:数学运算 (存在功能:random():产生随机数)
			
			
			public static double random(): 
			获取随机数  double [0.0,1.0)
			
			
分析:
	1)导包: 使用Scanner类  :java.util.Scanner;
	2) 产生一个随机数:0-100之间的随机数 Math.random()*100 +1
	3)创建键盘录入对象
	4)提示并录入数据 (不断录入)
	   4.1)判断
			使用键盘录入的数据和产生的随机数进行比较
			如果大了,提示"您录入的数据大了"
			如果小了,提示小了
			否则,就一致! 

*/
import java.util.Scanner ;
class WhileTest2{
public static void main(String[] args){

	//使用Math类中的random() :数学运算类
	//double number = Math.random() ; //number >= 0.0 && number< 1.0
	//System.out.println(number) ;
	
	//获取一个数据:1-100之间的随机数 (int类型)
	//int number = (int)(Math.random()*100+1);
	//System.out.println(number) ;
	//--------------------------------------------
	
	//产生一个1-100之间的随机数
	int number = (int)(Math.random()*100+1) ;
	
	//统计猜多少次
	//定义统计变量
	int count = 0 ;
	
	//不知道录入多少次才能猜中,无法明确次数,使用while
	
	
	while(true){
		count ++ ;
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入
		System.out.println("请输入一个数据(100以内):") ;
		int guessNumber = sc.nextInt() ;
		
		//判断
		if(guessNumber > number){
			System.out.println("您要猜的数据大了...") ;
		}else if(guessNumber < number){
			System.out.println("您要猜的数据小了...") ;
		}else{
			System.out.println("恭喜您猜中了,"+count+"次猜中了..") ;
			//退出循环
			break ; //退出,中断
		}
	
	
	}
	
	
	
	
	
	
}

}
doWhile循环语句的格式

初始化语句;
do{
	循环体语句;
	控制体语句;
}while(条件表达式) ;

执行流程:
	初始化语句对变量赋值一次;
	成立,执行循环体语句---控制体语句
	判断条件表达式是否成立!
	...
	条件不成立,循环语句结束!
	
	在控制台输出 5次"helloJavaEE" ;

do-while循环: 应用场景: 以后源码中会有,开发中很少用
它和for,while最大的区别:即使条件不成立,循环体至少执行一次!
*/
for循环嵌套

	for(初始化语句1;条件表达式1;控制体语句1){
		
		for(初始化语句2;条件表达式2;控制体语句2){
			循环体
		}
	}
	
	
	内层循环作为外层的循环体语句!

流程:
初始化1先执行,条件表达式1成立,
执行循环:for循环
先执行初始化语句2, 条件表达式2成立.
循环体语句 ---->控制体语句2----条件表达式2是否成立
不满足条件
控制体语句1
跳转控制语句
break ;
continue ;
return ;

		break:表示中断结束的意思,不能单独场景使用
		
			只能在这两个场景使用:
						switch语句 :遇见break结束
						循环中使用:结束循环语句的
						
								单个循环语句中
					嵌套循环中使用(早期的)
								
					break 标签语句

						标签语句:给外层循环和内层循环 起一个名字  标签名称:for(xxx)
							break 标签名称
							跳转控制语句之:	
		continue:结束当前循环,立即下一次循环!
		


	
	
	不能单独使用,一般都在循环中使用!;
	return 也属于跳转控制语句

	结束方法去使用
	
	
		一般 情况:return需要结合有具体返回值类型的方法使用!
	return很少单独使用!	
	
	return:返回 
	算法题:
		<<剑指OFFER>>  

5文钱可以买1只公鸡，3 文钱可以买一只母鸡，1文钱可以买3 只小鸡。用100 文
钱买100 只鸡，那么各有公鸡、母鸡、小鸡多少只？

分析:
当前公鸡,母鸡,小鸡三个变量:分别使用x,y,z
x,y,z 三个未知数:使用传统比较麻烦

公鸡的数量:			5文钱一只(100元钱----公鸡) :20
母鸡的数量:			3文钱一只(100元素----母鸡) :33
小鸡的数量:        z = 100 -x - y ;

for循环遍历:将x,y的数量一一获取

	x :0 -20 
	y: 0 - 33
	z = 100 -x - y ;
	
	需要满足条件:
		1)5*x + 3*y + z == 100
		并且
		2)小鸡的数量  z % 3 == 0	

在工具:idea/eclipse中使用debug模式启动:
当程序出问题/或者是 看一下程序的运行的先后顺序: 方便开发者观察代码!

在工具中:在方法中有效代码的第一行打断点: 在idea中代码的左边行号位置!

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

	//for循环:先去遍历 公鸡 数量
	for(int x = 0 ; x <= 20 ; x ++){
		//x的数量获取到 :公鸡 
		for(int y = 0 ; y <= 33 ; y ++){
			//母鸡的数量
			//小鸡的数量
			int z = 100 - x - y ;
			//满足的条件
			//三个数据的总价钱100
			if((5*x + 3*y + z/3 ==100) && (z % 3 == 0) ){
					//分别输出x,z,z
					System.out.println("公鸡的数量是:"+x+
	",母鸡的数量是:"+y+",小鸡的数量是:"+z) ;
			}
		}
	}
}

}