java基础--2.基本语法-1

一、 关键字和保留字

1.关键字

         定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

         特点：关键字中所有字母都为小写

 

 

2.保留字

 Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字 

byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

二、标识符

1.标识符：

         Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符

         凡是自己可以起名字的地方都叫标识符。

 

2.定义合法标识符规则：

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

         数字不可以开头。

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

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

         标识符不能包含空格。

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

 

3.Java中的名称命名规范

 

 

三、变量

1. 变量

(1)变量的概念：

         内存中的一个存储区域

         该区域有自己的名称（变量名）和类型（数据类型）

         Java中每个变量必须先声明，后使用

         该区域的数据可以在同一类型范围内不断变化

(2)使用变量注意：

         变量的作用域：一对{ }之间有效

         初始化值

(3)定义变量的格式：

数据类型    变量名  =  初始化值

 

 

2.变量的分类

(1)按数据类型

对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

 

 

(2)按声明的位置

         在方法体外，类体内声明的变量称为成员变量。

         在方法体内部声明的变量称为局部变量。

注意：二者在初始化值方面的异同:

同：都有生命周期     

异：局部变量除形参外，需显式初始化。

 

(3)整数类型

         byte、short、int、long

         Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。

         java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’

 

 

(4)浮点类型

         float、double

 

         与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响。

         Java的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

         浮点型常量有两种表示形式：

                   十进制数形式：如：5.12       512.0f        .512  (必须有小数点）

                   科学计数法形式:如：5.12e2      512E2    100E-2

 

 

(5)字符类型

         char

         char型数据用来表示通常意义上“字符”(2字节)

 

         字符型常量的三种表现形式：

1.        字符常量是用单引号(‘ ’)括起来的单个字符，涵盖世界上所有书面语的字符。例如：        char c1 = 'a';   char c2 = '中'; char c3 =  '9';

2.        Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char      c3    = ‘\n’; // '\n'表示换行符

3.        直接使用Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进    制整数。如：\u000a 表示 \n。

 

         char类型是可以进行运算的。因为它都对应有Unicode码。

 

(6)布尔类型

         boolean

boolean 类型适于逻辑运算，一般用于程序流程控制：

1.        if条件控制语句；                 

2.        while循环控制语句；

3.        do-while循环控制语句；     

4.        for循环控制语句；

 

boolean类型数据只允许取值true和false，无null。

         不可以0或非 0 的整数替代false和true，这点和C语言不同。

 

 

3.类型转换

 

(1)自动类型转换

 

     容量小的数据类型自动转换为容量大的数据类型。

              shorts = 12;

       inti =s + 2;

    注意：byte  short ，char之间做运算，结果为int型！

  

(2)强制类型转换

         是(1)的逆过程。使用“（）”实现强转。

      Stringa = "43";

      int i = Integer.parseInt(a);

注意：boolean类型不可以转换为其它的数据类型。 

 

(3)补充String类

 

         值null可以赋值给任何引用类型（类、接口、数组）的变量，用以表示这个引用类型变量中保存的地址为空。

         String类属于引用类型，可用null赋值。

         String类是一个典型的不可变类，String对象创建出来就不可能被改变。创建出的字符串将存放在数据区，保证每个字符串常量只有一个，不会产生多个副本。

 

public class TestString {    public static void main(String[] args) {       String nation = "老夫子";       System.out.println(nation);       //老夫子       //字符串与基本数据类型的转换，只能是连接运算“+”，结果仍为字符串       String str = "abc";       int m = 123;       String str1 = str + m;       System.out.println(str1);         //abc123       //       String s0 = "hello";       String s1 = "hello";       String s2 = "he" + "llo";       String s3 = new String("hello");       System.out.println(s0 ==s1);      //true       System.out.println(s0 ==s2);      //true       System.out.println(s0 ==s3);      //false    }}

 

(4)进制（了解）

    十进制  二进制  八进制 十六进制

 

   二进制：计算机底层都是用二进制来存储、运算。

          二进制与十进制之间的转换。

          二进制在底层存储：正数、负数都是以补码的形式存储的。（原码、反码、补码）

          四种进制间的转换

四.运算符

1.算术运算符

  

注意：

         如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。

         对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。       

2.赋值运算符

符号：=

当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。

支持连续赋值。

 

扩展赋值运算符： +=, -=, *=,/=, %=

3.比较运算符

  

4. 逻辑运算符

&—逻辑与         | —逻辑或         ！—逻辑非

&& —短路与      || —短路或        ^ —逻辑异或

 

注意：

         逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

 

“&”和“&&”的区别：“|”和“||”的区别同理

单&时，左边无论真假，右边都进行运算；

双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

 

         理解：异或，追求的是“异”!

5.位运算符

  位运算是直接对二进制进行运算

 

6.三元运算符

(1)格式:

         (条件表达式)?表达式1：表达式2；

          为true，运算后的结果是表达式1；为false，运算后的结果是表达式2；

                      表达式1和表达式2为同种类型

三元运算符与if-else的联系与区别：

         1）三元运算符可简化if-else语句

         2）三元运算符要求必须返回一个结果。

         3）if后的代码块可有多个语句

(2)实例

获取两个数中的较大数

public classTest {   public static void main(String[] args) {        int i = 10,j = 20;               int a = (i > j) ?i : j;               System.out.println(a);   }}

7.运算符的优先级

 

 

 

五、程序流程控制

 

顺序结构

         程序从上到下逐行地执行，中间没有任何判断和跳转。

分支结构

         根据条件，选择性地执行某段代码。

         有if…else和switch两种分支语句。

循环结构

         循环条件，重复性的执行某段代码。

         有while、do…while、for三种循环语句。

         注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素

 

1. 顺序结构

 

Java中定义成员变量时采用合法的前向引用。如：

      intnum1= 12;

      int num2 =num1 + 2;

 

2. 分支语句1： if-else语句

 

 

(1)

       if (true){

           执行代码块；

       }

 

(2)

                   if (条件表达式) {

           执行代码块；

       } else{

           执行代码块；

       }

 

(3)         

                   if (条件表达式) {

           执行代码块；

       } else if (条件表达式) {

           执行代码块；

       }

       ...

       else {

           执行代码块；

       }

 

 

3. 分支结构2：switch语句

 

      switch(变量) {

             case常量1:

                语句1

                break;

             case常量2:

                语句2

                break;

         ...

           default:

             语句

             break;

      }

 

/*从键盘输入小明的期末成绩。当成绩为100分时，奖励一辆BMW；当成绩为（80，99]时，奖励一个台iphone5s；当成绩为[60,80]时，奖励一本参考书；其它时，什么奖励也没有。*/ public class Test {    public static void main(String[] args) {       System.out.print("输入小明的期末成绩:");       Scanner s = new Scanner(System.in);       int obj = s.nextInt();             if (obj > 90 && obj <= 100) {           System.out.println("奖励一辆BMW");       } else if (obj > 80 && obj <= 90) {           System.out.println("奖励一个台iphone5s");       } else if (obj >= 60 && obj <= 80) {           System.out.println("奖励一本参考书");       }else {           System.out.println("什么奖励也没有");       }    }}

switch语句有关规则:

 

switch(表达式)中表达式的返回值必须是下述几种类型之一：

         byte，short，char，int，枚举，String；

case

         case子句中的值必须是常量，且所有case子句中的值应是不同的；

default

         default子句是可任选的，当没有匹配的case时，执行default

break语句

         用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾

public class Test {    public static void main(String[] args) {       int i = 6;       switch (i) {           case 0:              System.out.println("zero");              break;           case 1:              System.out.println("one");              break;           default:              System.out.println("default");              break;        }    }}

  

4. 循环结构

(1)基本概念

循环语句功能

在某些条件满足的情况下，反复执行特定代码的功能

 

循环语句的四个组成部分

         初始化部分（init_statement）

         循环条件部分（test_exp）

         循环体部分（body_statement）

         迭代部分（alter_statement）

 

循环语句分类

        for 循环

        while 循环

        do...while 循环

(2)for 循环语句

for (初始化 ;布尔值测试 ;更改表达式)｛

                语句块；

          ｝

public classTest {   public static void main(String[] args) {        int result = 0;        for(int i=1; i<=100; i++) {             result += i;        }     System.out.println("result="+ result);   }}

(3) while 循环语句

                   初始化语句

                   while( 布尔值测试表达式)｛

                                    语句或语句块;

                            [更改语句;]

                   }

public classTest {   public static void main(String[] args) {      int result = 0;      int i=1;      while(i<=100) {          result += i;          i++;      }      System.out.println("result="+ result);   }}

(4) do-while 循环语句

                 初始化语句

                   do｛

                          语句或语句块;

                           [更改语句;]

                   ｝while(布尔值测试表达式);

public classTest {   public static void main(String[] args) {        int result= 0,  i=1;            //1         do{            result += i;            i++;         }while(i<=100);         System.out.println("result=" + result);    }}

(5)嵌套循环for,while,do…while

         将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。

         实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

         设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n=mn次。

 

九九乘法表：

public class Test {    public static void main(String[] args) {        for (int i = 1; i <= 9; i++) {           for (int j = 1; j <= i; j++) {              System.out.print(i +"*"+ j +"="+ i*j + "\t");//制表符           }           System.out.println();       }     }}

5.特殊流程控制语句

(1)break 语句

         用于终止某个语句块的执行

         break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

 

int i;       /**        *break:1.break语句用于终止某个语句块的执行        *      2.出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块        */       for(i = 1 ;i <= 10 ; i++){           if (i % 4 == 0) {              System.out.print(i+" ");              break;           }       }                           //4

 

(2)contune 语句

用于跳过某个循环语句块的一次执行

         contune语句出现在多层嵌套的语句体中时，可以通过标签指明要跳过的是哪一层循环

 

int i;       /**        *continue1.用于跳过某个循环语句块的一次执行        *        2.出现在多层嵌套的语句体中时，可以通过标签指明要跳过的是哪一层循环        */       for(i = 1 ;i <= 10 ; i++){           if (i % 4 == 0) {              System.out.print(i+" ");              continue;           }       }                                             //4 8

 

(3)return 语句

         并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。

(4)说明

break只能用于switch语句和循环语句中；continue 只能用于循环语句中。

二者功能类似，但continue是终止本次循环，break是终止本层循环。

break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。

标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。