总结一下JAVA基础知识如：注释、关键字、标识符、数据类型、变量、数据类型转换等基础语法。初学者可参考看看。
1、程序注释
单行注释：
//xxxxxx多行注释：
/* xxxxxx */文档注释：
/** xxxxxx */
2、关键字
关键字：是被Java语言赋予特殊含义，具有专门用途的单词。所有的Java关键词，都是小写。关键词比较多，不用刻意去背，以后用多了自己就记住了。
3、标识符
Java中除了关键字以外基本上都是标识符。我们自己定义的词，比如自己定义的HelloWorld。
标志符命名规则：
标志符组成：字母、数字、下划线、美元符号
字母：a~z、A~Z
数字：0-9
下划线：_
美元符号：$注意：不能数字开头，不能是关键字，严格区分大小写，不限制长度起名时，尽量达到见名知意。
4、数据类型
数据类型分为基本数据类型和引用数据类型。
A、基本数据类型：4类8种（4类展开后共8种基本类型），基本数据类型是JAVA中内置的类型。
第一类：整型
字节
byte 1个字节 二进制位数：8 -128～127短整型
short 2个字节 二进制位数：16 包装类：java.lang.Short 最小值：Short.MIN_VALUE=-32768 （-2的15此方） 最大值：Short.MAX_VALUE=32767 （2的15次方-1）整型
int 4个字节 二进制位数：32 包装类：java.lang.Integer 最小值：Integer.MIN_VALUE= -2147483648 （-2的31次方） 最大值：Integer.MAX_VALUE= 2147483647 （2的31次方-1）长整型
long 8个字节 二进制位数：64 包装类：java.lang.Long 最小值：Long.MIN_VALUE=-9223372036854775808 （-2的63次方） 最大值：Long.MAX_VALUE=9223372036854775807 （2的63次方-1）
第二类：浮点型
单精度
float 4个字节 二进制位数：32 包装类：java.lang.Float 最小值：Float.MIN_VALUE=1.4E-45 （2的-149次方） 最大值：Float.MAX_VALUE=3.4028235E38 （2的128次方-1）注意：必须已“F”结尾，java才认为是float类型，否则默认认为是double类型。
双精度
double 8个字节 二进制位数：64 包装类：java.lang.Double 最小值：Double.MIN_VALUE=4.9E-324 （2的-1074次方） 最大值：Double.MAX_VALUE=1.7976931348623157E308 （2的1024次方-1）注意：必须以“D”结尾，java中默认的浮点类型是double类型。
第三类：字符型
char 2个字节 二进制位数：16 表示一个字符，如（'a','2','家'）注意：用单引号包裹起来，并且其中只能包含一个字符，必须填写。一个汉字=2个字节=16位，所以一个中文字符刚好可以装下。
第四类：布尔型
boolean 1个字节 只有2个值true与false只记基本数据类型的字节数，以及byte取值范围127～-128即可，其它不用记，一般开发中使用int、double、char、boolean。
B、引用数据类型：分别是数组、类、接口
引用数据是强大的数据类型，它是基于基本数据类型创建的。JavaSE中提供了一个超级类库，类库中包含了近万种引用数据类型。
5、常量
JAVA中数据量分为常量和变量。常量就是不变的数据量，任何数据量都是有其类型的，常量就是整数类型。
整数表示方式有十进制、二进制、十六进制、八进制，它们之间的转换（自行谷歌/百度）。
整数常量是byte、short、int、long中的哪种类型呢？
整数常量可以根据所在范围来确定类型，java中默认的整数类型是int类型。long类型必须添加“L”后缀，java才知道其类型，不加"L",java会将其当作int类型。默认浮点类型为doule类型。float需要加“F”后缀，double需加“D”后缀。
1267：没有L后缀，为int类型，但是超出int范围，会报错。
12L：为long类型.
3.1：没有后缀，所以为double类型。
2.34D：为double类型。
1.45F：为float类型。6、变量
Java变量应用最多的。内存数据运行时，临时存储数据的地方。变量就是内存中装载数据的小盒子，只能用来存数据和取数据，数据类型定义了就不能改变了，里面的数据可以变化的。
定义变量格式：
数据类型 变量名 数据值
int num = 100；注意：变量必须要有明确的类型，什么类型的变量装载什么类型的数据，同时也要指定变量能装载多大的数据。数据值不指定，不能使用，编译时不会报错，但是运行时会报错。变量名必须满足标识符规则，才能作为变量来使用。
7、字符串
字符串类型，值用""双引号包裹起来，属于引用数据类型。
String str = "Hello World";注意：字符串Sring不属于基本数据类型，属于JAVA中的引用类型，但是定义、使用和基本数据类型定义类似。
标记一下，后面详细记录String类型
8、变量使用注意事项
变量定义后可以不赋值，使用时再赋值。不赋值不能使用。
错误演示：
/** * 变量使用注意事项演示 * 错误演示：变量没有赋值 */ public class ErrorVariable{ public static void main(String[] args){ int i; System.out.println(i); } }输出结果：
ErrorVariable.java:9: 错误: 可能尚未初始化变量i System.out.println(i);正确演示：
/** * 变量使用注意事项演示 * 正确演示 */ public class CorrectVariable{ public static void main(String[] args){ int i; i = 100; int j = 200; System.out.println(i); System.out.println(j); } }输出结果：
100变量是有自己的作用范围，变量的有效范围为：定义的一对大括号内.
错误演示：
/** * 变量使用注意事项演示 * 错误演示:变量有效范围 */ public class ErrorVariable2{ public static void main(String[] args){ { int i = 100; } System.out.println(i); } }输出结果：
ErrorVariable2.java:11: 错误: 找不到符号 System.out.println(i); ^ 符号: 变量 i 位置: 类 ErrorVariable2 1 个错误变量不能重复定义
错误演示：
/** * 变量使用注意事项演示 * 错误演示:变量不能变量重复定义 */ public class ErrorVariable2{ public static void main(String[] args){ int a = 50; int a = 30; } }输出结果:
ErrorVariable3.java:9: 错误: 已在方法 main(String[])中定义了变量 a int a = 30; ^ 1 个错误
变量使用总结：1、变量没有赋值不能使用 2、变量有效范围 3、变量不能重复定义
9、数据类型代码演示
定义Java八种基本数据类型变量
/** * 定义Java八种基本数据类型变量。 * 变量只能存一个值，以最后一个值为准。 */ public class DataType{ public static void main(String[] args){ //字节类型（127～-128） 1个字节 byte b = 127; //短整型 2个字节 short s = 128; //整型 4个字节 int i =111111; //长整型 8个字节 long l = 22222222222222L; System.out.println(b); System.out.println(s); System.out.println(i); System.out.println(l); //单精度 4个字节 float f =1.176F; //双精度 8个字节 double d =1.100D; System.out.println(f); System.out.println(d); //字符类型 2个字节 //注意：必须有值，空字符也可以,必须单引号包裹起来。 char c ='6'; //char c2 =''; 这个没有值，会报错。 char c3 =' '; System.out.println(c); System.out.println(c3); //布尔类型 1个字节 只有2个值，true和false boolean boo = true; boolean boo2 = false; System.out.println(boo); System.out.println(boo2); } }输出结果：
127 128 111111 22222222222222 1.176 1.1 6 true false数据类型
/** * 数据类型演示 */ public class DemoOne{ public static void main(String[] args){ //输出整数 十进制 System.out.println(50); //输出整数 二进制，数字开头oB System.out.println(0B11); //输出整数 八进制，数字开头0 System.out.println(0537); //输出整数 十六进制，数组开头0X 0-9 A-F System.out.println(0XE); //输出浮点数 System.out.println(3.2); //输出布尔数据，只有2个值，true/false System.out.println(true); System.out.println(false); //输出字符常量，单引号包裹，只能写1个字符(无论是汉字、数组、字母)，都是一个字符。 //注意：不写也不行，不写会报错，但可以写一个空字符。 System.out.println('6'); System.out.println(' '); //输出字符串。 //注意：可以什么都不写，就为一个空字符。 System.out.println(""); } }输出结果：
50 3 351 14 3.2 true false 6注意：最后输出的2个为空。
字符串类型演示
/** * 字符串，引用类型 * 常量：字符串，""双引号包裹起来 * 注意：字符串Sring不属于基本数据类型，属于JAVA中的引用类型，但是定义、使用和基本数据类型定义类似。 */ public class StrVariable{ public static void main(String[] args){ String str = "Hello World"; System.out.println(str); } }输出结果:
Hello World强烈推荐阿里巴巴JAVA开发手册，程序员必备手册。
10、数据类型转换
数据类型转换分为自动转换和强制转换。不同类型的变量是否可以一起运算？答案是可以的，但是需要先进行数据类型转换，再运算。
数据转换遵循原则：
范围小的数据类型值，可以直接转换为范围大的数据类型值。
范围大的数据类型值，不可以直接转换为范围小的数据类型值。各种数据类型按照数据范围从小到大依次列出：
byte -> short -> int -> long -> float -> doubleA:自动类型转换：表示范围小的数据类型转换成范围大的数据类型，这种方式称为自动类型转换。
自动转换格式：
范围大的数据类型 变量 = 范围小的数据类型值；
/**
* 数据类型转换
* 自动转换：取值范围小的数据值，会自动转换成取值范围大的值。
* 注意：bolean类型不能参与转换
*/
public class DataTypeConversion{
public static void main(String[] args){
//double类型变量
double d = 10000; //出现类型自动转换，int自动转换成double
System.out.println(d);
int i =100;
double d2 = i; //出现类型自动转换，int自动转换成double
System.out.println(d2);
byte b =10;
int j = b; //自动类型转换，byte类型自动转换成int类型
System.out.println(j);
}
}注意：bolean类型不能参与转换
B:强制转换：把数据类型取值范围大的，转换成数据类型取值范围小的。
数据类型强制转换公式：
被转后的数据类型 变量名 = (被转换后数据类型)要被转的数据；
/**
* 强制数据类型转换
*/
public class DataTypeConversion2{
public static void main(String[] args){
//double浮点，转成int
double d = 3.14;
//被转后的数据类型 变量名 = (被转换后数据类型)要被转的数据
int i = (int)d;
System.out.println(i);
//类似大桶中的水倒入小桶，水肯定会丢失（精度丢失）
byte b = (byte)200;
System.out.println(b);
}
}输出结果：
3
-56注意：强制类型转换，实际开发中没有要求强制转换时，不转换，不然会丢失精度 ，除非要求转换才做强制转换。
### 11、运算符
运算符分为：算术运算符、赋值运算符、比较运算符、三元运算符。
算术运算符
运算符是用来计算数据的符号。数据可以是常量，也可以是变量。被运算符操作的数我们称为操作数。
算术运算符最常见的操作是将操作数参与数学计算，如下：
运算符 运算规则 范列 结果 + 正号 +3 3 + 加 2+3 5 + 字符串连接 "你"+"好" 你好 - 负号 int a=3;-a -3 - 减号 3-1 2 * 乘 2*3 6 / 除 5/2 2 % 取模 5/2 1 ++ 自增 int a=1;a++/++a 2 -- 自减 int b=3;b--/--b 2算术运算符演示：
/** * + 加法，连 * - 减法 * * 乘法 * / 除法 * % 取模（求余数） * ++ 自增 * -- 自减 */ public class Operator{ public static void main(String[] args){ // + 连接作用，将一个字符串和其他数据连接起来 // 遇到字符串，变成连"5+4=54" // + 任何类型只要和字符串+,所有的数据都变成了字符串。 System.out.println("5+4="+5+4); //除法运算 //java中，整数除法运算最后只会得到整数 int i = 100; int j = 9; System.out.println(i/j); //取模运算，两数相除，获取的余数 int k =6; int m =4; System.out.println(k%m); //++/-- 自增/自减运算 int a = 3; int b = 3; a++; //变量a自己增加1 System.out.println(a); ++b; System.out.println(b); //====================================================== //++：写在变量前面，和写在后面的，区别 int c = 3; int d = 3; ++c; d++; //结论：符号写在前面，还是后面，在变量自己独立计算的时候，没有区别。 //但是变量，要是参与了其它运算，就有区别了。 //f = e++,++后算，先将e的值赋予f，然后e再自增1. //q = ++h,++先算，先将h自增1，后再赋值给q。 //======================测试============================ int e = 5; int f = e++; System.out.println(e); System.out.println(f); int h = 5; int q = ++h; System.out.println(h); System.out.println(q); } }输出结果：
5+4=54 11 2 4 4 6 5 6 6++：写在变量前面，和写在后面的，区别：
符号写在前面，还是后面，在变量自己独立计算的时候，没有区别。但是变量，要是参与了其它运算，就有区别了。
f = e++,++后算，先将e的值赋予f，然后e再自增1. q = ++h,++先算，先将h自增1，后再赋值给q。-- 与++类似，不再做说明。
赋值运算符
赋值运算符就是为变量赋值的符号。
赋值运算符的使用如下：
运算符 运算规则 范例 结果 = 赋值 int a=2 2 += 加后赋值 int a=2,a+=2 4 -= 减后赋值 int a=2,a-=2 0 *= 乘后赋值 int a=2,a*=2 4 /= 整除后赋值 int a=2,a/=2 1 %= 取模后赋值 int a=2,a%=2 0注意：诸如+=这样形式的赋值运算符，会将结果自动强制转成等号左边的数据类型。
public class Operator2{ public static void main(String[] args){ int a = 1; a+=4.8; System.out.println(a); int b = 10; b%=3.3; //会先把10转成double 10.0 然后相除余数0.1，去整数0. System.out.println(b); int h = 10; //h=h%3.3; 会报 不兼容的类型: 从double转换到int可能会有损失 System.out.println(h); int c = 10; double d=3.3; System.out.println(c/d); System.out.println(c%d); byte m =1; //m = m + 1; //出错，会丢失精度，类似把小桶加大桶的水，放到小桶。 m=(byte)(m+1);//通过强转就可以。 m+=1;//这种加就包含了上面的强转，因此推荐使用+=这种 System.out.println(m); } }输出结果:
5 0 10 3.0303030303030303 0.10000000000000053 3注意：在运算时，都会往类型占有字节大的转换后再运算，除/余数运算，结果去整数。
比较运算符
比较运算符，又叫关系运算符，它是用来判断两个操作数的大小关系及是否相等关系的，结果是布尔值true/false。
运算符 运算规则 范例 结果 == 相等于 4==3 false ！= 不等于 4！=3 true < 小于 4<3 false > 大于 4>3 true <= 小于等于 4<=3 false >= 大于等于 4>=3 true注意:赋值运算符的=符号与比较运算符的==符号是有区别的：
赋值运算符的=符号，是用来将=符号右边的值，赋值给=符号左边的变量。
比较运算符的==符号，是用来判断==符号左右变量的值是否相等的。
/** * 赋值运算符 */ public class Operator3{ public static void main(String[] args){ int a = 3; int b = 4; System.out.println(a=b); System.out.println(a==b); System.out.println(a==3); System.out.println(a!=3); } }输出结果：
4 true false true逻辑运算符
逻辑运算符，是用于布尔值进行运算的，结果为布尔值true或false
运算符 运算规则 范例 结果 & 与 false&true false | 或 false|true true ^ 异或 true^false true ! 非 !true false && 短路与 false&&true false || 段落或 false||false true逻辑运算符通常是对两个类型数据之间进行计算，结果也是boolean类型。
/** * 逻辑运算符 */ public class Operator4{ public static void main(String[] args){ //一边是false，运算结果就是false System.out.println(false & false); System.out.println(false & true); System.out.println(true & true); //一边是true，结果就是true System.out.println(false | false); System.out.println(false | true); System.out.println(true | true); ////两相同就是false,不同为true System.out.println(false ^ false); System.out.println(false ^ true); System.out.println(true ^ true); //取反 System.out.println(!false); System.out.println(!true); //前边是false，后边不运行，结果为false。比&效率高 System.out.println(false && false); System.out.println(false && true); System.out.println(true && true); //前边是true，后边不运行，结果为true。比|效率高 System.out.println(false || false); System.out.println(false || true); System.out.println(true || true); } }输出结果：
false false true false true true false true false true false false false true false true true重点：
&与&&区别： 短路与&&,前面不成立(false)，后面就不运算了，结果为不成立（false）。 |与||区别： 短路或||,前面成立，后面就不运算了，结果为成立（true）。三目运算符
之前的均为一元或二元运算符，元就是参与运算的数据。
例如：
3+5，使用算术运算符将操作数联系起来，这种情况，称为：算符表达式。
3>2,使用比较运算符（条件运算符）将操作数联系起来，称为:条件表达式
其它表达式类似。
三目运算符格式:
（条件表达式）? 表达式1 : 表达式2
表达式：几通过使用运算符将操作数联系起来的式子。三目运算符运算规则：
先判断条件表达式的值，为true，结果则为表达式1，为false，结果为表达式2.
/**
* 三目运算符
*/
public class Operator5{
public static void main(String[] args){
int a =2;
int b=6;
System.out.println(a>b ? a+b : b-a);
System.out.println(a<b ? a+b : b-a);
String c = 9>4 ? "Hello" : "呵呵";
System.out.println(c);
}
}输出结果：
4
8
Hello
评论 (0)