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

HelloWorld

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

}

JAVA注释

//这是单行注释

多行注释：

/*这是多行注释
*
*/

文档注释：

/**
* @author Administrator
*
*/

标识符

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

JAVA关键字

是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 + "秒！！");
}
}
}
}
}

• 点赞 1
• 收藏
• 分享
• 文章举报