01_Java语言基础部分(数据类型与表达式、流程控制语句、数组与方法)

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

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

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

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

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

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

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

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

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

图1.1-标识符名称规范

　　图1.2-所有关键字

---

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

图2.1-所有数据类型

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

---

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

     整型常量分为long、int、short和byte四种类型，Java语言的整型常量默认为int类型 , 可以使用L,F,D等后缀.

     Java中对于数值数据的表示有以下三种形式：  

            十进制：数据以非0开头，例如：4，-15； 

            八进制：数据以0开头，例如：054，012； 

            十六进制：数据以0x开头，例如：0x11，0xAD00 

 

     浮点常量类型区分--在常量后面加后缀修饰

          Float类型以F/f结尾，double类型以D/d结尾。

          如果浮点常量不带后缀，则默认为双精度常量     

 

     字符常量是由一对单引号括起来的单个字符或以反斜线(\)开头的转义符, Java的字符编码采用了国际统一标准的Unicode码 （2字节）,注意后可跟三个八进制(\ddd)和 四位unicode码(\uxxxx)字符表示的特殊形式.

　　       

---

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

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

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

　　　　　　　　  变量 = (强转数据类型)表达式

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；

　　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中定义的循环变量只在for语句中有效,但是while的不会.不过我还是喜欢用for循环语句.不是仍可以变量定义在for外吗?

 

　　累加和计数器思想

 

　　无限循环的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];
    }

     //4.选择排序, 第一个与之后所有元素比较得到极值, 第二个与之后比较得到极值...
     public static void selectSort(int[] arr){
         for(int i=0;i<arr.length-1;i++){
             for(int j=i+1;j<arr.length;j++){
                 if(arr[i]>arr[j]){
                     int temp = arr[i];
                     arr[i] = arr[j];
                     arr[j] = temp;
                 }
             }

         }
     }
     //5.冒泡排序, 似重石逐个沉入水底.
     public static void method6(int[] arr){
         for(int i=0;i<arr.length-1;i++){
             for(int j=0;j<arr.length-1-i;j++){
                 if(arr[j]>arr[j+1]){
                     int temp = arr[j];
                     arr[j] = arr[j+1];
                     arr[j+1] = temp;
                 }
             }
         }
     }

选择与冒泡排序

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

 //6.1折半查找, 条件分离有一种不言语的违和感.
     public static int halfSearch2(int[] arr, int key){
         int low,mid,high;
         low = 0;
         high = arr.length-1;
         mid = (low+high)/2;
         while(key!=arr[mid]){
             if(key>arr[mid])
                 low = mid+1;
             else if(key<arr[mid])
                 high = mid-1;
             if(low>high)
                 return -1;
             mid = (low+high)/2;
         }
         return -1;
     }    

     //6.2折半查找 , 推荐!
     public static int halfSearch(int[] arr, int key){
         int low,mid,high;
         low = 0;
         high = arr.length-1;
         while(low<=high){
             mid = (low+high)/2;
             if(key>arr[mid])
                 low = mid+1;
             else if(key<arr[mid])
                 high = mid-1;
             else
                 return mid;
         }
         return -1;
     }

折半查找的两种思路

数组的查找拓展:

     练习:有一个有序数组,想要将一个元素插入到该数组中,还要保证该数组是有序的,如何获取钙元素在数组中的位置.

     还是利用折半查找的思路,将其中的return -1 改为 return min 就是要插入的位置.

数组中常见的Exception:

　　访问到不存在的角标: ArrayIndexOutOfBoundsException

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