2.0Java基本语法

1.关键字与标识符

1.关键字：被java语言赋予特殊含义的字符串(或单词)

     比如：puclic   static  void   class int   float ....

     注意：关键字都是小写的！

    保留字：被java语言占用，但是还没有具体含义。

2.标识符：凡是可以自己命名的地方，都是标识符。

               比如：类名、变量名、方法名、包名、接口名、。。。。

3.定义合法标识符规则：(必须遵守，如果不遵守，编译不通过)

>由26个英文字母大小写，0-9 ，_或 $ 组成 

>数字不可以开头。

>不可以使用关键字和保留字，但能包含关键字和保留字。

>Java中严格区分大小写，长度无限制。

>标识符不能包含空格。

4.Java中的名称命名规范：(如果不遵守，编译也可以通过)

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

5.在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

2.变量

1.变量的声明格式：数据类型 变量名 = 初始化值;

2.变量类型的分类：按照数据类型分：

     1)基本数据类型(8种):          整型：byte short  int  long

                              浮点型：float  double

                              布尔型：boolean

                              字符型：char

     2)引用数据类型：类(比如：String)、接口、数组

3.变量要求：先声明，后使用

4.每一个变量，都有其作用域。即声明这个变量时所在的一对{}内。

5.每种数据类型的使用

     //1.整型 ： byte(1字节)  short(2字节)  int(4字节)  long(8字节)

     byte b1 = 127;

     //b1 = 128;//编译不通过，超出了byte的取值范围

     //定义一个long型的变量，以"l"或者"L"结尾

     long l = 1243124L;

     //通常定义个整型变量，一般使用int型

     //2.浮点型：float(4字节)  double(8字节),表示带小数的数值

     //比较常用的是double

     double d1 = 123.3;

     //定义float型变量时，需要末尾添加"f"或者"F"

     float f1 = 123.2f;

     //3.boolean型：取值只有两个：true 或 false。不能取值为null

     boolean isMale = true;

     //通过boolean型变量使用在条件判断和循环结构中

     if(isMale){

     System.out.println("真男人");

     }else{

          System.out.println("真女人");

     }

     //4.字符型：char(2字节)

     //一个char型变量，表示一个字符

     char c1 = 'a';

     //char c2 = 'ab';//编译不通过

     char c3 = '1';

     char c4 = '中';

     char c5 = '\n';//转义字符

     c5 = '\t';

     System.out.println("abcd" + c5 + "def");

     //很少用

     char c6 = '\u1234';

     System.out.println("c6:" + c6);

6.变量间的运算：(除了boolean类型以外的基本数据类型)

     ①自动类型提升：

          //1.自动类型提升：容量小(表数范围)的变量与容量大的变量间做运算，结果的数据类型与容量大的变量的类型一致。

          //byte、short、char ---> int --->long---->float----> double

          //当byte\short\char三者之间的变量做运算的话，结果都为int型。

         

          long l = 123L;

          float f = 12.3F;

         

     ②强制类型转换：是自动类型提升的逆过程：将容量大的数据类型的变量转换为容量小的数据类型的变量

                    使用强制类型转换符：()

                   

                    double d1 = 123.3;

                    int i = (int)d1;//123

                    byte b = (byte)i;

                    注意：强转时，可能会导致精度损失。

7.关于字符串：String类

     >String类的变量可以与基本数据类型的变量做运算：连接运算：+

     >运算的结果是字符串类型

     >String str1 = "Beijing";

     int i = 10;

     System.out.println(str1 + 10);

    

     System.out.pritln(10);

    

     int num1 = 10;

     int num2 = 20;

     System.out.pritln(num1 + num2);//30

     System.out.pritln("num1 + num2 = " + (num1 + num2));//num1 + num2 = 30

     //System.out.pritln(num1,num2);//错误的！

   进制间的转换：

（了解）

1.计算机底层的所有数据都是使用二进制进行存储的。

2.二进制、十进制、八进制、十六进制间的转换

  1）十进制---->二进制：除2取余数的逆。

  2）二进制---->十进制：

          正数：相应的位 * 2的相应次幂的和

          负数：原码、反码、补码的概念。

               计算机底层都以补码的形式存储数据。 

               对于正数来说，三码合一。  对于负数来说：负数的原码 除符号位以外，各个位取反，得到反码。反码+1，得到补码。

              

  3）如何实现二进制 与 八进制、十六进制间的转换

二进制：计算机底层都以二进制的方式保存数据，以及进行数据的运算。表示：0b101010101011

十进制：表示：54234850246139

八进制：表示：04235465732542

十六进制：表示：0x375458ABEDF

二进制：在底层都是以补码的形式存储的。

二进制和十进制间的运算：

                                ------------------------------------------------------

十进制转换为二进制：

//问题：

        //60  手动的方式，从控制台输出60的十六进制。

        int i = 61;

        //自动调用Integer类现成的方法

        String binary = Integer.toBinaryString(i);//二进制

        System.out.println(binary);

        String hex = Integer.toHexString(i);//十六进制

        System.out.println(hex);

与其他进制间转换的思路：

3.运算符

1.算术运算符：+  -  +  -  *  /  %  (前)++  (后)++   (前)--  (后)--   +(字符串连接运算)

     1） int i = 12;

           int j = i / 5;

           System.out.println(j);//2

     2)取模运算与被模数符号一样。

              int i = 12;

              int j = 3;

           if(i % j == 0){....}

     3)(前)++ ：先+1，后运算

        (后)++：先运算，后+1

简单的来说，++i 和 i++,在单独使用时，就是 i=i+1。

而 a = ++i，相当于 i=i+1; a = i;

而 a = i++，相当于 a = i; i=i+1;

++i是先加再使用,而i++是先使用再加

 

   4）// %:取模、取余.

        //结果的符号取决于被模数

        int num1 = 12;

        int num2 = 5;

        System.out.println(num1 % num2);//2

         num1 = -12;

         num2 = 5;

        System.out.println(num1 % num2);//-2

         num1 = 12;

         num2 = -5;

        System.out.println(num1 % num2);//2

         num1 = -12;

         num2 = -5;

        System.out.println(num1 % num2);//-2

底层应该是以二进制运算的

2.赋值运算符:  =    +=   -=   *=     /=    %=

     运算结果不改变原有变量的数据类型：

     int i = 12;

     i += 10;//i = i + 10;

    

     short s = 10;

        //不建议使用，相当于与int类型做运算得到一个int值，再把前面多出的部分砍掉，再赋值给short

        s = (short)(s + 2);//这个相当于是加法运算和赋值运算，两个运算

        //既可以实现运算，又不会改变原有的数据类型，只会和赋值运算符所要返回的数据类型的二进制数进行运算

        s += 2;//这个只是将要加的值赋值给声明的变量，相当于只做了赋值运算

    

    

     int m = 12;

     m *= 0.1;//编译能通过。

     m = m * 0.1;//编译不通过

3.比较运算符（关系运算符）：  ==   >    <   >=    <=  !=  intanceof

   >比较运算符的结果都为boolean类型！

   >通常使用在条件判断和循环语句中

  int age= 23；

  if(20 < age < 30){}//编译不通过

  应该写为：

  if(age > 20 &&  age < 30){}

4.逻辑运算符: 且： &   &&      或：  |   ||      !     ^

     符号左右两边操作的是boolean类型的变量

  //& 与 && 的区别：当符号左端为true时。二者没有区别。

 //当符号左端是false时，& : 照样执行符号右边的操作。 && ：不再执行符号右边的操作。

 //开发中建议：&&

// | 与|| 区别：当符号左端为false时。二者没有区别。

//当符号左端是true时，| : 照样执行符号右边的操作。 || ：不再执行符号右边的操作。

//开发中，建议使用：||

    

5.位运算符：  <<    >>   >>>   &   |   ^  ~

>>:在二进制的情况下，整体向右移相应的位数。

<< : 在二进制的情况下，整体向左移相应的位数。

     >处理的是数值型的变量

     >在一定范围内，左移一位，相当于这个数值 * 2。右移一位，相当于除以2.

     int i = 6;

     int j = ~i; //-7

<<  :  空位补0，被移除的高位丢弃，空缺位补0。

>>  :  被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1。

>>>:  被移位二进制最高位无论是0或者是1，空缺位都用0补。

&    :  二进制位进行&运算，只有1&1时结果是1，否则是0; 可以看成1是true，0是false

|      :  二进制位进行 | 运算，只有0 | 0时结果是0，否则是1;

^    :  相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0,不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1

~    :  正数取反，各二进制码按补码各位取反，负数取反，各二进制码按补码各位取反。十进制（先加1，再取反）

   

6.三元运算符:(条件表达式)? 表达式1 : 表达式2

例如：int m=10;

     int n=5;

     int max=（m>n）? 10:5;

当条件表达式为true时，返回表达式1，否则返回表达式2.

注:1.既然是运算符，一定会返回一个结果，表达式1和表达式2的类型要一致

     2.表达式1和表达式2的类型，决定了运算符的类型。运算符的结果的数据类型由表达式1 和 表达式2决定。

     3.凡是使用三元运算符的操作都可以转换为if-else结构。反之不成立.

        如果二者都可以使用的情况下，建议使用三元运算符，效率高。

 

例子：求两个数的较大值；求三个数的最大值

4.流程控制

System.currentTimeMillis();        //记录当前时间为多少，用来计算出所用时间

4.1 分支结构

1.条件判断：

1.  if(true){

     执行代码块；

     }

2.  if(条件表达式){

     执行代码块；

      }

     else{

     执行代码块；

      }

3.  if(条件表达式){

     执行代码块；

      }

      else if (条件表达式){

     执行代码块；

      }

       ……

       else{

     执行代码块；

       }

注意1.当程序从上到下执行过程中，若某个条件表达式满足(意味着返回true)，就进入其执行语句执行。执行结束，跳出当前结构

       2.如果多个条件表达式是"互斥"关系，那么执行结构谁上谁下都可以。

       如果多个条件表达式是"包含"关系，要求将范围小的写在范围大的上面

     3.条件判断语句可以嵌套

        4.如果条件判断的执行语句只有一行的话，可以省略一对{}.

       建议：不要省略

    

2.选择结构：

switch(变量){

     case 值1:

          语句1;

          break;

     case 值2:

          语句2;

          break;

     ...

     default:

          语句;

}

1.当变量值的值满足某个case中的值时，就进入相应的case语句中执行，执行完以后，会继续向下执行相应的

case语句，直到遇到break关键字，或者运行到程序末尾

2.default:可选的，同时位置是灵活的。如果不满足任何case，执行当前条件。这条语句可有可无。

3.switch中的变量只能是如下的类型之一：byte short int char 枚举类 String(JDK1.7新加入的)

4.使用switch-case的结构都能转换为if-else结构。反之，不成立。

5.如果switch-case和if-else结构都可以使用，建议使用switch-case,因为效率高

6.case中只能写取值(常量)，不能表示范围！

4.2循环结构 

1.循环结构的4个要素：

①初始化条件

②循环条件(是boolean类型的结果)

③循环体

④迭代条件

2.三种循环结构：

for(①;②;④){    1-2-3-4-2-3-4.。。3-4-2

     ③

}

①

while(②){

     ③；

     ④；

}

①

do{

     ③；

     ④；

}while(②);

注：三种循环间都可以相互转换

区别：①for循环的初始化条件执行完循环以后就不可再在循环外调用。而while循环的初始化条件在循环结束以后，初始化变量声明所在的{}内还可以被调用

②do-while至少会被执行一次。

3.嵌套循环：在一个循环结构A中，还可以定义另外的一个循环结构B，那么就构成了嵌套循环

               A:外层循环   B：内层循环

注：1.内层循环充当了外层循环的循环体。

    2.若外层循环执行m次，内层循环执行n次，那么一共执行了m * n 次

     3.技巧：对于两层嵌套循环来说：外层控制行数，内层控制列数

/*

*****

*****

*****

*****

*/

for(int j = 0;j < 4;j++){

     for(int i = 0;i < 5;i++){

          System.out.print("*");

     }

     System.out.println();

    

}

【典型例题】①九九乘法表  ②100以内的所有的素数（两种方法）

4.

两个特殊的循环结构：

while(true)  或者 for(;;)

第一种情况：当某次执行时，②循环条件返回false，进而结束当前循环

第二种情况：在循环结构内，执行到break语句，调出当前循环。

无限循环结构：while(true) /  for(;;)

明确：若循环结构没有出现上述两种情况之一，那这个循环就是死循环！

      死循环是我们写程序要避免的!       

break和continue关键字的使用

break:①可以使用在switch-case或者循环结构中

②：如果在循环结构中使用：结束当前循环结构（默认结束的是离break最近的循环结构）

continue:①只能使用在循环结构中

②：如果在循环结构中使用：结束当次循环（默认结束的是离break最近的循环结构）

说明：在break和continue关键字后面不能有任何的操作语句。否则编译不通过。

*/

class BreakContinueTest

{

     public static void main(String[] args) {

         

          //对于单层循环来说：

          for(int i = 1;i <= 10;i++){

               if(i % 4 == 0){

                    //break;//123

                    continue;//123567910

               }

               System.out.print(i);

          }

          //***********************************************

          System.out.println();

          //在嵌套for循环中

          l:for(int i = 1;i <= 5;i++){

               for(int j = 1;j <= 10;j++){

                    if(j % 4 == 0){

                         //break;

                         //continue;

                         //break l;

                         continue l;//123123123123123

                    }

                    System.out.print(j);

               }

              

               System.out.println();

          }

          //***********************************************

          //说明的知识：

          System.out.println();

          for(int i = 1;i <= 10;i++){

               if(i % 4 == 0){

                    //break;//123

                    continue;//123567910

                    //System.out.println("今晚林志玲要约我！");//编译不通过

               }

               System.out.print(i);

          }

     }

}