Java基础

关键字与保留字

关键字(key word)

关键字(keyword)的定义和特点
- 定义:被Java语言赋予了特殊含义，用做专门用途的字符串(单词) 
- 特点:关键字中所有字母都为小写
- 官方地址: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

保留字(reserved word)

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

标识符(Identifier)

标识符

标识符
- Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
- 技巧:凡是自己可以起名字的地方都叫标识符。
定义合法标识符规则
- 由26个英文字母大小写，0-9 ，_或 $ 组成
- 数字不可以开头
- 不可以使用关键字和保留字，但能包含关键字和保留字
- Java中严格区分大小写，长度无限制
- 标识符不能包含空格。

Java中的命名规范

Java中的名称命名规范:
- 包名: 多单词组成时所有字母都小写: xxxyyyzzz
- 类名、接口名: 多单词组成时，所有单词的首字母大写: XxxYyyZzz
- 变量名、方法名:多单词组成时，第一个单词首字母小写, 第二个单词开始每个单词首字母大写: xxxYyyZzz
- 常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ

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

java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

变量

变量的概念:
- 内存中的一个存储区域
- 该区域的数据可以在同一类型范围内不断变化
- 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

变量的作用:
- 用于在内存中保存数据

使用变量注意

　　1. Java中每个变量必须先声明, 后使用

　　2. 使用变量名来访问这块区域的数据

　　3. 变量的作用域:其定义所在的一对{ }内

　　4. 变量只有在其作用域内才有效

　　5. 同一个作用域内，不能定义重名的变量

声明变量
    语法:<数据类型> <变量名称>
    例如:int var;

变量的赋值
    语法:<变量名称> = <值>
    例如:var = 10;

声明和赋值变量
    语法: <数据类型> <变量名> = <初始化值>
    例如:int var = 10;

变量的分类-按数据类型

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

变量的分类-按声明位置

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

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

同: 都有生命周期

异: 局部变量除形参外, 需显示初始化

整数类型(byte、short、int、long)

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
java的整型常量默认为int型，声明long型常量须后加'l'或'L'
java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

public class Variable Test{
    public static void main(String[] args){
        int number1;
        number1 = 10;
        
        int number2;
        number2 = 20;
       
        int number3;
        number3 = number1 + number2;
        System.out.println("Number3=" + number3);

        int number4 = 50;
        int number5 = number4 - number3;
        System.out.println("Number5=" + number5);
    }
}

浮点类型(float、double)

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
浮点型常量有两种表示形式:
- 十进制数形式:如:5.12 512.0f .512 (必须有小数点) 
- 科学计数法形式:如:5.12e2 512E2 100E-2
float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double:双精度，精度是float的两倍。通常采用此类型。
Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

字符类型(char)

char型数据用来表示通常意义上“字符”(2字节)
Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母, 一个汉字, 或其他书面语的一个字符。 
字符型变量的三种表现形式:
- 字符常量是用单引号(‘ ’)括起来的单个字符。例如:char c1 = 'a'; char c2 = '中'; char c3 = '9';
- Java中还允许使用转义字符‘’来将其后的字符转变为特殊字符型常量。例如:char c3 = ‘ ’; // ' '表示换行符
- 直接使用 Unicode 值来表示字符型常量:‘uXXXX’。其中，XXXX代表一个十六进制整数。如:u000a 表示。

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

布尔类型(boolean)

boolean 类型用来判断逻辑条件，一般用于程序流程控制:
- if条件控制语句;
- while循环控制语句;
- do-while循环控制语句;
- for循环控制语句;
boolean类型数据只允许取值true和false，无null
- 不可以使用0或非0的整数替代false和true，这点和C语言不同。
- Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替:true用1表示，false 用0表示。———《java虚拟机规范 8版》

基本数据类型转换

自动类型转换:容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为:

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
boolean类型不能与其它数据类型运算。
当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。

public class StringTest {
    public static void main(String[] args) { 
        int no=10;
        String str = "abcdef";
        String str1 = str + “xyz” + no;

        str1 = str1 + "123"; 
        char c = '国';

        double pi = 3.1416; 
        str1 = str1 + pi;
        boolean b = false; 
        str1 = str1 + b; 
        str1 = str1 + c;
        System.out.println("str1 = " + str1); 
    }
}

强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符:()，但可能造成精度降低或溢出,格外要注意。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。

String a = “43”; int i = Integer.parseInt(a);

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

运算符

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

算术运算符
赋值运算符 
比较运算符(关系运算符) 
逻辑运算符
位运算符
三元运算符

算术运算符

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

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

例如:int x=3510; x= x/1000*1000; x的结果是3000

“+”除字符串相加功能外，还能把非字符串转换成字符串.

例如: System.out.println(“5+5=”+5+5); //打印结果是5+5=55

public class SignTest{
    public static void main(String[] args){
        int i1 = 10;
        int i2 = 20;
        int i = i1++; 
        System.out.print(“i=”+i); 
        System.out.println(“i1=”+i1); 
        i = ++i1; 
        System.out.print(“i=”+i); 
        System.out.println(“i1=”+i1); 
        i = i2--; 
        System.out.print(“i=”+i); 
        System.out.println(“i2=”+i2); 
        i = --i2; 
        System.out.print(“i=”+i); 
        System.out.println(“i2=”+i2);
} }

符号:=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
- 支持连续赋值。
扩展赋值运算符: +=, -=, *=, /=, %=

比较运算符

比较运算符的结果都是boolean型，也就是要么是true，要么是false

比较运算符“==”不能误写成“=”

public class Test{
    public static void main(String[] args){
        boolean b1 = false;

        if(b1==true){
            System.out.println("结果为真");
        } else{
            System.out.println("结果为假");
        }
    }
}

逻辑运算符

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

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
“&”和“&&”的区别:
- 单&时，左边无论真假，右边都进行运算; 
- 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，
- ||表示:当左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是:当左右都为true时，结果为false。

public class Test{

    public static void main(String[] args) {
        
        boolean x = true;
        boolean y = false;
        short z = 42;

        if ((z++==42)&&(y=true)){
            z++;
        }
        if ((x=false) || (++z==45)) {
            z++;
        }

        System.out.println("z=" + z);
    }
}

位运算符

位运算是直接对整数的二进制进行的运算

三元运算符

格式

(条件表达式)?表达式1:表达式2;

条件表达式为true, 运算后的结果是表达式1
条件表达式为false, 运算后的结果是表达式2

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

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

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

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

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

运算符的优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表, 上一行运算符总优先于下一行。
只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

程序控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即:
- 顺序结构: 程序从上到下逐行地执行，中间没有任何判断和跳转
- 分支结构: 根据条件，选择性地执行某段代码。有if...else和switch-case两种分支语句
- 循环结构: 根据循环条件，重复性的执行某段代码。有while、do...while、for三种循环语句。

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

顺序结构

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

public class Test{
    int num1 = 12;
    int num2 = num1 + 2; }

// 错误形式:
public class Test{
    int num2 = num1 + 2; 
    int num1 = 12;
}

分支语句 - if-else语句

if的三种格式

if(条件表达式){
    执行代码块;
}

if(条件表达式){
    执行代码块1;
}else{
    执行代码块2;
}

if(条件表达式1){ 
    执行代码块1;
}else if (条件表达式2){
    执行代码块2;
...
}else{
    执行代码块n;
}

分支结构: if-else使用说明

条件表达式必须是布尔表达式(关系表达式或逻辑表达式)、布尔变量 
语句块只有一条执行语句时，一对{}可以省略，但建议保留
if-else语句结构，根据需要可以嵌套使用
当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略 
当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓, 当多个条件是“包含”关系时，“小上大下 / 子上父下”

public class AgeTest{
    public static void main(String args[]){
        int age = 75; 
        if (age< 0) {
            System.out.println("不可能!"); 
        } else if (age>250) {
            System.out.println("是个妖怪!"); 
        } else {
            System.out.println("年龄是:" + age);
        }      
    }
}

分支结构 - switch-case结构

switch(表达式){ 
    case 常量1:
        语句1;
        // break; 
    case 常量2:
        语句2;
        // break; 
        ......
    case 常量N: 
        语句N;
        // break; 
    default:
        语句;
        // break; 
}

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

switch(表达式)中表达式的值必须是下述几种类型之一:byte，short， char，int，枚举 (jdk 5.0)，String (jdk 7.0);
case子句中的值必须是常量，不能是变量名或不确定的表达式值;
同一个switch语句，所有case子句中的常量值互不相同;
break语句用来在执行完一个case分支后使程序跳出switch语句块;如果没有break，程序会顺序执行到switch结尾
default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default

循环结构

循环结构: 在某些条件满足的情况下，反复执行特定代码的功能 
循环语句分类: for 循环、while 循环、do-while 循环
循环语句的四个组成部分 
- 初始化部分(init_statement)
- 循环条件部分(test_exp) 
- 循环体部分(body_statement) 
- 迭代部分(alter_statement)

循环结构 - for循环

语法格式

for (1初始化部分; 2循环条件部分; 4迭代部分){ 
    3循环体部分;
}

执行过程:

1-2-3-4-2-3-4-2-3-4-.....-2

说明:
- 2循环条件部分为boolean类型表达式，当值为false时，退出循环
- 1初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔  4可以有多个变量更新，用逗号分隔

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

循环结构 - while循环

语法格式

1初始化部分
while(2循环条件部分){ 
    3循环体部分;
    4迭代部分; 
}

执行过程:

1-2-3-4-2-3-4-2-3-4-...-2

说明:
- 注意不要忘记声明4迭代部分。否则，循环将不能结束，变成死循环。 
- for循环和while循环可以相互转换

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

循环结构 - do-while循环

语法格式 1初始化部分;

1 初始化部分
do{
    3 循环部分
    4 迭代部分
}while(2 循环条件部分)

执行过程:

1-3-4-2-3-4-2-3-4-...2

说明:
- do-while循环至少执行一次循环体。

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

嵌套循环(多重循环)

将一个循环放在另一个循环体内，就形成了嵌套循环。其中， for ,while ,do...while均可以作为外层循环或内层循环。
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次

特殊关键字的使用 - break、continue

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

{ 
    ......
    break; 
    ......
}

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

label1: { ......
label2:     { ......
label3:         { ......
                    break label2; 
                    ......
                    }
               }
          }

public class BreakTest{
    public static void main(String args[]){
        for(int i = 0; i<10; i++){ if(i==3)
        break; 
        System.out.println(" i =" + i);
        }
    System.out.println("Game Over!");
    } 
}

continue语句
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
- continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

public class ContinueTese{
    public static void main(String[] args){
        for (int i = 0; i < 100; i++) { 
            if (i%10==0){
                continue;
                System.out.println(i)
        }
    }
}

return
- 并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束
- 与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内

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

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

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

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

很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的。