黑马程序员——Java语法基础

一、关键字

　　1、定义和特点

　　定义：被Java语言赋予了特殊含义的单词。

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

　　2、分类

　　（1）用于定义数据类型的关键字：byte、short、int、long、float、double、char、boolean、class、interface、void

　　（2）用于定义数据类型值的关键字：true、false、null

　　（3）用于定义流程控制的关键字：if、else、switch、case、default、for、while、do、continue、break、return

　　（4）用于定义访问权限修饰符的关键字：private、protected、public

　　（5）用于定义类、函数，变量修饰符的关键字：abstract、final、static、synchronized

　　（6）用于定义类与类之间关系的关键字：extends、implements

　　（7）用于定义建立实例及引用实例，判断实例的关键字： new、this、super、instanceof

　　（8）用于异常处理的关键字：try、catch、finally、throw、throws

　　（9）用于包的关键字：package、import

　　（10）其他修饰关键字：native、strictfp(strict float point，精确浮点)、transient(变量修饰符，用它声明一个实例变量，在对象序列化时不会被序列化)、volatile(类型修饰符，用来修饰被不同线程访问和修改的变量) 、assert(断言，可以看作是异常处理的一种高级形式，用于捕捉我们在代码中做出的假设)

注意：main不是关键字，却是被虚拟机所识别的一个名称。

二、常量

　　1、定义：java中不能改变的数值，在程序中只能被引用，而不能被重新赋值。

　　2、分类：

　　（1）整数常量。所有整数。

　　（2）小数常量。所有小数。

　　（3）布尔型常量。较为特有，只有两个数值。true  false。

　　（4）字符常量。将一个数字字母或者符号用单引号( ‘ ‘ )标识。

　　（5）字符串常量。将一个或者多个字符用双引号(“”)标识。

　　（6）null常量。只有一个数值就是：null。

　　3、对于整数，Java有四种表现形式：

　　（1）二进制（Binary）：0，1，满2进1

　　（2）八进制（octal）：0-7，满8进1，用0开头表示。

　　（3）十进制（decimal）：0-9，满10进1。

　　（4）十六进制（hexadecimal）：0-9，A-F，满16进1，用0x开头表示。

三、变量

　　1、定义：内存中的一个存储空间，该空间有自己的名称（变量名）和类型（数据类型）。

　　2、作用：用来不断的存放同一类型的常量，并可以重复使用。

　　3、定义的格式：数据类型 变量名 = 初始化值。例如：int x = 5

　　4、变量作用范围：从变量定义开始到定义它的代码块结束。同一范围内，不允许多个个局部变量命名冲突。　　

　　5、Java有两种数据类型：基本数据类型、引用数据类型，结构图如下：

　　6、Java基本数据类型：所占字节数及取值范围，如下图：

　　7、“自动类型提升”和“强制类型转换”

　　（1）自动类型提升：

　　* 在运算中，所有byte型、short型和char型将被提升到int型。

　　* 整个算术表达式的数据类型自动提升到与表达式中最高等级操作数同样的类型。类型提升示意图如下：

　　（2）强制类型转换：当程序中，数据类型需要变换时，可以进行强制转换。

　　8、面试小细节

　　若 byte b = 4;     byte b1 = 3;    b3 = 7;

　　则：b = b1+b2;//运行出现“可能溢出”，因为b1、b2是变量，无法判断结果是否溢出。

　　而：b = 3+7 则可以通过运行

四、运算符

　　运算符是一种特殊符号，用以表示数据的运算、赋值和比较等，共分以下几种：

　　（1）算术运算符

• 单目运算符：+（取正）、－（取负）、++（自增1）、--（自减1）。
• 双目运算符：（＋ 、－、* 、／、%）­
• 三元运算符：a>b? val1： val2。 说明：当a大于b为true时，返回val1的值，否则返回val2的值

　　（2）赋值运算符（= 、+=、－=、*=、/=，、%=）

　　（3）关系运算符（==、!=、>、>=、<、<=、instanceof（判断是否是某一个类的对象））

　　（4）逻辑运算符（&&、||、！&、|、^）

　　其中，&和&&的特点是：单&时，左边无论真假，右边都进行运算；双&时，如果左边为真，右边参与运算；如果左边为假，则右边不参与运算。

而“|”和“||”的特点是：“|”表示其两边都参与运算。而“||”时，表示当左边为真，右边不参与运算。

　　（5）位运算符（&、|、^、~、>>、<<、<<<、>>>）

• 　左移（<<）：空位补0，被移除的高位丢弃，空位补0。
• 　右移（>>）：被移位的二进制最高位是0，右移后，空位补0；最高位是1，空位补1。
• 　无符号左移动和右移（<<<、>>>）：被移位二进制最高位无论是0或者是1，空缺位都用0补。
• 　与（&）：二进制位进行&运算，只有1&1时结果是1，否则是0。
• 　或（|）：二进制位进行 |运算，只有0 | 0时结果是0，否则是1。
• 　异或（^）：任何相同二进制位进行^运算，结果是0。注意：一个数异或同一个数两次，结果还是这个数。 

五、程序流程控制

　　1、程序流程分类

　　四种类型：顺序结构、分支结构（条件结构）、循环结构、控制循环结构

　　2、四种流程控制定义及特点

　　（1）顺序结构：代码里没有流程控制，程序是至上而下顺序地执行完成的，即一条语句执行完之后继续执行下一条语句，直到程序的最后。

　　（2）分支结构：常见的分支结构包括if...else...语句及swtich语句

　　① if...else...语句

　　基本语法：if(表达式){方法体}else if(表达式){方法体}else(方法体)

　　三种格式：

　　if(条件表达式){执行语句;}

　　if(条件表达式){执行语句;}else{执行语句;}

　　if(条件表达式){执行语句;}else if (条件表达式){执行语句;}……else{执行语句;}

　　② switch控制语句

　　定义格式：

　　switch(表达式)

　　{     case 表达式结果值1：

                执行语句；

　　　　　　　　break；

       case 表达式结果值2：

                执行语句；

                break

       default：

                执行语句；

　　}

　　switch语句特点：

• switch语句选择的类型只有四种：byte，short，int， char。
• case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
• 结束switch语句的两种情况：1、遇到break结束；2、执行到switch结尾结束。
• 如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

　　注：JDK1.5以后可以接收枚举类型，JDK1.7以后可以接收字符串。

　　if和switch语句很像。具体什么场景下，应用哪个语句呢？如果判断的具体数值不多，而且符合byte  short  int  char这四种类型。虽然两个语句都可以使用，建议使用switch语句，因为效率稍高。其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

（3）循环结构

　　While：事先不需要知道循环执行多少次；

　　do while：同上，只是至少要执行一次(先执行，后判断)；

　　for：需要知道循环次数；

　　while循环，定义格式如下：

　　while(循环条件语句)

　　{     循环体；       } 

　　do while循环，定义格式如下：

　　do

　　{     循环体；       }while(循环条件语句)

　　for循环，定义格式如下：

　　for(初始化表达式；循环条件表达式；循环后的操作表达式)

　　{     循环体；       } 

　　补充：JDK5.0后的增强型for循环，定义格式如下

　　For（变量类型 变量名 ： 变量名集合）{      执行语句；    } 

　　（4）嵌套循环及控制语句

　　嵌套循环：循环里套循环，即外循环嵌套内循环，其中外循环“控制行”，内循环“控制列”，假设外循环的循环次数是m次，内循环的循环次数是n次，那么内层循环的循环次数需要 m * n次。代码示例如下（打印九九乘法表）： 

1 for（int x = 1；x<=9；x++）{
2        for(int y = 1；y<=x；y++){
3               System.out.print(x+”*”+y+”=”+x*y+”\t”);
4        }
5        System.out.println(); 
6 }

　　控制语句：包括break语句、continue语句；

　　break：终止该层循环；

　　continue：结束本次循环，进入下次循环

　　注：

　　① 若这两个语句离开应用范围，存在是没有意义的。

　　② 这个两个语句后面都不能有语句，因为执行不到。

　　③ continue语句是跳过本次循环，继续下次循环。

　　④ 标签的出现，可以让这两个语句作用于指定的循环，通常不建议使用。

六、函数

　　1、定义：函数是具有一定功能的小程序段。

　　2、定义格式：

　　修饰符    返回值类型    函数名(参数列表){

       　　执行语句；

　　return 返回值；

　　}

　　3、特点：功能代码的封装，进行复用；调用才能执行。

　　4、注意事项：① 当函数执行后无返回值，此时返回值的数据类型用void作为返回值类型，此时return语句可以省略不写。② 函数之间是平行关系，只能相互调用，不能在函数内定义函数。③ 函数存放在类中。

　　5、如何定义函数？

　　定义函数要有两个明确：① 函数的运算结构式什么。② 明确该函数是否需要有参数参与运算，参与运算的参数类型和个数的情况如何。

　　6、函数重载（@override）

　　* 函数重载：是指在“同一个类”中，参数名称相同，而参数的类型和个数不同。又称“同名函数，重复载入”。

　　* “函数重载”与“函数返回值类型”无关。函数重载代码示例： 

 1 class overrideDemo
 2 {
 3        public static void main(String[] args)
 4        {
 5               int sum1=add(3，4);
 6               int sum2=add(3，4，5);
 7               System.out.println(sum1);
 8               System.out.println(sum2);
 9        }
10        public static int add(int a， int b)
11        {
12               int sum = a+b;
13               return sum;
14        }
15 
16        public static int add(int a , int b, int c){
17               int sum;
18               sum = a+b+c;
19               return sum;
20        }
21 }

 七、数组(Array) 

　　（一）定义、内存空间划分、Stack、Heap、数组常见异常问题

　　1、定义：数组是Java 语言中内置的一种基本数据存储结构，通俗的理解，就是一组数的集合，目的是用来一次存储多个数据。

　　2、内存空间划分、Stack、Heap、数组常见异常问题：

　　内存空间划分：寄存器、本地方法去、方法区、栈内存、堆内存。

　　栈内存：存储局部变量，作用域结束后释放。

　　对内存：存储数组/对象，凡是new数组或对象都建立在堆中。其中，每一个对象实体都有一个首地址；每一个变量都有默认初始值。

　　数组常见异常问题：ArrayIndexOutOfBoundsException、NullPointerException

　　（二）一维数组

　　1、格式

　　格式1：元素类型[] 数组名 = new 元素类型[元素的个数或数组长度];

　　　　　　示例：int[] arr = new int[5]；

　　格式2：元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

　　　　　　示例：int[] arr = new int[]{3,5,1,7};   int[] arr = {3,5,7,1}；

　　2、数组常见操作

　　（1）数组遍历，代码如下：

1 int arr[] = {12，23，34，12，45};
2 for（int x=0; x<arr.length; x++）{
3        System.out.println(arr[x]);
4 }

 　　（2）求最值，代码如下：

1        int arr[] = new int[] { 23,26,45,13,12,56,87 };
2               int max = arr[0];
3               for (int i = 0; i < arr.length; i++) {
4                      if (max < arr[i]) {
5                             max = arr[i];
6                      }
7               }
8        System.out.println(max);

 　　（3）数组排序：

　　* 选择排序，代码如下： 

 1 public static void selectSort(int[] arr){
 2        for( int x=0;x<arr.length-1;x++){
 3               for(int y = x+1;y<arr.length; y++){
 4                      if( arr[x] > arr[y] ){
 5                             int temp = arr[x];
 6                             arr[x] = arr[y];
 7                             arr[y] = temp;
 8                      }
 9 
10               }
11        }
12 }

 　　* 冒泡排序，代码如下： 

 1 public static void BubbleSort(int[] arr){
 2        for( int x=0;x<arr.length-1;x++){
 3               for(int y = 0;y<arr.length-1-x; y++){
 4                      if( arr[y] < arr[y+1] ){
 5                             int temp = arr[y];
 6                             arr[y] = arr[y+1];
 7                             arr[y+1] = temp;
 8                      }
 9              }
10        }
11 }

　　（4）查找 

1 public static void getIndex(int[] arr , int key){
2        for( int x=0 ; x<arr.length-1 ; x++){
3               if( arr[x] == key)
4                      return x;
5        }
6        Return -1;
7 }

  　　（三）二维数组

　　1、定义：其实是一个一维数组，它的每一个元素又是一个一维数组。

　　格式1：int[ ][ ]  arr = new int[3][2];　　　　定义了一个二维数组，其中有3个一维数组，每一个一维数组中有2个元素

　　格式2：静态初始化：int[ ][ ]  arr = new int[][]{{4,8}，{3,7}，{9,16}};

　　　　　　　　　　　　int[ ][ ]  arr = {{1,2}，{3,4}，{5,6}};

　　2、应用示例：

1 public class Demo3 {
2        public static void main(String[] args) {
3               int age[][] = new int[][]{{1,2},{3,4},{5,6}};
4               System.out.println(age[0][0]);             //输出结果：1
5               System.out.println(age[2].length);        //输出结果：2
6        }
7 }