关键字
指的是在Java中已经被预定义的，并有特殊意义的。
关键字所有的字母都是小写
Goto和const关键字没有被使用，它只是作为java中的保留字，也许以后会用到。
标识符
其实标识符就是名字，标识符用来表示包名，类名，变量名，常量名，方法名等。
标识符的规则：
- 必须由字母，数字，下划线，美元组成。
- 首字母必须是字母，下划线，美元，数字不能开头。
例如：
1：包名全部小写。
*例如 xxx.yyy.zzz
*www.baidu.com/www.itcast.cn 开发中，他们的com.baidu.www/cn.itcast.www
2：类和接口
*如果是单个单词，首字母大写。例如：Student
*如果是多个单词组成，每个单词的首字母大写。例如：HelloWorld
*使用的是“驼峰命名”；
3：变量和函数
*如果是单个单词，小写即可。例如：main
*如果是多个单词组成，首字母小写，从第二个单词开始，每个单词的首字母大写。例如：makeMoney
*变量是名词组成。函数是由动词+名词组成。
4：常量
*如果是单个单词，全部大写即可。例如：MONEY
*如果是多个单词组成，每个单词大写，用_连接。例如：MAKE_MONEY
注：标识符应该要见名知意，
注释：
三作用—>对代码的说明，提高代码的可读性，还可以在调试时定位错误在哪。
注释的种形式：
单行注释 多行注释 文档注释
单行：//……… 一般放在被注释的上一行或者放在后面
多行：/*………*/ 一般放在方法之前，用来说明方法的作用和要实现的过程
文档：/**………*/ 放在类之前，用于对类的说明描述、作者、版本等，在编写完成之后，利用javadoc工具生成网页文档。
注：单行可以嵌套单行
单行不可以嵌套多行
多行不可以嵌套多行
多行可以嵌套单行
在程序中添加注释:
编写程序时要养成良好的注释习惯，先写注释，再写代码
注释结构：
1， 需求
2， 实现思想
3， 实现步骤
常量
就是在程序运行过程中，其值不能改变的量。
常量的分类
整数常量： 所有的整数，例如:3，4，233，等
字符常量： 将单个字符用单引号引起来，例如：’d’,’g’等
字符串常量： 将一个或者多个字符引起来，例如：”sfljf”,”龙乾坤”;等
小数常量 （实数常量）：带有小数点的数，例如：44.55，2.4等
Nulll常量： 只有一个值就是null;
布尔常量： 有点特殊，分别是固定的true,false值
三种表示常量的形式
十进制：0—9，满十进一
八进制：0-7，满八进一，以0开头的。
十六进制：0-9，A-F,,满16进一。以0X开头的。
所有计算机中的表示形式
二进制：0-1，满二进一
二进制的由来：
二进制是从以前的电信号转换过来的，因为电信号只有一个开和一个关，后面出现了数字信号，就把开和关由0和1来表示。
系数：就是数据中每一位数
基数：用来表示X进制，这X就是基数。
全：就是多少次幂
例如：1*10^5 1代表系数，10代表基数，5代表全
规律：
用系数的基数的全次幂之和就是这个进制转十进制的数
12345=1*10^4+2*10^3+3*10^2+4*10^1+5*10^0=12345
其他进制转换成十进制和其他进制转换成二进制
二进制-à十进制
规律：用系数乘于基数的全次幂
10100110=1*2^7+0*2^6+1*2^5+0*2^4+0*2^3+1*2^2+1*2^1+0*2^0=166
=128+ 0+32+ 0+ 0+ 4+2+ 0
=166
二进制10100110对应十进制数是166
十进制-à二进制
规律：除于2取余，直到商为0，最后把余数反转。
166=10100110
技巧：
规律
11111111=1*10^7+1*10^6+1*10^5+1*10^4+1*10^3+1*10^2+1*10^1+1*10^0
=127 + 64 + 32 + 16+ 8+ 4+ 2+ 1
所以很快的可以计算出：
例如10100001=1*10^7+0*10^6+1*10^5+0*10^4+0*10^3+0*10^2+0*10^1+1*10^0
=127 + 0 + 32 + 0+ 0+ 0+ 0+ 1
=127+32+1
=160
十进制166对应二进制的数是10100110
八进制-à十进制
规律：系数乘于8的全次幂
0246=2*8^2+4*8^1+6*8^0
=128+32+6
=166
八进制0246对应的十进制数是166
十进制--à八进制
方式1：
除于8取余，直到商为0，最后把余数反转
方式2：
首先把十进制转换成二进制，再把二进制转换成八进制，为什么要这样呢，因为十进制可以很方面的计算成二进制是多少，再把二进制的位数各三位分成一组，这样就便于计算。
根据技巧：166对应的二进制数是10100110，
现在要把二进制的数分别各三位组合成一位如果最高位不够三位，就在最高位置不0.最后把所有的值再次组合
010 100 110
2 4 6
所以对应八进制是0246
十进制166对应的八进制数是0246
十六进制--à十进制
规律：系数乘于基数的全次幂
0XA6=10*16^1+6*16^0
=160+6
=166
所以十六进制0xA6对应的十进制数是166
十进制--à十六进制
方式1：
用这个十进制数除于16取余，直到商为0，把余数反转
方式2：
首先把十进制转换成二进制，再把二进制转换成十六进制，现在要把二进制的数分别各四位组合成一位如果最高位不够四位，就在最高位置不0.最后把所有的值再次组合
得到的二进制数是10100110，
1010 0110
10 6
组合后得到0xA6
十进制166对应的十六进制的数是0XA6
八进制---à二进制
方法：把八进制数上的每一位数单独对应二进制的三位数
所以：
0246对应的二进制是：10100110
2 4 6
010 100 110
十六进制---à二进制
方法：把十六进制数上的每一位数单独对应二进制的四位数
0XA6对应的二进制数是：
A 6
1010 110
0XA6对应的二进制数是：10100110
有符号位的二进制
三种表示形式：原码，反码，补码
最高位是符号位，如果是0表示正数，1表示负数
原码：
+7：00000111
-7：10000111
反码：正数和原码一样，负数则符号位不变，其他未取反
+7：00000111
-7：11111000
补码：正数和原码相同，负数则符号位不变，反码加1
+7：00000111
-7：11111001
在计算机中都是用补码来表示，如果用原码有可能会出错，
变量
1.在程序运行过程中，其值有可能会发生变化
2.在内存中会分配一片存储区域，
变量的声明
数据类型 变量名 = 参数
变量名要符合标示符的命名规则
数据类型
基本数据类型
整数
1,byte 1个字节 -128~127
2,short 2个字节 -2^15~2^15-1
3,int 4个字节 -2^31~2^31-1
4,long 8个字节 -2^63~2^63
实数
1,float 4个字节 -3.403E38~3.403E38
2,double 8个字节 -1.798E308~1.7E308
字符型
1,char 2个字节
布尔型
1,boolean 1个字节
注意：整数默认的是int型，实数默认的是double型
基本数据类型的例子：
/*
打印出各种数据类型的值
*/
class Demo
{
public static void main(String[] args)
{
//定义byte类型变量，并给以赋初始值
byte b=1;
System.out.println(b);
//定义short类型变量，并给以赋初始值
short s=234;
System.out.println(s);
//定义 int类型变量，并给以赋初始值
int i=88;
System.out.println(i);
//定义float类型变量，并给以赋初始值
float f=2.33f;
System.out.println(f);
//定义double类型变量，并给以赋初始值
double d=333.22;
System.out.println(d);
//定义char类型变量，并给以赋初始值
char c='中';
System.out.println(c);
//定义boolean类型变量，并给以赋初始值
boolean bo=true;
System.out.println(bo);
}
}
引用类型（类(class)，接口(interface)，数组）
基本数据类型之间的转换
1. boolean类型不能与其他数据类型进行转换
2. char short byte之间不能相互转换
3. 如果char byte short参加运算时，会先自动转换成int类型在参加运算
4. 容量小类型和容量大类型一起运算时，结果就是容量类型的。
自动类型转换（隐式类型转换）：容量小类型向容量大类型转换
例如：
byte b=6;
int i=7;
int i1=i+b;
强制类型转换（显式类型转换）：高类型向低类型转换
byte b=3;
int i2=9;
byte b1=5;
byte b2;
b2=(byte)(i2+b1)
b2=b+b1;
/*这种情况会发生精度丢失的错误，因为b,b1都是byte类型，在进行预算时
b和b1会自动转换成int类型的，结果就是int类型，这时int占有4个字节，而byte只占有1个字节，所以会出现精度丢失的情况*/
b2=3+5;
/*为什么这个没有错呢，因为在赋值运算符中，运算的顺序是从右往左的，所以3加5等于8是一个常量，最后把这个常量赋给了b 。*/
溢出：
符号位向前进位，而使符号位发生改变，
例如，
十进制数据300对应二进制的数据是：100101100
int
00000000 00000000 00000001 00101100
强制转换：byte 干掉前三个字节。
因为byte类型只占一个字节，取值范围-128~127 ，所以就舍去前面的就变为
符号位 值
0 0101100
十进制数据130对应二进制的数据是：10000010
观察可知，这是负数。
原码：10000010
反码：11111101
补码：11111110
int
00000000 00000000 00000000 11111110
强制转换：byte舍去前三个字节。
符号位 值
1 1111110
-126
运算符
●算术运算符
●赋值运算符
●条件运算符
●逻辑运算符
●位运算符
●三元运算符
算术运算符：
算术运算符包括（+， -, *, /, %, ++, --,）
例如：a=3,b=2
运算符 运算 结果
+ a+b 5
- a-b 1
* a*b 6
/ a/b 1
% a%b 1
++ a++ 4
++a 4
-- a-- 2
--a 2
如果c=a++通过运算的时候，必须要先把a的值赋给c自己在加1，而c=++a就是先自己加1再赋给c
赋值运算符：
在java中包括（=，+=，-=,*=,/=,%=）
指的就是把运算符右边的值赋给左边
+=：这种赋值运算符左边的操作数必须是变量，不能是常量，
a+=5 意思就是a =a+5
short s=4;
s+=5
s=s+5
条件运算符
<,>,<=,>=,!=
判断运算符的左右两边的数，结果是布尔型
逻辑运算符
& | ！ && ||
&:只有两个表达式的结果都为true时，结果才为true,否则false
表达式 运算符 表达式 结果
True & true true
True & false false
False & true false
False & false false
|:只有两个表达式的结果都为false时，结果才为false,否则true
表达式 运算符 表达式 结果
True | true true
True | false true
False | true true
False | false false
!:这是一个单目运算符，非true就是false,非false就是true
运算符 表达式 结果
！ true false
！ false true
&&(短路): 只有两个表达式的结果都为true时，结果才为true,否则false，如果第一个表达式为false，则不会再计算第二个表达式，结果为false
表达式 运算符 表达式 结果
True && true true
True && false false
False && true false
False && false false
||（短路）: 只有两个表达式的结果都为false时，结果才为false,否则true,如果第一个表达式为true，则不会再计算第二个表达式，则结果为true
表达式 运算符 表达式 结果
True || true true
True || false true
False || true true
False || false false
&与&&的区别：
&：必须要计算到最后才能计算出结果，
&&：只要第一个表达式的结果为false,就不计算第二个表达式，只有第一个表达式为true的时候，才接着计算第二个表达式。
(& | ~ ^):如果运算符的左右两边为布尔型的时候，它作为逻辑运算符来表示，如果两边都为数值，则按位运算符来表示。
位运算符
按位运算符：
& | ~ ^
&：先把十进制转换成二进制，再把它们相与运算。只有两个对应都为1时结果才为1，否则结果就是0
例如： 7和3相与得到：
|：先把十进制转换成二进制，再把它们相或运算。只有两个对应都为0时结果才为0，否则结果就是1
例如：12与6相或得到：
~：先把十进制转换成二进制，对位取反，是1则0，是0则1。
例如：~4
^：先把十进制转换成二进制，再进行计算。如果两边都相同则为0，否则为1.
例如：12^6
移位运算符：
<< >> >>>
<<:先把左边的操作数转换成二进制形式的数据，然后向左移动右边操作数的位数，在右边后面补0.，最后得到的结果为左边的操作数乘以2的右边操作数的次幂。
例如：12<<3
也就是12*2^3=12*8=96
>>:先把左边的操作数转换成二进制形式的数据，然后向右移动右边操作数的位数，左边补0，如果最高位是1，则最高位就补1，最高位是0，则补0，最后得到的结果是这个数除以2移动位数的次幂
例如：12>>3
也就是12/2^3=1
>>>:无符号位，先把左边的操作数转换成二进制形式的数据，然后向右移动右边操作数的位数，左边补0，这里不管最高位为1或0，则都为0表示。
例如：98>>>1
条件运算符：
（条件表达式）？表达式1：表达式2
必须要一个结果，如果条件表达式为真，则结果为表达式1，否则为表达式2.
流程控制结构
●判断结构
●选择结构
●循环结构
判断结构：
判断结构的三种形式:
形式1：
If(条件表达式)
{
执行语句
}
例如：
Int a=4;
If(a<7)
{
System.out.println(“a真的小于7”);
}
提示：如果if语句后边的大括号中只有一条语句，那么大括号可以省去。
形式2：
If(条件表达式)
{
执行语句；
}else
{
执行语句;
}
例如：
Int a=4;
If(a<7)
{
System.out.println(“a真的小于7”);
}
Else
{
System.out.println(“a不小于7”);
}
形式3：
If(条件表达式)
{
执行语句;
}
else if(条件表达式)
{
执行语句;
}
else if(条件表达式)
{
执行语句;
}
Else
{
执行语句;
}
例如：
Int a=4;
If(a<7)
{
System.out.println(“a真的小于7”);
}
Else if(a>3)
{
System.out.println(“a大于3”);
}
Else
{
System.out.println(“ a等于3”)
}
注意：else后面没有条件表达式，而且else不能单独使用，必须得和if配对使用。
If…..else的嵌套形式：
If(条件表达式)
{
If(条件表达式)
{
执行语句;
}
else{
执行语句;
}
}
Else
{
执行语句;
}
注意：else都是离它最近的那个if进行配对使用。
选择结构
Switch结构的语句：
结构如下：
Switch(表达式)
{
Case表达式: 执行语句；
Break;
Case表达式: 执行语句；
Break;
Case表达式: 执行语句；
Break;
…….
Default:
执行语句；
Break;
}
注：switch后面的表达式只能基本数据类型中的byte,short,int,不能是long类型的，在JDK1.5后可以使用enum. 在JDK1.7后可以使用引用String类型.
例如：
Int a=2;
Switch(a)
{
Case 1: System.out.println(“这就是1吗？”);
Break;
Case 2: System.out.println(“这就是2吗？”);
Break;
Case 3: System.out.println(“这就是3吗？”);
Break;
Default:
System.out.println(“这就是3吗？”);
Break;
}
提示：在case和defualt语句之间的位置可以互换，这并影响程序的运行，但是为了提高代码的可读性，应该尽量把default放在后面，还有的就是case后的各个表达式中不能重复，必须独立。
、
循环结构
有三种可以表示循环结构的方式
方式1：
While(条件表达式)
{
执行语句；
}
执行过程就是：首先判断表达式，如果表达式为真，则执行大括号内的语句，否则不执行，
例子：
Int i=3;
While(i<5)
{
System.out.println(i);
I++
}
这里例子打印出的结果为3 4，为什么呢？
因为在程序运行过程中，先判断i的值是不是小于5，如果是，则打印出I的值，到下一步语句，改变的i的值，现在i的值变为了4，又对4进行判断，一直不断循环比较，直到表达式为假才结束循环体。
方式2：
结构：
Do
{
执行语句；
}
While(表达式);
执行过程：先执行do后面大括号中的语句，然后判断while中的表达式，如果为真，则再执行语句，直到表达式为假时结束，注：while后面必须加分号；
Do
{
Int i=3;
System.out.println(i);
I++;
}
While(i<5);
这里例子打印出的结果为3 4,
While和do…..while一般情况下可以互换，它们的区别在于while语句是先判断表达式，如果为真，则执行大括号内的语句，否则结束执行，而do…….while语句是先执行do后面的语句，再判断while中的表达式，如果为真，则再执行do后面的语句，直到表达式为假时，结束循环体。
方式3：
For语句
格式：
For(表达式1；表达式2；表达式3)
{
执行语句；
}
执行过程是：
先对表达式1进行初始化工作，再判断表达式2，如果为真，则执行大括号内的语句，回到表达式3，再根据表达式3再判断表达式2，直到表达式2为假时，才结束循环体的执行。
例如：
For(int i=3;i<5;i++)
{
System.out.println(i);
}
While语句和for语句一般情况可以互换。
注意：如果while语句后加了分号，for(; ; ;)这样的情况就会出现死循环
Continue和break
Continue:一般用在循环语句中，结束本次循环，接着进行下一次循环
Break:一般用在循环语句和switch语句中，结束当前循环
注：continue和break后面不能出现语句。
---------------------- android培训 、 java培训 、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima