1、关键字
（1）定义：被java语言赋予了特殊含义的单词。
（2）特点：Java语言中的所有关键字全部都是小写。
（3） 下面是我总结的所有关键字的用法：
1**用于定义数据类型的关键字：
基本数据类型（8个）：整数类型（byte short int long） 浮点类型（ float double） 字符类型（char ) 布尔类型（boolean）
引用数据类型： class（类） interface（接口）
void 用于函数上表示无返回值类型
2 **用于定义数据类型值的关键字：true（真） false（假） null（空）
3**用于定义流程控制的关键字： 判断{if else switch case default } 循环{ while do for }
break（ 结束循环或选择结构 ） continue（ 继续循环） return（返回）
4 **用于定义访问权限修饰符的关键字：private私有的) protected(受保护的) public(公有的)
5**用于定义类，函数，变量修饰符的关键字：abstract(抽象的) final (最终的) static(静态的) synchronized(同步的) enum(枚举)
6**用于定义类与类之间关系的关键字：extends(继承) implements (实现)
7**用于定义建立实例及引用实例，判断实例的关键字：new(建立实例) this (当前引用) super(父类引用) instanceof(判断对象类型)
8 **用于异常处理的关键字：try (检查异常) catch (捕获异常) finally (最终一定会执行)
throw throws（两多表示抛出异常，但使用位置不同）
9 **用于包的关键字：package(创建包) import(导入包)
10 **其他修饰符关键字：native(本地) strictfp (strict float point，精确浮点)
transient (变量修饰符，用它声明一个实例变量，在对象序列化时不会被序列化)
volatile (类型修饰符，用来修饰被不同线程访问和修改的变量)
assert (断言，可以看作是异常处理的一种高级形式，用于捕捉我们在代码中做出的假设)
注意事项：goto和const虽然从未使用，但作为保留字(在JDK的新版本中可能提升为关键字)存在。没有被使用。
2、标示符
（1）定义：在Java语言中，对各种变量、方法和类等要素命名时使用的字符序列。
个人理解，说白了就是给类、变量、方法起名字。
（2）由26个英文字母大小写，数字，0-9 符号，_ $ 组成
（3）Java 标识符命名规则：由字母、下划线“_” 、美元符“$”或数字组成，以字母、下划线 、美元符开头。
注意事项：
A：只能有组成规则规定的内容组成。
B：不能以数字开头。
C：不能是Java中的关键字。
D：区分大小写。
（4）常用的命名规则：见名知意，驼峰命名
A：包（文件夹，用于区分同名的类）全部小写。如果多级包，用.分开。
举例：com 一级包 cn.heima 二级包
注意：www.heima.cn(域名反写)
B：类和接口
如果是一个单词，首字母大写。 举例：Demo，Test ，Student ，Teacher
如果是多个单词，从第二个单词开始每个单词的首字母大写。 举例：HelloWorld，MyInteface
C：变量和方法
如果是一个单词，首字母小写。举例：main，name，age
如果是多个单词，从第二个单词开始每个单词的首字母大写。举例：showName(),studentName
D：常量
全部大写，如果多个单词组成，用_连接。举例：PI，STUDENT_MAX_AGE
3、注释
（1）就是对程序的解释性文字。
（2）注释的分类：
A：单行注释：以//开头，以回车结束，并且是可以嵌套的。
B：多行注释：以/*开头，以*/结束，不可以嵌套使用。
C：文档注释： 将来被javadoc工具解析，生成一个说明书。
（3）注释的作用：
A：解释程序，提高程序的阅读性。
B：便于调试错误。
4、常量
（1）定义：在程序的运行过程中，其值是不可以发生改变的量。
（2）常量的分类：
A：字面值常量
a、整数常量 如：30，-80
b、小数常量 如：25.8， -78.43
c、字符常量 将一个数字字母或者符号用单引号( ' ' )标识 如：‘m’，‘A’，‘2’
d、字符常量 将一个数字字母或者符号用单引号( ' ' )标识 如：“hello”
e、布尔常量 只有两个：true ， false
d、空常量 只有一个数值 null
B、自定义常量
（3）常量可以直接被输出。
5、进制
（1）是一种进位的方式。 X进制，表示逢x进1。
（2）Java中整数常量的表示
A：二进制 满2进1 由0,1 组成，以0b开头。JDK7以后的新特性。
B：八进制 满8进1 由0-7组成，以0开头。
C：十进制 满10进1 由0-9组成，默认就是十进制。
D：十六进制 满16进1 由0-9，A-F（不区分大小写）组成，以0x开头。
（3）进制转换
A：其他进制到十进制
系数：就是每一位上的数据。
基数：X进制，基数就是X。
权：在右边，从0开始编号，对应位上的编号即为该位上的权。
结果：把系数*基数的权次幂相加即可。
如：二进制数 1011 转换为十进制为 1*2^3+0*2^2+1*2^1+1*2^0=8+2+1=11
八进制数 74 转换为 十进制为 7*8^1+4*8^0=56+4=60
十六进制数 0xb5转换为十进制为 11*16^1+5*16^0=181
B：十进制到其他进制
除基取余，直到商为0，余数反转。
例如十进制45转换为二进制做法如下：
C：快速转换
a：8421码。
b：二进制--八进制(3位组合)
c:：二进制--十六进制(4位组合)
6、变量
（1）定义：程序的运行过程中，在指定范围内发生改变的量。变量不指定范围，不知道其所占的内存。
（2）格式：数据类型 变量名=初始化值；
变形格式： 数据类型 变量名；
变量名=初始化值；
举例：方式1： int a=8;
方式2： int a;
a=8;
7、数据类型
（1）分类 ：
基本类型：4类8种。
引用类型：类，接口，数组。
这里需要注意的是：Java程序中，整数默认：int ，long类型需要加L或者l后缀。
浮点数默认是double类型。float类型需要加F或者f后缀。
注：Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。
（2）类型转换：转换分为默认转换和强制转换
java中可以从任意基本类型转型到另外的基本类型，但boolean例外，此类型不可以转换为其他的数据类型。
a：自动类型转换（也叫隐式类型转换）(从小到大)
b：强制类型转换（也叫显式类型转换）(从大到小)
（3） 表达式的数据类型自动提升
所有的byte型、short型和char的值将被提升到int型。
如果一个操作数是long型，计算结果就是long型；
如果一个操作数是float型，计算结果就是float型；
如果一个操作数是double型，计算结果就是double型。
在这儿，看一道面试题：
/*
面试题：下面的语句有没有问题，如果有，请解释。
byte b1 = 3;
byte b2 = 4;
byte b3 = b1 + b2;
byte b4 = 3 + 4;
有问题，在byte b3 = b1 + b2;报错。
解释：
b1 + b2在参与运算的时候，首先会自动转换成int类型。
在这个时候，b1和b2其实都被提升了类型。
所以，他们的计算结果也应该是int类型。
最终，就相当于直接把int类型赋值给byte类型，所以，会有精度的损失。
如果参与运算的是常量，编译器会先计算值，在看该值是否是左边能够表示的范围。
如果是，就不报错。
*/
class VariableDemo4
{
public static void main(String[] args)
{
byte b1 = 3;
byte b2 = 4;
byte b3 = (byte)(b1 + b2);
byte b4 = 3 + 4;
System.out.println(b3);
System.out.println(b4);
}
}8、运算符
（1）就是把常量和变量连接的符号，一般参与运算使用。
（2）分类：
1、算术运算符
2、赋值运算符
3、关系运算符
4、逻辑运算符
5、位运算符
6、三元运算符
a、算术运算符的注意问题
如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
例如：int x=4150;x=x/1000*1000; x的结果是？
“+”除字符串相加功能外，还能把非字符串转换成字符串 ，
例如：System.out.println("5+5="+5+5);//打印结果是？5+5=55 （前面是字符串相加，后面也默认是字符串相加）
System.out.println(5+5+"=5+5");//10=5+5
%：取得余数
左边如果大于右边，结果是余数。
左边如果小于右边，结果是左边。
左边如果等于右边，结果是0。
正负号跟左边一致。
++/--：
++ 其实相当于把数据+1
1、单独使用：
在数据的前后，结果一致。
2、参与操作使用：
如果在数据的后边，数据先操作，在++/--
如果在数据的前边，数据先++/--，在操作。
b、赋值运算符 =,+=,-=,*=,/=,%=
int a = 10;
把10赋值给int类型的变量a。
a += 20;
把左边和右边的和赋值给左边。
注意事项：
a = a + 20;
a += 20;
结果是等价的，理解不是等价的。
因为+=这种运算符，内含了强制类型转换功能。
比如：
short s = 2;
s+=3;
等价于s = (short)(s+3);
c、比较运算符
这里需要注意的是：1、比较运算符的结果都是boolean型，也就是要么是true，要么是false。
2、比较运算符“==”不能误写成“=” 。
d、逻辑运算符
注： 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
/*
表达式：用运算符连接的式子(有变量，常量组成)。
a+b 算术表达式
5>4 比较表达式
逻辑运算符：
用于连接结果是布尔型表达式的运算。
& 逻辑与,并且。有假则假。
| 逻辑或,或者。有真则真。
! 逻辑非,不是，针对一个表达式的操作。
以前真，现在假；以前假，现在真。
^ 逻辑异或。相同为假，不同为真。
如果从结果看，单&和双&以及单|和双|的效果一样。
那么，他们的区别在哪里呢?
&& 如果前面出现了false，后面将不再执行。
|| 如果前面出现了true，后面将不再执行。
&& 短路与
|| 短路或
开发常用：
&&,||,!
*/
class OperatorDemo2
{
public static void main(String[] args)
{
//& 逻辑与,并且
int x = 5;
int y = 6;
System.out.println(x>3 & y>4);//true & true -- true
System.out.println(x>3 & y<4);//true & false -- false
System.out.println(x<3 & y>4);//false & true -- false
System.out.println(x<3 & y<4);//false & false -- false
System.out.println("*******");
//| 逻辑或,或者
System.out.println(x>3 | y>4);//true & true -- true
System.out.println(x>3 | y<4);//true & false -- true
System.out.println(x<3 | y>4);//false & true -- true
System.out.println(x<3 | y<4);//false & false -- false
System.out.println("*******");
//! 逻辑非,不是
System.out.println(x>3);//true
System.out.println(!(x>3));//false
System.out.println(!!(x>3));//true
System.out.println("*******");
//^ 逻辑异或,
System.out.println(x>3 ^ y>4);//true & true -- false
System.out.println(x>3 ^ y<4);//true & false -- true
System.out.println(x<3 ^ y>4);//false & true -- true
System.out.println(x<3 ^ y<4);//false & false -- false
System.out.println("*******");
//&& 短路与
System.out.println(x>3 && y>4);//true & true -- true
System.out.println(x>3 && y<4);//true & false -- false
System.out.println(x<3 && y>4);//false & true -- false
System.out.println(x<3 && y<4);//false & false -- false
System.out.println("*******");
//|| 短路或
System.out.println(x>3 || y>4);//true & true -- true
System.out.println(x>3 || y<4);//true & false -- true
System.out.println(x<3 || y>4);//false & true -- true
System.out.println(x<3 || y<4);//false & false -- false
System.out.println("*******");
//看区别
int a = 10;
int b = 20;
//boolean b1 = (a++ > 10);//false
//System.out.println(b1);//false
//boolean b1 = (++a > 10);
//System.out.println(b1);//true
//System.out.println(a);
//如果++在前面，先把a变化，后在与10进行比较。
//如果++在后面，先与10进行比较，然后a变化。
//boolean b2 = (b-- > 10);//true
//System.out.println((a++ > 10) & (b-- > 10));//a=11,b=19
System.out.println((a++ > 10) && (b-- > 10)); //a=11,b=20
System.out.println(a);
System.out.println(b);
}
}e、位运算符
注：位运算是直接对二进制进行运算。
位运算符的细节
/*
位运算符：是针对二进制数据的运算。
& 按位与
| 按位或
^ 按位异或
~ 按位取反
<< 左移 左边的高位舍弃，右边空出的部分补齐0。
>> 右移 如果最高位是0，左边被移空的位就填入0；如果最高位是1，左边被移空的位就填入1
>>> 无符号右移 无论最高位是1还是0，左边被移空的高位都填入0
向左移动或者向右移动，其实就是把数据增大或者缩小2的指定次幂。
*/
class OperatorDemo3
{
public static void main(String[] args)
{
int a = 3;
int b = 4;
System.out.println(a & b);//0
System.out.println(a | b);//7
System.out.println(a ^ b);//7
System.out.println(~b);//-5
System.out.println(~a);//-4
System.out.println(~8);//-9
//左移
System.out.println(16<<2);
//16*2^2 = 64
/*
16二进制：
00000000 00000000 00000000 00010000
向左移动两位：
00000000 00000000 00000000 00010000
(00)000000 00000000 00000000 0001000000
*/
//右移
System.out.println(16>>2);
//无符号右移
System.out.println(16>>>2);
}
}
/*
推理过程：a=3,b=4
把十进制转成二进制
a -- 00000000 00000000 00000000 00000011
b -- 00000000 00000000 00000000 00000100
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
------------------------------------
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000011
|00000000 00000000 00000000 00000100
------------------------------------
00000000 00000000 00000000 00000111
00000000 00000000 00000000 00000011
^00000000 00000000 00000000 00000100
------------------------------------
00000000 00000000 00000000 00000111
b:
00000000 00000000 00000000 00000100
~ 按位取反，就是针对b这个二进制数据，所有的0变1,1变0。
补码 11111111 11111111 11111111 11111011
反码 11111111 11111111 11111111 11111010
原码 10000000 00000000 00000000 00000101
*/f、条件运算符
格式
( 条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
示例：
获取两个数中大数。
int x=3,y=4,z;
z = (x>y)?x:y;//z变量存储的就是两个数的大数。
****运算符的优先级
运算符的优先级决定了表达式的执行顺序，表达式的运算通常是按照运算符的优先级由高到低依次执行的。
请参阅：Java语言运算符优先级表.doc
好啦~~ 终于把这两天学的东西总结完了，虽然有点累，但是收获蛮大的，继续坚持，继续为自己加油！
1204
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
