JAVA基础语法(注释、常量、变量、数据类型、数据类型转换、运算符、流程控制、循环结构)

public class HelloWorld {	//这一行是创建一个叫HelloWorld的类，HelloWorld是类的名称，必须与文件名称一致，大小写也一致。
	//类是源代码组成的基本单位，一段程序由无数个类组成。代码都要写在类里面，即在{}大括号里
	public static void main(String args[]) {//这一句是代表main方法，固定格式。它是程序的入口，程序运行首先从这里开始
		System.out.println("Hello,World!!!");//这是一句输出语句，即在“”里面输入任意内容，即可在屏幕中打出来
		//每个语句必须以分号结尾，必须是英文状态下的分号！！！
	}

}

//这是单行注释

多行注释：

/*这是多行注释
* 
*/

文档注释：

/**
 * @author Administrator
 *
 */

是自己定义的名称，例如类名、方法名、变量名。
规定：
	（1）可以以字母、数字、$、_、组合而成;
	（2）不能以数字开头;
	（3）不能用关键字;
尽量遵守：
	（1）对于类名，采用大驼峰式命名，即每个单词首字母大写
	（2）对于方法名、变量名，采用小驼峰式，即第一个单词首字母小写，其余单词首字母大写

是JAVA中带有特殊含义的字符，全是小写且在IDE中带有特殊颜色的。

是在程序运行中固定不变的量
分类：
	（1）字符串常量：""  在双引号内的，可以是字母、数字、中文等，且没有限制，也可以是空白
	（2）整数常量：整数数字
	（3）浮点数常量：带小数的数字
	（4）字符常量：'' 在单引号内的，有且仅有一个字符，也不能是空白
	（5）布尔常量：True或者False；只有这两种
	（6）空值常量：null，代表没有任何数据

public class Demo1Const {
	public static void main(String args[]) {
		//字符串常量
		System.out.println("Hello Mr.Z");
		System.out.println("");
		System.out.println("1345t66");
		//整数常量
		System.out.println(1111);
		//浮点数常量
		System.out.println("1.333");
		//字符常量
		System.out.println('a');
		System.out.println('1');
		//布尔常量
		System.out.println(true);
		//空值常量不能直接使用在打印输出语句上
		System.out.print("111111");//println与print的区别；print语句代表不换行，打印输出内容不会换到下一行
		System.out.println("222222");//
		System.out.print("1122");
		
	}
}

程序中可以改变的值，本质为一个可操作的储存空间
格式：	数据类型 变量名(=初始值);
Java是一种强类型语言，每个变量都必须声明其数据类型。变量的数据类型决定了变量占据存储空间的大小

基本数据类型
	整数型
		byte	1个字节（最小的储存单位）	-128~127
		short	2个字节					-32768~32767
		int		4个字节					-21亿~21亿左右
		long	8个字节					很大很大很大
	浮点数型
		float	4个字节					-3.4x10*38~3.4x10*38
		double	8个字节					-1.798x10*308~1.798x10*308
	字符型
		char	2个字节
	布尔型
		boolean	1位
引用数据类型
	类
	数组
	接口
	...

注意：
	1.默认的整数类型为int型
	2.默认的浮点数型为double型
	3.若想声明为long型，要在后面加上L
	4.若想声明为double型，后面加F
	5.浮点型不能作比较，因为不精确，存在误差


public class Demo2Variable {
	public static void main(String args[]) {
		//整数型数据类型：
		byte a = 100;//定义一个变量的数据类型，并将右边的值赋值于左边
		System.out.println(a);//输出变量a的值100
		
		short b =200;
		System.out.println(b);//200
		b=300;//重新给变量b赋值
		System.out.println(b);//所以变量b的值为300
		
		int c,d;//同时定义变量c和d
		c=300;
		d=400;
		System.out.println(c);//300
		System.out.println(d);//400
		
		long e =3000000000000L;
		System.out.println(e);//3000000000
		System.out.println("----------这是一个分隔符-----------");
		
		float f =3.1233232F;//默认浮点数类型为double,当定义为float类型时，要在后面加上F
		System.out.println(f);//3.1233232
		
		double g = 3.12344556677777777;
		System.out.println(g);//3.12344556677777777
		System.out.println("----------这是一个分隔符-----------");
		//字符型数据类型
		char h = 'a';
		char i = '章';
		System.out.println(h);//a
		System.out.println(i);//章
		System.out.println("----------这是一个分隔符-----------");
		//布尔型数据类型
		boolean j = true;
		System.out.println(j);//true
		/*
			int k = 1999;
			System.out.println(k);  测试变量的使用范围要在它的作用域内，即在花括号内为它的作用域
			System.out.println(a);	当定义了一个变量k，只能在这个范围花括号内打印出来。
		} */   
	}
}


字符（char）型特别说明：
	它可以跟byte、short进行数学计算
	ASCII表，里面记录着字符与数字间的转换关系，字符a对应数字97.因为计算机底层识别的是二进制
	Unicode表，则是记录着全世界各国语言与数字间的转换关系
	
public class Demo4DataTypeChar {
	public static void main(String[] args) {
		char a ='a';//将字符a赋值于变量a中
		long b = 12;//定义变量为long类型
		int c = (int)(a+b);//强制转换，字符型可以与整数型相加
		System.out.println(c);//109
		System.out.println("==========这是一个分割线==========="); 
		
		char zifu1 = 'A';//定义一个char型变量，将右边的值A赋值，A在ACSII表中对应的数字为65
		double d =3.12;//定义一个double型的变量，
		double f = zifu1 + d;//char型与double相加
		System.out.println(f);//68.12
		
	}

}

自动转换：
	取值范围小的可以自动转换为取值范围大的
强制转换：
	取值范围大的强制转换为取值范围小的
	格式：	范围较小的数据类型 变量名 =（数据较小的数据类型）数值
	注意：
		会出现数据溢出或者精度损失的情况
		int d =(int) 5000000000L;//出现了数据溢出的情况

public class Demo3DataType {
	public static void main(String[] args) {
		long a = 10000;//右边的数值默认int类型的，左边定义的数据类型为long型， int----->long,由小到大，发生自动转换
		System.out.println(a);
		
		double b = 3.1F;//右边的数值默认为double类型的，在后面加F，就变成float型，左边为double型，符合规则
		//float---->double 由小变大
		System.out.println(b);
		System.out.println("===========这是一个分隔符============");
		//强制转换
		int c =(int) 1200000L;//进行了数据类型的强制转换，右边是long类型，左边是int型，强制将long型数值储存在int类型变量中
		int d =(int) 5000000000L;//右边数值是long型，强制转换为int型，但是这个数值范围超过了int数据类型的本身范围
		System.out.println(c);//1200000
		System.out.println(d);//不会是12000000000，结果是705032704，这就出现现了数据溢出的情况
		//因为int数据类型的范围是-21亿到21亿，强制转换的数值超过了21亿，但是还在long类型的范围内
		//所以要将这个long型的数值强制转换成int型，装不下，溢出了。
		System.out.println("===========这是一个分隔符============");
		
		double e = 30000;//右边的int型常量自动转换储存在左边的double类型的变量中
		System.out.println(e);//30000.0
		int f = (int)321.1;//右边的double型常量自动转换 储存在左边的int型变量中
		System.out.println(f);//321
		System.out.println("===========这是一个分隔符============");
		
		byte g = 100;
		byte h = 100;
		int j = g+h;   //两个byte型变量相加时，会想转换为int型相加，及byte+byte---->int+int 
		//所以变量j的数据类型要定义为int；
		byte i =(byte)(g+h);//g与h相加后进行强制转换，结果不得超出byte类型的取值范围，否则就会数据溢出
		System.out.println(j);//200
		System.out.println(i);//-56  数据溢出
		
		
	}

}
		

+加、减-、乘*、除/、取余%
不同类型间的运算，会提升至范围大的数据类型进行相加

public class Demo5Operator {
	public static void main(String[] args) {
		//加法
		System.out.println(1+10);//常量相加  11
		int a =10;
		int b =1;
		System.out.println(a+b);//变量相加  11
		System.out.println(a+1);//变量与常量相加  11
		System.out.println(3.14+4.22);//7.35999999  精度损失，一般不进行浮点数间的计算
		double c = a + 2.5;//整数型与浮点数相加，但是不能与定义为浮点型的变量相加，否则就精度损失
		//由int + double ------》 double + double
		System.out.println(c);//12.5
		//减法
		System.out.println(1-11);//常量相减  -10
		System.out.println(a-b);//变量相减 9
		//乘法
		System.out.println(1 * 11);//常量相乘 11
		System.out.println(a*b);//变量相乘 10
		double f = a * 3.12;//为什么这个出现的结果会是31.200000000003呢！！！！
		//测试发现只有3.1几的时候，会出现这种情况
		//原因：首先计算机进行的是二进制运算，我们输入的十进制数字会先转换成二进制，进行运算后再转换为
		//十进制输出。Float和Double提供了快速的运算，然而问题在于转换为二进制的时候，有些数字不能完
		//全转换，只能无限接近于原本的值，这就导致了在后来的运算会出现不正确结果的情况。
		double h = a * 3.22;
		double g = a * 4.12;
		System.out.println(f);
		System.out.println(g);//41.2
		System.out.println(h);//32.2
		System.out.println(10*4.12);//41.2
		System.out.println("===========分隔符===========");
		//除法
		System.out.println(4.0 / 2.0);//2.0
		System.out.println(5 / 2);//2 因为整数相除，结果得到的还是整数
		//取模（取余数）
		System.out.println(5 % 2);//1  结果为等式的余数


自增、自减
	单独使用：++变量名与变量名++没有差别
	int a =100;
	a++;//后++格式
	System.out.println(a);//101
	int b =100;
	++b;
	System.out.println(b);//101
		
	混合使用：
	＋＋变量名,自身立马＋1，然后在赋值于其他变量
	int c =100;
	int d =++c ;//变量c值立马加1，然后在赋值于变量d中
	System.out.println(c);//101
	System.out.println(d);//101

	变量名++，先将原来的值赋值给其他变量，然后自身在+1
	int e =100;
	int f =e++;//先用变量e原来的值赋值于变量f中，然后变量e自身在加1
	System.out.println(e);//101
	System.out.println(f);//100


加法：
	（1）对于数字，起相加的作用
	（2）对于char类型，与byte short进行运算时，会先提升到int与int间的相加
	（3）对于字符串，起连接的作用。任何数据与字符串连接，最后都是字符串

public class Demo5Plus {
	public static void main(String[] args) {
		System.out.println(1+1);//第一种用法：
		System.out.println("=-=-=-=-=-==-=-");
		char a ='a';
		System.out.println(a+1);//98   第二种用法，a对应的数字为97 
		System.out.println("=-=-=-=-=-==-=-");
		String b ="章";
		System.out.println(b+"zhong");//章zhong      第三种用法
		System.out.println(b+111);//章111  当字符串与数字连接时，string + int-----> string，String起的是连接的作用
		System.out.println(b+122+111);//章122111
		
	}

}

赋值运算符@TOC

基本赋值运算符："=",意思是将等式右边的值给予左边的变量并进行储存
复合赋值运算符：	+=     a+=3;//a=a+3
				-=	同上
				*=  同上
				/=	同上
				%=	同上
注意：
	（1）只有变量才能使用赋值运算符，常量不能
  	（2）复合赋值运算符隐藏了强制类型转换
		short g=100;//
		g -=10;//g=g-10;short = short-int=int-int=int  内部隐藏了强制转换的操作
		System.out.println(g);//90

public class Demo07Operator {
	public static void main(String[] args) {
		int a=10;
		a+=3;//a=a+3
		System.out.println(a);//13   -=、*=、/=、%=的操作与+=一样
		int b=10;
		b *= 3;
		System.out.println(b);//30
		//复合赋值运算符中包含了强制类型转换
		short g=100;
		g -=10;//g=g-10;short = short-int=int-int=int  内部隐藏了强制转换的操作
		System.out.println(g);//90

==	=的意思是赋值，==才是比较两个数字是否相等
!=
>
<
>=
<=

注意：
	1.比较运算符的结果只有boolean值，成立为true，不成立为false;
    2.进行多次判断时不能连着写
    public class Demo08Operator {
	public static void main(String[] args) {
		System.out.println(1 > 5);//不成立，所以输出为false
		System.out.println(6 >= 5);//成立，因为6大于等于5；true
		System.out.println(1 < 5);//true
		System.out.println(1 <= 5);//true
		int a =10;
		int b =20;
		System.out.println(a == b);//flase
		System.out.println(a != b);//true
		//不能这样写，  1<x<6；
	}

与：  &&  两个条件必须都满足为true，否则为flase
或：  ||  两个条件只要满足一个就有true，都不满足为false
非：  ！	true的对立面为flase

1.与和非具有短路效果，即只要第一个条件已经得出结果了，就不会在执行确认第二个条件；
2.逻辑运算符只能运用于boolean值
3.与和非左右都必须有一个布尔值，非只有一个布尔值
4.可以连续写多个条件，即 条件A && 条件B && 条件C

public class Demo09Logic {
	public static void main(String[] args) {
		//与 &&的使用
		System.out.println(1<2 && 2>5);//flase  两个条件有一个不满足  true && false
		System.out.println(1<2 && 2<5);//true  两个条件均满足 true && true
		System.out.println("=====分隔符======");
		//非 ||的使用
		System.out.println(1>5 || 3>1); //true  有一个条件满足即可
		System.out.println(1>5 || 3<1);//false  两个条件都不满足
		System.out.println("=====分隔符======");
		//非 ！的使用
		System.out.println(!true);//false
		System.out.println(!false);//true
		System.out.println("=====分隔符======");
		//短路
		int a =100;//与的情况
		System.out.println(1>10 && ++a>1);//false  因为左边的条件已经有了结果，为false，所以第二个条件不会执行
		System.out.println(a);//还是100
		int b =100;//或的情况
		System.out.println(1>0 || b++>1);//true 因为左边的条件已经有了结果，为false，所以第二个条件不会执行
		System.out.println(b);//还是100
	}

}

一元运算符：只要有一个数据就能进行的操作，比如说自增++，自减--，非！
二元运算符：需要有两个数据才能进行的操作，比如说加号+、减号-、与&& 、或||
三元运算符：需要有三个数据才能进行的操作，格式：  数据类型 变量名称 = 条件判断? 数值a:数值b

注意事项：
1.右边的数值必须满足左边数据类型的要求
2.三元运算符的结果必须被使用

public class Demo10Operator {
	public static void main(String[] args) {
		int a =10;
		int b =20;
		int result = a>b ? a:b;//流程：先进行条件判断，若条件符号，则将a的值赋值于变量result，若不符合条件，将b的值赋值
		System.out.println(result);//因为条件不满足，所以将b的值赋值，结果为20
		System.out.println(a>b ? a:b);//也可以是这种写法
		//a>b ? a:b；不能这样写，因为三元运算的结果必须被使用
		//int c =a>b ? 2.5:10; 这是个错误语句，因为2.5是double类型的，必须强制转换才能赋值于int型的变量中
	}
	

}

**选择结构**
if语句:
		格式：
		if(条件判断){
			语句体;
		}
if-else语句:
		格式：
		if(条件判断1){
			语句体1;
		}else{
			语句体2;
		}
if-else if-else语句(适用于多个条件判断):
		格式：
		if(条件判断1){
			语句体1;
		}else if{
			语句体2;
		}else {
			语句3;
		}
switch语句：
		格式：
		switch(变量名称){
 		case 常量1:            
  			语句体;
 			break;   
  		case 常量2:
  			语句体2;
 			break;
  		defalut:
  			语句体;
  			break;  //这里的break可以省略，但是最好要写出来 
  		注意事项：
  			1.case语句后的数值不能重复；
			2.switch后面跟着的括号里面的数据类型只能是基本数据类型的short/byte/int   以及引用数据类型的String字符串型以及eunm枚举型 
			3.若case后不加break,即使它的值已经匹配了，但程序将向下运行，继续打印输出，直到遇到break语句或是下面没有语句了才会停止。为什么default后面的break可以不加呢，因为到这里了它其实已经是末尾了，加与不加程序都将停止，但是防止default语句的顺序颠倒，若不加break语句，还是会向下运行
			4.switch语句比较灵活，不讲先后顺序，即case值的判断可以是颠倒的，且break语句是可以省略的

public static void main(String[] args) {
		int number = 10;
		switch(number) { //检测变量number中的数据
		case 1://若数据等于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("数据不合理");
		}            

**for循环语句条件**
格式：
	for (初始化语句 ; 条件判断 ; 步进语句;){
	循环体;
	}
执行步骤：
第一步，先定义好变量，即初始化语句
第二步，进行条件判断，满足条件，进入第三步；不满足条件，for循环结束
第三步，开始执行循环体语句；
第四步，步进语句，即执行完循环体语句的后要进行什么操作
第五步，重复第二步到-第四步，直到不满足第二步的条件，循环结束。

public class Demo21FOR {
	public static void main(String[] args) {
		//int word=100为初始化语句，这是第一步；第二步进行条件判断，即word>=0;第三步，执行循环体语句，即下面的打印输出语句。第四步是步进语句，是word -=10;
		for (int word=100; word>=0;word -= 10) {
			System.out.println("目前单词还剩" + word +"个，请继续加油！！！");//循环体语句
		}
		System.out.println("恭喜！！您的单词已背完！！");
	}


**while循环语句**
格式：
	初始化语句;
	while(条件判断){
	循环体;
	步进语句;
	}
 
流程：
第一步，初始化语句;
第二步：进行条件判断，满足条件，进入第三步；不满足，退出循环;
第三步：执行循环体;
第四步：执行步进语句;
第五步：重复二-四步，直到不满足条件，循环结束。

public static void main(String[] args) {
		int word =100;//第一步，初始化语句；
		while (word>=0) {//第二步， 进行条件判断
			System.out.println("您今日的单词还剩"+ word + "个,请继续加油！！！");//第三步，执行循环体语句
			word -= 10;//第四步，步进语句
		}
		System.out.println("恭喜您，您今日的单词任务已完成！！！");//循环结束，将打印这句话


**do while 循环语句**
格式：
	初始化语句;
	do {
	循环体语句;
	步进语句；
	}while(条件判断);
	
流程：
第一步：初始化语句
第二步：执行循环体语句
第三步：执行步进语句
第四步：进行条件判断，满足，则重新第二步，不满足，循环结束。

	}

public class Demo23DoWhile {
	public static void main(String[] args) {
		int word =100;//初始化语句
		do {
			System.out.println("您今日的单词还剩" + word + "个,请继续加把劲！！");//执行循环体
			word -=10;//步进语句;
		}while(word>=0);//最后在执行条件判断
		System.out.println("恭喜您，您今日的单词已背完！！！==");//循环结束，打印输出语句	
	}
}

**三种循环的区别：**
	1.当判断条件一开始就不满足时，while和for循环一次都不会执行循环，而do-while循环会执行一次
  	2.for循环中定义的变量只能在for循环中使用，超过范围就不行，而while与do-while循环不一样，它是外面定义变量，即使离开了循环体，变量依旧可以使用

**循环控制语句break语句：**
	1.用于switch语句中，一旦执行，switch语句结束
 	2.用于循环语句中，一旦执行，循环语句结束
public class Demo26Break {
	public static void main(String[] args) {
		for (int i =1; i<=10; i++) {
			if(i == 5) {
				break;//当i的值为5时，循环结束
			}
			System.out.println("i的值为" + i);//这个值只会输出到4
		}
	}
}

**循环控制语句continue语句：**
 * 	使用continue语句后，将跳过这一次循环，直接执行下一次循环；

public class Demo27Continue {
	public static void main(String[] args) {
		for (int i =1;i<=10;i++) {
			if(i == 4) {
				continue;//当i的值为4时，直接跳过循环，进行下一次的循环
			}
			System.out.println(i + "楼到啦！！");//输出发现4层没了，是因为使用了continue语句，直接跳过了第四层，开始第五层
		}
	}
}

**死循环**
格式：
	while(true){
	循环体
	}

要想退出死循环，要记得在循环体中加入break语句

public class Demo28DeadLoop {
	public static void main(String[] args) {
		
		while(true) {
			int i =1;//
			System.out.println("i的值为"+i);//所以最后输出的语句一直是1;
			}
	}
}

**嵌套循环：**
	在循环体中在加入一个循环体

public class Demo29LoopHourAndMinute {
	public static void main(String[] args) {
		for (int hour = 0; hour < 25; hour++) {//执行一回，里面执行了三千六百回，总共执行86400回
			for (int minute = 0; minute<60; minute++) {
				for (int second = 0; second<60; second++) {
					System.out.println("现在是"+ hour + "时" +minute + "分" + second + "秒！！");
				}
			}
		}
	}
}