1. Java语言主要由5中符号组成

标识符：数字、字母、美元符、下划线（注意不能数字开头）

关键字(被Java赋予特殊意义的单词,注意所有关键字都是小写):

　　   goto和const保留了它们，但是Java没有使用。

main不是关键字,但是被虚拟机识别的一个名称

运算符(圆点“.”、分号“；”、空格和花括号“{ }”等符号具有特殊的分隔作用)

　　　 注意运算符优先级(注意左结合和右结合)

分隔符：注意+号可以分割字符串。

注释：单行、多行、文本(共3种),注意写代码时必须添加必要的注释, 在开始时要写思路.

图1.1-标识符名称规范

　　图1.2-所有关键字

2. 数据类型与变量(八大基本数据类型+三种复合类型)

图2.1-所有数据类型

图2.2-基本(简单)数据类型详解

常量: (整型   浮点型   字符常量   字符串  布尔型    null常量)

　　       

变量(内存中一个存储区域,在该区域的数据可以在同一个类型范围内不断变化):

一定要注意变量属于哪个类型和它的取值范围

强制类型转换(小能默认转大,大转小要用强转)

byte short char int long float double

/*为了避免数据溢出,Java虚拟机将两短整数想加的结果默认为int型

s = i; s = i++; s = i+1; 只有前两者编译器通过,第三种自动升为int不通过

*/

//强转可以取某个实数的整数部分(int a = (int)12.34)

3. 表达式与运算符(一定是执行了特定的操作,返回了一个值)

按操作数分为一元,二元和三元

也有另一种分法:包含算术,关系,逻辑,位,赋值组合等几种运算符.

 表3.1-运算符优先级

注意"6+6"+6+6 的输出结果是 6+666, 这是"+"字符连接符导致.

算术运算符中除法符号看左边就行。

　　-2%5为-2；

比较运算符得到的结果是true or false布尔常量.

位运算符注意 异或'^'是不同为真，相同为假。101 011 110 000 . 一个数异或2次或2次的倍数有还原的效果.

逻辑运算符注意短路 与 非短路 的逻辑. 短路可以略微减少判断次数.   短路&&与 &       短路|| 与 |

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

4. 流程控制语句

条件选择语句:

if型,if else型,if else嵌套型

//如果条件体只有一句话,大括号可以省略

switch语句

其中expression必须为byte,short,int 或 char,现新增enum枚举型,jDK1.7新增String类型.

　　　　//default实现所有case都没捕获到的情况

　　　　//case 0: case 1: case 2: { } 实现了多个case对应一种情况.

　　　　if和switch比较: if可以区间比较 , 布尔值的运算. 但是switch不行. switch却效率高过if. 所有在byte,short,int,char...支持的范围内用switch, 其他选择用if语句.

循环语句: (3种,)

while,do while

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

　　　　       { 执行语句}

　　　//for循环语句必须保证中间的表达式是条件表达式,返回true or false.　　

　　无限循环的while和for最简形式

for(;;){}while(true){}

click me

　　break和continue比较

　　 1.break既用在循环语句中,也可用在条件选择语句中的switch语句.

　　 2.contine只用在循环语句中,作用是结束本次循环,接着继续进行条件判断.

　　3.另外break和contine可以带标号(标号的作用:在循环开始执行前,加上标号.例如 label: for循环.)

5. 方法(函数):定义在类中的具有特定功能的一段独立小程序

方法声明

修饰符 1 修饰符2... 返回值类型 方法名(形参表) [ throws 异常列表 ] { }

其中返回值是方法在操作完成后返还调用它的环境的数据,形式有2种:

(1)return 表达式;//方法返回结果为表达式的值;

(2)return;          //用于无返回值的方法退出,无返回值末尾可不写;

参数传递

(1) 基本数据类型的参数传递是以传值的方式进行，即将实际参数的值传递给形参;  在方法内对形参的修改只影响形参单元，不影响实参

(2)引用类型（如对象、数组等）参数传递是按地址进行传递的。在方法内对形参的访问实际是访问所指引用对象

　　函数的特点:

　　　　将功能代码进行封装,便于对该功能进行调用. 只有被调用才被执行,提高了代码的复用性. (注意不能在函数的内部定义函数)

　　函数的重载:　　　　

　　　　在同一个类中，允许存在一个以上的同名函数，函数参数个数或者参数类型至少其一不同.

　　　　由于只考虑参数类型和个数的差异  ,不会考虑出现返回值类型的差异. 因为这将导致算法的不确定性,这是不可能存在的.

函数的递归:

方法自身调用自己,注意死循环即可.

Java的命令行函数

main方法中有一个字符串数组参数,该数组中存放所有的命令行参数.它在命令行运行的主类名之后,个参数之间用空格分隔.使用命令行参数有利于提高应用程序的通用性.

　　如何使用一个函数:

　　　　1.明确返回值类型

　　　　2.明确参数类型和个数

6. 数组(同一种类型数据的集合)

一维数组:声明数组,创建数组空间,初始化三步.

格式1： 数组元素类型  数组名[] ;

格式2： 数组元素类型[]  数组名 ;

其中，数组元素的类型可以是基本类型，也可以是类或接口。

创建数组元素并初始化,称为静态初始化

类型  数组名[ ]={ 初值表 };  例： int arr[] = {1,2,3,4,5,6,7,8,9,10};

其实这相当于int[] arr= new int[]{1,2,3,4,5,6,7,8,9,10}; (记住不能写长度)

高级for(元素类型 循环变量名:数组名 ){循环体}

图6.1-数组的内存结构

内存结构简介:

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式.

栈内存

　　用于存储局部变量，当数据使用完，所占空间会自动释放

堆内存
　　 数组和对象，通过new建立的实例都存放在堆内存中。
　　 每一个实体都有内存地址值
　　 实体中的变量都有默认初始化值
　　 实体不在被使用，会在不确定的时间内被垃圾回收器回收
方法区，本地方法区，寄存器

多维数组

1.声明数组

格式1：数组元素类型  数组名[ ][ ];

格式2：数组元素类型[ ][ ]  数组名;

2.创建数组空间

（1）直接为每一维分配空间，如：

int a[][] = new int [2][3];

（2）从最高维开始，按由高到低的顺序分别为每一维分配空间。如：

int a[][] = new int [2][];

a[0] = new int [3];

a[1] = new int [4];

数组名.length( 数组名[行标].length也要看得懂)

获取数组的长度

3.创建数组元素并初始化

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

int b[][] = {{1,2},{4,5,6}};

更为常见的做法是在数组定义后通过循环语句给数组赋值。

    //1.稍微漂亮的打印int类型数组public static void printArray(int[] arr){System.out.print('[');for(int i=0;i<arr.length;i++){if(i==arr.length-1)System.out.print(arr[i]+"]");else System.out.print(arr[i]+", ");}}/*2.二维数组取出所有元素的方式 (1)使用普通for循环   (2)使用高级for循环 */public static void method2(int[][] array){//1.普通for循环for(int i=0;i<array.length;i++){for(int j=0;j<array[i].length;j++){System.out.print(array[i][j]+" ");     }System.out.println();}//2.高级for循环for(int[] arr:array){for(int i:arr){System.out.print(i+" ");}System.out.println();}        }//3.1获取一位数组的最小值(打擂台方式)public static int method3(int[] arr){int min = arr[0];for(int i=1;i<arr.length;i++)if(min>arr[i])min = arr[i];return min;}//3.2获取一位数组的最小值(打擂台方式)public static int method4(int[] arr){int min = 0;for(int i=1;i<arr.length;i++){if(arr[min]>arr[i])min = i;}return arr[min];}

 1     //4.选择排序, 第一个与之后所有元素比较得到极值, 第二个与之后比较得到极值...
 2     public static void selectSort(int[] arr){
 3         for(int i=0;i<arr.length-1;i++){
 4             for(int j=i+1;j<arr.length;j++){
 5                 if(arr[i]>arr[j]){
 6                     int temp = arr[i];
 7                     arr[i] = arr[j];
 8                     arr[j] = temp;
 9                 }
10             }
11
12         }
13     }
14     //5.冒泡排序, 似重石逐个沉入水底.
15     public static void method6(int[] arr){
16         for(int i=0;i<arr.length-1;i++){
17             for(int j=0;j<arr.length-1-i;j++){
18                 if(arr[j]>arr[j+1]){
19                     int temp = arr[j];
20                     arr[j] = arr[j+1];
21                     arr[j+1] = temp;
22                 }
23             }
24         }
25     }

选择与冒泡排序

　　但开发中,还是使用系统自带的java.util.Arrays 的sort方法较好

 1 //6.1折半查找, 条件分离有一种不言语的违和感.
 2     public static int halfSearch2(int[] arr, int key){
 3         int low,mid,high;
 4         low = 0;
 5         high = arr.length-1;
 6         mid = (low+high)/2;
 7         while(key!=arr[mid]){
 8             if(key>arr[mid])
 9                 low = mid+1;
10             else if(key<arr[mid])
11                 high = mid-1;
12             if(low>high)
13                 return -1;
14             mid = (low+high)/2;
15         }
16         return -1;
17     }
18
19     //6.2折半查找 , 推荐!
20     public static int halfSearch(int[] arr, int key){
21         int low,mid,high;
22         low = 0;
23         high = arr.length-1;
24         while(low<=high){
25             mid = (low+high)/2;
26             if(key>arr[mid])
27                 low = mid+1;
28             else if(key<arr[mid])
29                 high = mid-1;
30             else
31                 return mid;
32         }
33         return -1;
34     }

折半查找的两种思路

数组的查找拓展:

数组中常见的Exception:

　　访问到不存在的角标: ArrayIndexOutOfBoundsException

　　空指针异常,当引用没有任何指向时该引用还用于操作实体: NullPointerException