标识符：

由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 voidmain(String[] args)

       {

       int x=getSum(3);

              System.out.println(x);             

       }

       public static int getSum(intnum)

       {

              return num+3;

       }

(4)重载：

在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

例子：void show(int a,charb,double c){} 判断与给定函数是否重载：

    (1)void show(int x,chary,double z){}  //没有重载，与原函数一样。

       (2)int show(int a,doublec,char b){}   //重载，因为参数列表与原函数的参数列表顺序不一样。

       (3)boolean show(int c,charb){}  // 重载，参数列表的个数不同。

       (4)void show(doublec){}      //  重载，参数列表的个数不同。

(5)double show(int x,char y,double z){} //没有重载，不可以与原函数同时出现在一个类中，因为它与原函数的参数列表相同，且它有返回值类型，如果放在同一个类中，就分不清调用的是有返回值类型的函数，还是没有返回值类型的参数。

重载特点：

与返回值类型无关，只看参数列表（参数的个数，参数的类型，参数的顺序）。