Java基础_Java语法

先来梳理一下入门Ja va必须要掌握的核心知识框架。

一、Ja va语法

（一）Ja va环境搭建

1. 基本常识

软件，说到底就是按照特定顺序组织起来的一组计算机数据和指令。常见的系统软件比如Linux，应用软件比如Google Chrome。软件存在的意义，就是让人和计算机之间能更好地“对话”。这种交互方式主要有两种：图形化界面和命令行。

说到命令行，DOS命令是绕不开的基本功：

• dir — 列出当前目录下的文件及文件夹
• md — 创建目录
• del — 删除文件
• rd — 删除目录
• cd — 进入指定目录
• cd.. — 退回上一级目录
• cd/ — 退回根目录
• exit — 退出DOS命令行

需要注意，在DOS里删除文件夹，前提是文件夹里必须是空的。

实际上，玩转DOS命令行之后你会发现，操作计算机就像跟它说话——你告诉它做什么，它就做什么。当然，前提是你说的话它得能听懂，这就是计算机语言的核心意义。

2. Ja va的跨平台性

跨平台性，简单说就是：用Ja va写的应用程序，在Windows上能跑，在Linux上也能跑。原理其实不复杂——只要在需要运行Ja va程序的操作系统上，提前装好一个Ja va虚拟机（JVM）就行了。JVM负责在对应的系统里把Ja va程序跑起来，至于底层是啥系统，它全包了。

3. Ja va编程环境搭建

两个关键概念得先分清：

• JRE（Ja va Runtime Environment）—— Ja va运行环境。它包含JVM和核心类库。如果你想运行一个现成的Ja va程序，装JRE就够了。
• JDK（Ja va Development Kit）—— Ja va开发工具包。这个是为开发人员准备的，里面不仅有开发工具（编译用的ja vac.exe、运行用的ja va.exe、打包用的jar.exe等），还顺带把JRE也装进来了。所以，装好JDK就不用再单独装JRE了。

一句话总结：你用JDK写程序，交给JRE去跑。

还有个小细节：JDK里自带JRE和开发工具，而JRE里才包含虚拟机。当你敲下运行命令ja va时，系统会自动去找JRE里的虚拟机，让它去执行对应的字节码文件（.class）。

4. 环境变量

在DOS下敲命令时，操作系统会先在当前目录找有没有这个命令。找不到？它就会去环境变量里找那些配置好的路径，看里面有没有。所以，配置环境变量的目的很单纯——让Ja va开发工具用起来更方便。

配置时注意一点：文件必须是可执行文件。

常用配置如下：

• JA VA_HOME → C:\Ja va\jdk1.7.0_17
• PATH → %JA VA_HOME%\bin;
• CLASSPATH → .;%JA VA_HOME%\lib;

这里有几个要点值得注意：

• 把可能会变的路径（比如JDK安装目录）提取出来，用JA VA_HOME变量统一管理。这样在PATH里引用%JA VA_HOME%就能动态获取，以后换版本只改一处就行。
• 在DOS里用set命令配置环境变量，只对当前窗口有效。比如：set PATH=C:\Ja va\jdk1.7.0_17\bin;
• PATH的特点是先当前目录、再环境变量。而CLASSPATH正好相反——先去CLASSPATH配置的路径里找，找不到才去当前目录。
• 同样是配置CLASSPATH，在结尾加不加分号区别很大。加了的，既找环境变量路径也找当前目录；没加的，只找环境变量路径。

5. 第一个Ja va程序

主函数的作用是确保这个类能独立运行。当你敲下ja va命令，系统会去调用JVM，JVM再去调用Windows底层，然后运行你指定的类。而在运行之前，JVM会先检查这个类里有没有public static void main(String[] args)——这就是程序的入口，没有它，一切免谈。

（二）语法基础

1. 基础语法

（1）关键字

关键字，就是计算机语言里被赋予了特殊含义的单词。Ja va里的关键字有个共同特点：全是英文小写。

（2）标识符

标识符就是你在程序里起的各种名字。成分包括：0-9、A-Z、a-z、下划线_、美元符号$。注意两条铁律：数字不能开头，不能和关键字重名。

（3）注释

注释有三种：

• 单行注释：// 注释内容
• 多行注释：/* 注释内容 */
• 文档注释：/** 注释内容 */

注释既可以用来解释说明代码，也可以用来临时屏蔽代码做调试。不过有一个坑要记住：多行注释里不能再嵌套多行注释。

（4）Ja va关键字一览

数据类型：class、interface、byte、short、int、long、float、double、char、boolean、void
数据值：true、false、null
流程控制：if、else、switch、case、default、while、do、for、break、continue、return
访问权限：private、protected、public
类/函数/变量修饰：abstract、final、static、synchronized
类关系：extends、implements
实例相关：new、this、super、instanceof
异常处理：try、catch、finally、throw、throws
包操作：package、import
其他：native、strictfp、transient、volatile、assert

（5）Ja va名称规范

• 包名：全小写
• 类名/接口名：每个单词首字母大写（大驼峰）
• 变量名/函数名：第一个单词首字母小写，后续每个单词首字母大写（小驼峰）
• 常量名：全大写，单词之间用下划线连接

2. 进制

任何数据在计算机底层都是以二进制形式存在的。二进制说到底就是开关的演变，但一连串的0和1实在不方便阅读。于是人们想到把三位二进制缩成一位表示——三位最大是7，超过就进位，这就是八进制。后来又觉得不够，干脆用四位二进制表示一位，这就是十六进制。

计算机里，8位二进制数组成一个最小的存储单位——字节。

为了把文字也塞进计算机，人们用0和1的不同排列来对应A、B、C……这就形成了编码表。最基础的是ASCII表，美国人用的。中文词太多，对应的编码表自然也更复杂。

负数在二进制里怎么表示？举个例子：6在32位二进制里是00000000 00000000 00000000 00000110。先取反得11111111 11111111 11111111 11111001，再加1，得到11111111 11111111 11111111 11111010，这就是-6。负数的最高位总是1，这个特征很明显。

（三）变量

1. 变量的概念

变量就是内存里的一块存储区域，有自己的名字（变量名）和类型（数据类型）。这块区域里的数据可以在同一类型范围内不断变化。

2. 为什么要定义变量

说白了，就是为了反复存放同一类型的常量数据，并且能重复使用。

3. 使用变量要注意的两件事

• 变量的作用范围
• 初始化值

4. 什么时候定义变量

数据不确定、需要存储的时候，就定义一个变量。本质上，程序里要用一些内存单元来暂存数据。为了方便访问，我们用标识符（也就是变量名）给这些内存单元取个名字，而不是记它那一长串唯一地址。命名同时还要指定数据类型，这样才能存入和读取正确类型的数据。因为程序运行时这些数据会变化（常量除外），所以叫变量。

这里顺便扯一句C语言的类比：类型本身（比如int）是不占内存的，但用它们定义的变量和数组是占内存的。结构体类型也不占内存，它只是告诉编译器：将来定义这种类型的对象由哪些成员构成、各占多少字节。一旦定义变量，内存就分配好了，而且是连续的。

经典示例：类型转换

short s = 3;
s = s + 2;  // 编译失败！s被自动转成int，运算结果也是int，没法赋值给short
s += 2;     // 编译通过！+=运算符在赋值时自动完成了强制类型转换

（四）运算符

位运算示例：

60 >> 4 = 3
// 00000000 00000000 00000000 00111100 >> 4 = 00000000 00000000 00000000 00000011

注意一个规律：左移相当于乘以2的移动位数次幂，右移相当于除以2的移动位数次幂。

（五）语句

1. switch语句的特点

• 选择的类型只有四种：byte、short、int、char
• case和default的顺序无所谓，程序会先看第一个case，没有匹配就去执行default
• switch语句结束只有两种可能：遇到break，或者执行到switch结尾
• 如果匹配的case或default没有break，程序会继续往下执行，直到遇到break或switch结尾

2. 循环语句

需要多次执行某些语句时，就用循环。另外要留意变量的作用域：如果把增量定义在for语句里，这个变量只在for循环内有效，循环结束后它就在内存里被释放了。这一点其实很实用——如果循环结束后还要用到这个变量，就得用while循环；否则，用for更省内存。

for与while的对比：

for(int i = 0; i < 3; i++) {
    System.out.println("i=" + i);
}
// System.out.println("i=" + i);  // 编译出错，找不到符号i

int j = 0;
while(j < 3) {
    System.out.println("j=" + j);
    j++;
}
System.out.println("j=" + j);  // 编译正确，输出j=3

嵌套循环示例：

for(int i = 1; i <= 5; i++) {       // 控制行
    for(int j = 1; j <= i; j++) {   // 控制列
        System.out.print(j);
    }
    System.out.println();
}
// 运行结果：
// 1
// 12
// 123
// 1234
// 12345

（六）函数

函数是定义在类中的、具有特定功能的一段独立小程序。它的基本格式如下：

修饰符 返回值类型 函数名(参数类型 形式参数1, 参数类型 形式参数2, ...) {
    执行语句;
    return 返回值;
}

• 返回值类型：函数运行后的结果的数据类型
• 参数类型：形式参数的数据类型
• 形式参数：函数的自变量，用来接收调用时传入的实际参数
• 实际参数：传给形式参数的具体数值
• return：结束函数，同时把返回值交给调用者

定义函数的思路：

1. 先明确这个功能的运算结果是什么（确定返回值类型）
2. 再明确运算过程中是否需要未知内容参与（确定参数列表）

有两个原则必须记住：函数里只能调用函数，不能在函数内部再定义函数；函数的结果应该返回给调用者，让调用者自己决定怎么处理。主函数的作用，就是调用其他函数来做测试。

错误案例：

public static void getAdd(int a, int b) {
    System.out.println((a+b));  // 问题很大！打印操作应该是调用者的事
    return;
}

另一个常见错误：

class Demo {
    // 错误：找不到程序入口
    for(int i = 0; i < 5; i++) {
        System.out.println(i);
    }
}

函数重载

重载指的是在同一个类中，允许存在多个同名函数，只要参数个数或参数类型不同即可。重载和返回值类型无关，只看参数列表。它的好处是方便阅读，优化设计。什么时候用？功能相同，但参与运算的未知内容不同时，就用同一个函数名来统一语义，靠参数列表来区分。

（七）数组

1. 数组的概念

数组就是同一种类型数据的集合，本质上就是一个容器。好处是：数组会自动给每个元素从0开始编号，方便操作。

2. C语言中的数组（拓展理解）

C语言里，数组定义后，数组和它的每个元素在内存中都有明确的地址。数组起始地址就是数组的指针，可以用数组名或取地址符来给指针变量赋值——数组名本身代表数组首地址，并且永远是常量。

3. Ja va内存结构

Ja va程序运行时，内存被划分为不同区域，每个区域有特定的数据处理和管理方式：

• 栈内存：存局部变量，数据用完自动释放
• 堆内存：存实体（包括数组和对象），通过new创建的对象都在这里。每个实体都有地址值，实体中的变量都有默认初始值，不再使用时会在不确定的时间内被垃圾回收器回收
• 方法区（也叫共享区或数据区）
• 本地方法区
• 寄存器

4. 数组常见操作

（1）遍历

public static void print(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        System.out.println("arr[" + i + "]=" + arr[i]);
    }
}

（2）最值

public static int max(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

（3）排序

选择排序：

public static void sort(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;
            }
        }
    }
}

冒泡排序：

public static void sort(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;
            }
        }
    }
}

（4）查找

折半查找：效率很高，但前提是数组必须有序。

public static int search(int[] arr, int key) {
    int min = 0;
    int max = arr.length - 1;
    int mid;
    while (min <= max) {
        mid = (min + max) / 2;
        if (key > arr[mid]) {
            min = mid + 1;
        } else if (key < arr[mid]) {
            max = mid - 1;
        } else {
            return mid;
        }
    }
    return -1;
}

向有序数组插入元素（保持有序）：

public static int insert(int[] arr, int key) {
    int min = 0;
    int max = arr.length - 1;
    int mid;
    while (min <= max) {
        mid = (min + max) / 2;
        if (key > arr[mid]) {
            min = mid + 1;
        } else if (key < arr[mid]) {
            max = mid - 1;
        } else {
            return mid;
        }
    }
    return min;
}

5. 进制转换

十进制 → 十六进制：

public static void toHex(int num) {
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < (32 / 4); i++) {
        int temp = num & 15;
        if (temp > 9) {
            sb.append((char) (temp - 10 + 'A'));
        } else {
            sb.append(temp);
        }
        num = num >>> 4;
    }
    System.out.println(sb.reverse());
}

十进制 → 任意进制：

public static void toBinary(int num) {
    transform(num, 1, 1);
}

public static void toOctal(int num) {
    transform(num, 7, 3);
}

public static void toHex(int num) {
    transform(num, 15, 4);
}

public static void transform(int num, int base, int offset) {
    char[] chs = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8',
            '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    char[] arr = new char[32];
    int pos = arr.length - 1;
    while (num != 0) {
        int temp = num & base;
        arr[pos] = chs[temp];
        pos--;
        num = num >>> offset;
    }
    for (int i = pos + 1; i < arr.length; i++) {
        System.out.print(arr[i]);
    }
}

6. 二维数组

int[][] arr = new int[3][];
arr[0] = new int[3];
arr[1] = new int[2];
arr[2] = new int[1];

System.out.println(arr.length);        // 二维数组的长度
System.out.println(arr[0].length);     // 第一个一维数组的长度
System.out.println(arr[1].length);     // 第二个一维数组的长度
System.out.println(arr[2].length);     // 第三个一维数组的长度

for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.println(arr[i][j]);
    }
}