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