标识符：
由26个英文字母大小写，数字：0-9 符号：_ $ 组成
定义合法标识符规则：
1、数字不可以开头。
2、不可以使用关键字。
3、Java中严格区分大小写。
Java中的注释格式：
单行注释：
格式： //注释文字
多行注释：
格式： /* 注释文字*/
文档注释：
格式：/** 注释文字 */
常量：
常量表示不能改变的数值。
java中常量的分类：
1、整数常量。所有整数
2、小数常量。所有小数
3、布尔型常量。较为特有，只有两个数值。true 和false。
4、字符常量。将一个数字字母或者符号用单引号( ' ' )标识。
5、字符串常量。将一个或者多个字符用双引号标识。
6、null常量。只有一个数值就是:null.
对于整数：java有三种表现形式。
十进制：0-9 ，满10进1.
八进制：0-7 ，满8进1. 用0开头表示。
十六进制：0-9，A-F，满16进1. 用0x开头表示。
进制的基本转换：
(1)十进制二进制互转：
十进制转成二进制除以2取余数，能整除就计为0，不能整除计为1，从右往左写。
例如：6是十进制，变二进制的时候就用6去除以2,6除以2等于3，能整除计为0。
3在除以2于1，不能整除，就计为1。然后1再除以2，计为1。依次从右往左写，为110。
(2)二进制转成十进制乘以2的幂数：
例如：将110变成十进制，整数是4个8位，00000000 00000000 00000000 00000110
从右往左，开始位为2的0次方，然后指数逐渐的增加，最后将2的幂次方
结果乘以二进制位，所以上边的从右往左，第一个1对应的是2，第二个1对应的是4，然后相加，等于6。
(3)十进制十六进制互转：
先将十进制转成二进制，再转成十六进制，4个二进制位代表1个十六进制位。
(4)负数的二进制表现形式：
对应的正数二进制取反加1
变量：
就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间。
(1)变量的概念：
内存中的一个存储区域。
该区域有自己的名称(变量名)和类型(数据类型)。
该区域的数据可以在同一类型范围内不断变化。
(2)为什么要定义变量：
用来不断的存放同一类型的常量，并可以重复使用。
(3)使用变量注意事项：
变量的作用范围(在一对{}中有效)。
(4)变量的格式：
数据类型 变量名 =初始化值;
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。
开辟空间有三个要素：
(1)数据类型。
(2)变量名称。
(3)数据。
整数默认：int 小数默认：double
自动类型转换(也叫隐式类型转换)
强制类型转换(也叫显式类型转换)
类型转换的原理 ：
表达式的数据类型自动提升：
1、所有的byte型、short型和char的值将被提升到int型。
2、如果一个操作数是long型，计算结果就是long型；
3、如果一个操作数是float型，计算结果就是float型；
4、如果一个操作数是double型，计算结果就是double型。
1、自动类型提升示例：
byte b = 5;
int x = 6;
x = x + b; //b会自动提升为int类型进行运算。
2、强制类型转换示例：
byte b = 5;
b = b + 6; //报错 因为b是byte类型的，6是int类型的，
b = (byte)b+6;//强制类型转换，强制将b+6的结果转换为byte类型，再赋值给b。
算术运算符：
Java中的运算符主要有 +(加)、-(减)、*(乘)、/(除)、%(求余数)，它们都是二元运算符。
比较运算符：
比较运算符属于二元运算符，用于程序中的变量之间，变量和自变量之间以及其他类型的信息之间的比较。比较运算符的运算结果是boolean型。当运算符对应的关系成立时，运算结果是true,否则为false。所有比较运算符通常作为判断的依据用在条件语句中。
逻辑运算符：
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
位运算：
1、通过第三方变量交换两个变量的值：
int temp;
temp = n;
n = m;
m = temp;
2、不用第三方变量交换两个变量的值：
n =
n + m;//如果n和m的值非常大，容易超出int范围。
m =
n - m;
n = n - m;
n = n ^ m;
m = n ^ m; //(n^m)^m;
n =
n ^ m; //n ^ (n ^ m)
移位操作：
还可以对二进制位进行移位操作，java中移位运算有三种。
(1) <<:>
(2) >>: 右移
(3) >>>>: 无符号右移
三元运算符：
格式：
(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
程序流程控制：
判断结构：if语句
三种格式：
(1)if(条件表达式)
{
执行语句；
}
(2)if(条件表达式)
{
执行语句；
}
else
{
执行语句；
}
(3)if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
if语句特点：
1、每一种格式都是单条语句。
2、第二种格式与三元运算符的区别：三元运算符运算完要有值出现。 好处是：可以写在其他表达式中。
3、条件表达式无论写成什么样子，只看最终的结构是否是true 或者false。
选择结构：
switch语句
格式：
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
......
default:
执行语句；
break；(可以省略)
}
switch语句特点：
a,switch语句选择的类型只有四种：byte，short，int，char。
b,case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
c,结束switch语句的两种情况：遇到break，执行到switch语句结束。
d,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
如果判断的具体数值不多，而且符合byte short int char这四种类型。
虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
循环结构：
while语句格式：
while(条件表达式)
{
执行语句；
}
do while语句格式：
do
{
执行语句；
}
while(条件表达式);
do while特点是条件无论是否满足，
循环体至少被执行一次。
格式：
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；
}
1、for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然
后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
2、while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while
循环使用的变量在循环结束后还可以继续使用。
3、最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某
些条件，来控制循环。
break(跳出)，continue(继续)：
break语句：应用范围：选择结构和循环结构。
continue语句：应用于循环结构。
for和while的区别：
1、变量有自己的作用域，对于for来说：如果将用于控制循环的增量定义在for语句中。那么该变量只在for语
句内有效。For语句执行完毕，该变量在内存中被释放。
2、For和while可以进行互换，如果需要定义循环增量。用for更为合适。
例子：
(1)for(int x=0;x<6;x++)
{
System.out.println("x"+x);
}
(2) int x =0;
while(x<6)
{
System.out.println("x=="+x);
x++;
}
for(int x = 0; x<3 ; x++)
{
System.out.println("x="+x);
}
int y=0;
while(y<3)
{
System.out.println("y="+y);
y++;
}
System.out.println("y===="+y);
for练习:
(1)
*
**
***
****
*****
例子：
for(int x=0; x<5; x++)
{
for(int y =0; y<=x; y++)
{
System.out.print("*");
}
System.out.println();
}
(2)
1
12
123
1234
12345
例子：
for(int x=1; x<5; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y);
}
System.out.println();
}
for (int x=1; x<=5; x++)
{
for (int y=1; y<=x;y++
)
{
System.out.print(y);
}
System.out.println();
}
(3)
九九乘法表:
1*1=1;
1*2=2; 2*2=4;
1*3=3 2*3=6; 3*3=9;
1*4=4; 2*4=8; 3*4=12;
4*4=16;
1*5=5; 2*5=10; 3*5=15;
4*5=20; 5*5=25
例子：
for (int x=1; x<=9 ; x++)
{
for (int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
for (int x=1; x<=9 ; x++)
{
for (int y=1; y<=x;
y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
函数：
(1)什么是函数：
函数就是定义在类中的具有特定功能的一段独立小程序，是最小的功能单元,函数也称为方法。
(2)函数的格式：
修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2，)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该值会返回给调用者。
(3)函数的特点：
1、定义函数可以讲功能代码进行封装。
2、便于对该功能进行复用。
3、函数只有被调用才会去执行。
4、函数的出现提高了代码的复用性。
5、对于函数没有具体返回值的情况，返回值类型用关键字void来表示，那么此时该函数中的returm语句可以省略不写。
注意：
1、函数中只能调用函数，不可以下函数内部定义函数。
2、定义函数时，函数的结果应该返回给调用者，交由调用者处理。
例子：
public static void
main(String[] args)
{
int x
=getSum(3);
System.out.println(x);
}
public static int getSum(int
num)
{
return num+3;
}
(4)重载：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
例子：void show(int a,char
b,double c){} 判断与给定函数是否重载：
(1)void show(int x,char
y,double z){} //没有重载，与原函数一样。
(2)int show(int a,double
c,char b){} //重载，因为参数列表与原函数的参数列表顺序不一样。
(3)boolean show(int c,char
b){} // 重载，参数列表的个数不同。
(4)void show(double
c){} // 重载，参数列表的个数不同。
(5)double show(int x,char y,double z){} //没有重载，不可以与原函数同时出现在一个类中，因为它与原函数的参数列表相同，且它有返回值类型，如果放在同一个类中，就分不清调用的是有返回值类型的函数，还是没有返回值类型的参数。
重载特点：
与返回值类型无关，只看参数列表(参数的个数，参数的类型，参数的顺序)。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
