【JavaSE 知识框架】02 Java基本语法

最新推荐文章于 2024-06-20 15:02:17 发布

深山老Java

最新推荐文章于 2024-06-20 15:02:17 发布

阅读量239

点赞数

分类专栏： JavaSE - 编程技术文章标签： java 开发语言 intellij-idea 后端

本文链接：https://blog.csdn.net/woailuo8214/article/details/121181772

版权

JavaSE - 编程技术专栏收录该内容

19 篇文章 3 订阅

订阅专栏

第02章 Java基本语法

创作日期：2021-11-02

1.关键字与保留字

1.1 关键字（keyword）的定义与特点

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

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

1.2 保留字（reserved word）

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

2.标识符

2.1 标识符

Java对各种变量，方法和类等要数命名时使用的字符序列称为标识符

技巧：凡是自己可以起名字的地方都叫标识符

2.2 合法标识符定义规则

由26个英文字母大小写，0-9，_或$组成
数字不可以开头
不可以使用关键字和保留字，但能包含关键字和保留字
Java中严格区分大小写，长度无限制
标识符不能包含空格

2.3 Java中的名称命名规范

包名：多单词组成时所有字幕都小写：xxyyzz
类名，接口名：多单词组成时，所有单词的首字母大写：XxYyZz
变量名，方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxYyZz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XX_YY_ZZ
命名最好要做到“见名知意”

3.变量

3.1 变量的概念

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

变量是程序中最基本的存储单元；包含变量类型，变量名和存储的值

3.2 变量的作用

用于在内存中保存数据

3.3 使用变量注意

Java中每个变量必须先声明，后使用

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

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

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

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

3.4 变量的分类

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

数据类型分为基本数据类型（primitive type）和引用数据类型（reference type）

基本数据类型：

数值型：整数类型（byte，short，int，long）和浮点类型（float，double）

字符型（char）

布尔型（boolean）

引用数据类型：

类（class）

接口（interface）

数组（[ ]）

3.5 变量类型的介绍

整数类型：byte，short，int，long：

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。

Java的整型常量默认为 int 型，声明 long 型常量须后加 ‘l’ 或 ‘L’

Java程序中变量通常声明为 int 型，除非不足以表示较大的数，才使用 long

bit：计算机中的最小存储单位。byte：计算机中基本存储单元。

浮点类型：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类型是可以进行运算的。因为它们都对应有 Unicode 码。字符型变量的三种表现形式：

字符常量是用单引号（' '）括起来的单个字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';

Java中还允许使用转义字符 ‘\’ 来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’；// '\n' 表示换行符。

直接使用 Unicode 值来表示字符常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。

布尔类型：boolean：

字符串类型：String：

String不是基本数据类型，属于引用数据类型，翻译为：字符串，使用方式与基本数据类型一致。例如：String str = "abcd";

声明String类型变量时，使用一对 " "，一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：str = str+"xyz"; int n = 100; str = str + n; 则 str 的值为 "abcxyz100" 。

3.6 变量的简单练习

4.了解编码类型

4.1 了解 ASCII 编码

在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，因此 8个二进制位就可以组合出 256 种状态，这称为一个字节（byte）。一个字节一共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从 0000000 到 1111111。
ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格 “SPACE”是32（二进制00100000），大写字母A是 65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。
缺点：不能表示所有字符。相同的编码表示的字符不一样。

4.2 了解 Unicode 编码

乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，想要打开一个文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。
Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。
Unicode的缺点：Unicode只规定了符号的二进制代码，却没有规定这个二进制代码如何存储：无法区别Unicode 和 ASCII：计算机无法区别三个字节表示一个符号还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果 unicode 统一规定，每个字符用三个或四个字节表示，那么每个英文字母前都必须有二到三个字节是0，对于存储空间说是极大的浪费。

4.3 了解 UTF-8 编码

UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。
UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度。
UTF-8 的编码规则：
对于单字节的 UTF-8 编码，该字节的最高位为0，其余7位用来表示对字符进行编码（等同于ASCII码）。
对于多字节的 UTF-8 编码，如果编码包含n个字节，那么第一个字节的前n位为1，第一个字节的第 n+1位为0，该字节的剩余各位用来对字符进行编码。在第一个字符之后的所有字节，都是最高两位为“10”，其余6为用来对字符进行编码。

5.基本类型数据之间的转换规则

5.1 自动类型转换

5.2 强制类型转换

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

5.3 变量运算规则的两个特殊情况

6.进制

6.1 关于进制

所有数字在计算机底层都以二进制形式存在。对于整数，有四种表示方式：

二进制（binary）：0，1，满2进1 以 0b 或 0B开头。

八进制（octall）：0-7，满8进1，以数字0开头表示。

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

十六进制（hex）：0-9及A-F，满16进1，以0x或0X开头表示。此处A-F不区分大小写。如：0X21AF + 1 = 0x21B0

6.2 二进制

Java整数常量默认是int类型，当使用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位。计算机以二进制补码的方式保存所有的整数，正数的原码，反码，补码都相同，负数的补码是其反码 +1。二进制的整数有如下三种形式：

原码：直接将一个数值换成二进制数。最高位是符号位。

负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。

负数的补码：其反码加1。

7.运算符

7.1 运算符的概述

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

分为：算术运算符赋值运算符比较运算符（关系运算符）逻辑运算符位运算符三元运算符。

7.2 算术运算符

7.3 赋值运算符

符号：=；当” =“两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理，支持连续赋值。

扩展赋值运算符：+=，-=，*=，/=，%=

7.4 比较运算符

比较运算符的结果都是boolean型数据，也就是要不 true，要不 false。

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

7.5 逻辑运算符

用于连接布尔型表达式，Java中不可以写成 3 < x < 6，应该写成 x > 3 & x < 6。

”&“和”&&“ 的区别：”&“，左边无论真假，右边都进行运算；”&&“，如果左边为真，右边参与运算，如果左边为假，那右边不参与运算。

”|“和”||“的区别同理，||表示：当左边为真，右边不参与运算。

异或（^）和（|）的不同之处是：当左右都为true时，结果为false。

7.6 位运算符

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

7.7 三元运算符

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

条件表达式为 true，执行表达式1；条件表达式为false，执行表达式2。

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

三元运算符与 if-else的区别：

三元运算符可简化if-else语句
三元运算符必须返回一个结果
if后的代码块可有多个语句
如果程序既可以使用三元运行算符，有可以使用if-else结构，那么优先选择三元运算符。原因：简洁，执行效率高。

7.8 运算符的优先级

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

8.程序流程控制

8.1 概述

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：

顺序结构：程序从上到下逐行的执行，中间没有任何判断和跳转；
分支结构：根据条件，选择性的执行某段代码，有 if-else 和 switch-case两种分支语句；
循环结构：根据循环条件，重复性的执行某段代码，有 while，do...while，for三种循环语句，注：JDK1.5提供了foreach循环，方便了遍历集合，数组元素。

8.2 顺序结构

分支语句：if-else结构

第一种格式：if( 条件表达式 ){ 执行代码块 } 一选一

第二种格式：if( 条件表达式 ){ 执行代码块1 }else{ 执行代码块2 } 一选二

第三种格式：if( 条件表达式 ){ 执行代码块1 }else if( 条件表达式2 ){ 执行代码块2 }else if( 条件表达式3 ){ 执行代码块3 }else{ 执行代码块4 } 多选多

8.3 练习

分支语句：switch-case 结构

switch语句有关规则：

switch（表达式）中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举（jdk 5.0），String（jdk 7.0）

case子句中的值必须是常量，不能是变量名或不确定的表达式值

同一个switch语句，所有case子句中的常量值互不相同

break语句用来执行玩一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾

default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default

import java.util.Scanner;

public class Person {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        int j = i % 12;
        switch (j){
            case 4:
                System.out.println("Rat："+"鼠");
                break;
            case 5:
                System.out.println("Ox："+"牛");
                break;
            case 6:
                System.out.println("Tiger："+"虎");
                break;
            case 8:
                System.out.println("Dragon："+"龙");
                break;
            case 9:
                System.out.println("Snake："+"蛇");
                break;
            case 10:
                System.out.println("Horse："+"马");
                break;
            case 11:
                System.out.println("Sheep："+"羊");
                break;
            case 0:
                System.out.println("Monkey："+"猴");
                break;
            case 1:
                System.out.println("Rooster："+"鸡");
                break;
            case 2:
                System.out.println("Dog："+"狗");
                break;
            case 3:
                System.out.println("Pig："+"猪");
                break;
            default:
                System.out.println("输入有误");
        }
    }
}

8.4 循环结构

循环语句的四个组成部分：初始化部分（init_statement），循环条件部分（test_exp），循环体部分（body_statement），迭代部分（alter_statement）

循环结构：for循环：

for循环是编程语言中一种循环语句，而循环语句由及循环体循环的判定条件两部分组成，其表达式为：for（单次表达式;条件表达式;末尾循环体）{中间循环体；}。

public class Person {
    public static void main(String[] args) {
        for (int i = 0; i < 150; i++) {
            if (i % 3 == 0) {
                System.out.println("foo");
            } else if (i % 5 == 0) {
                System.out.println("biz");
            } else if (i % 7 == 0) {
                System.out.println("baz");
            }
            System.out.println();
        }
    }
}

循环结构：while循环：

while是j计算机的一种基本循环模式。当满足条件时进入循环，进入循环后，当条件不满足时，跳出循环。while语句的一般表达式为：while（循环条件）{循环体}。循环条件一定不能丢，丢了会导致死循环状态。

循环结构：do while循环：

do...while 循环是while循环的变体。在检查while()条件是否为真之前，该循环首先会执行一次do{}之内的语句，然后在while()内检查条件是否为真，如果条件为真的话，就会重复do...while这个循环,直至while()为假。

import java.util.Scanner;

public class Person {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int positiveNumber = 0;//记录正数的个数
        int negativeNumber = 0;//记录负数的个数
        while (true){
            int number = scanner.nextInt();
            //判断number的正负情况
            if (number>0){
                positiveNumber++;
            }else if(number<0){
                negativeNumber++;
            }else {
                break;
            }
        }
        System.out.println("输入正数的个数为："+positiveNumber);
        System.out.println("输入负数的个数为："+negativeNumber);
    }
}

8.5 嵌套循环

将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环。其中，for，while，do...while均可以作为外层循环或内层循环。外层循环：循环结构B；内层循环：循环结构A。

实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

内层循环结构循环一遍，只相当于外层循环循环体执行了一次，假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行可m*n次。

技巧：外层循环控制行数，内层循环控制列数

九九乘法表

100以内的所有质数质数：素数，只能被1和它本身整除的自然数

import org.junit.Test;

public class Demo {

    @Test
    public void primeNumberTest() {

        boolean flag = true;

        for (int i = 2; i <= 100; i++) {
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                //为什么要定义变量flag？
                //因为只能被1和它本身整除的才是质数，而如果if的判断条件为true
                //则这个数不是质数。因为进入if判断条件，意味着这个数能被2到i-1的某个数整除
                    flag = false;
                }
            }
            if (flag) {
                System.out.print(i+",");
            }
        //因为内层循环会把flag的值设置为false
        //如果没有下面的语句，flag的值在进入内层循环之后将永远为false
            flag = true;
        }
    }
}

8.6 特殊关键字的使用 break，continue，return

break

continue

continue 只能使用在循环结构中

continue 语句用于跳过其所在循环语句块的一次执行，继续下一次循环

continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

return

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

9.综合项目 - 家庭记账软件

package com.oceanstar;

import java.util.Scanner;

public class FamilyAccount {

    private static Scanner scanner = new Scanner(System.in);

    // 一定能得到n位数
    public static String readKeyBoard(int limit) {
        String line = "";

        while (scanner.hasNext()) {
            line = scanner.nextLine();
            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }

    public static String readString(){
        // 因为这个函数得到的已经是小于等于8长度的字符串了，所以不需要处理，直接返回即可
        return readKeyBoard(8);  // 各个函数一定是相对封闭的，写函数的时候要确保这个函数独立正确
    }
    // 直到输入正确才跳出循环: 这里它确保了输入正确
    private static char readMenuSelection(){
        char c;
        for (; ; ) {
            String str = readKeyBoard(1);
            c = str.charAt(0);
            if (c != '1' && c != '2' && c != '3' && c != '4') {
                System.out.print("选择错误，请重新输入：");
            } else
                break;
        }
        return c;
    }

    // 确保能够得到'Y', 'y', 'N', 'n'
    private static char readConfirmSelection(){
        char c;
        for (; ; ) {
            String str = readKeyBoard(1);
            c = str.charAt(0);
            if (c != 'Y' && c != 'y' && c != 'N' && c != 'n') {
                System.out.print("选择错误，请重新输入：");
            } else
                break;
        }
        return c;
    }

    // 直到输入正确才能跳出循环
    private static int readNumber(){
        int i = 0;
        for (; ; ) {
            String str = readKeyBoard(4);

            try {
                i = Integer.parseInt(str);
                if (i < 0){
                    throw new Exception("必须输入一个正整数");
                }
                break;
            }catch (Exception e){
                System.out.print("必须输入一个正整数:");
            }
        }
        return i;
    }


    public static void main(String[] args) {
        int balance = 10000;
        String details = "";
        while (true){
            System.out.print("-----------------家庭收支记账软件-----------------\n" +
                    "1 收支明细\n" +
                    "2 登记收入\n" +
                    "3 登记支出\n" +
                    "4 退 出\n" +
                    "请选择(1-4)：");
            char c = readMenuSelection(); // 工具一定是正确的输出
            switch (c){
                case '1':
                    System.out.println("-----------------当前收支明细记录-----------------");
                    System.out.println("收支\t账户金额\t收支金额\t说明");
                    System.out.println(details);
                    System.out.println("---------------------------------------------");
                    break;
                case '2':
                    System.out.println("----------------------本次收入-----------------------");
                    System.out.print("本次收入金额:");
                    int t = readNumber();// 工具得到的数一定是正整数
                    balance = balance + t;
                    System.out.print("本次收入说明:");
                    String s = readString();
                    details = details + "收入\t" + balance + "\t" + t + "\t" + s + "\n";
                    System.out.println("---------------------登记完成-------------------");
                    break;
                case '3':
                    System.out.println("----------------------本次支出-----------------------");
                    System.out.print("本次支出金额:");
                    int t1 = readNumber();// 工具得到的数一定是正整数
                    if (t1 > balance){
                        System.out.println("余额不足");
                        break;
                    }
                    balance = balance - t1;
                    System.out.print("本次支出说明:");
                    String s1 = readString();
                    details = details + "支出\t" + balance + "\t" + t1 + "\t" + s1 + "\n";
                    System.out.println("---------------------登记完成-------------------");
                    break;
                case '4':
                    System.out.print("确认是否退出(Y/N)：");
                    char d = Character.toLowerCase(readConfirmSelection());
                    if (d == 'y'){
                        return;
                    }
                    break;
            }
        }
    }
}