java入门基础笔记语法篇（3）

一、 注释

什么是注释

•  注释定义：注释是写在程序中对代码进行解释说明的文字，方便自己和他人查看以理解程序。

Java注释的三种写法：

• 单行注释：以“//”开头，注释内容只能写一行。
• 多行注释：以“/*”开头，“*/”结尾，中间可有多行注释内容。
• 文档注释：以“/**”开头，“*/”结尾，通常用在类和方法上方。 并给出了包含三种注释写法的代码示例。

/**
 * 这是一个文档注释，通常用在类和方法上方
 */
public class HelloWorld {
    public static void main(String[] args) {
        // 这是一个单行注释，有效范围是从//开始到当前行结尾
        System.out.println("HelloWorld");
        /*
         这是一个
         多行注释
         */
        System.out.println("HelloWorld");
    }
}

注释的特点 

注释只在代码编写阶段起作用，编译后的.class文件中没有注释，注释不会影响程序执行。

二、第一个 Java 程序

1.创建 Java 源文件

创建一个新的文件，命名为 HelloWorld.java。文件名必须与类名相同，并且后缀名为 .java。

2.编写代码

在 HelloWorld.java 中输入以下代码：

// 这是一个 Java 类，类名必须与文件名相同
public class HelloWorld {
    // 这是主方法，程序的入口点
    public static void main(String[] args) {
        // 这行代码会在控制台输出 "Hello, World!"
        System.out.println("Hello, World!");
    }
}

掌握java中输出常见字面量程序

//定义一个名为 LiteralOutputExample 的公共类，
//在 Java 中，一个 Java 文件中可以有多个类，但只能有一个公共类，且该公共类的名称必须与文件名相同。
//这里我们将通过这个类来演示 Java 中各种常见字面量的使用和输出。
public class LiteralOutputExample {

    /**
     * 程序的入口方法，Java 虚拟机（JVM）在运行 Java 程序时会从这个方法开始执行。
     * 该方法是静态方法（static），意味着它属于类本身，而不是类的某个实例对象，
     * 这样 JVM 可以直接调用而无需创建类的实例。
     * 参数 args 是一个字符串数组，用于接收从命令行传递给程序的参数。
     */
    public static void main(String[] args) {

        // --------------- 整数字面量 ---------------
        // 整数字面量表示整数数值，在 Java 中有多种表示形式。

        // 十进制整数，这是最常见的整数表示方式，直接书写数字即可。
        // 这里定义了一个 int 类型的变量 integerLiteral1，并将十进制整数 100 赋值给它。
        int integerLiteral1 = 100;
        // 负的十进制整数，在数字前加上负号表示负数。
        // 定义 int 类型变量 integerLiteral2，并赋值为 -20。
        int integerLiteral2 = -20;

        // 使用 System.out.println 方法输出提示信息，表明下面要输出整数字面量。
        System.out.println("整数字面量:");
        // 输出十进制整数 integerLiteral1 的值。
        System.out.println("十进制: " + integerLiteral1);
        // 输出负的十进制整数 integerLiteral2 的值。
        System.out.println("负数: " + integerLiteral2);

        // 八进制整数，以 0 开头，后面跟由 0 - 7 组成的数字序列。
        // 这里的 012 是八进制表示，转换为十进制是 1 * 8 + 2 = 10。
        int octalLiteral = 012;
        // 输出八进制整数转换为十进制后的结果。
        System.out.println("八进制: " + octalLiteral);

        // 十六进制整数，以 0x 或 0X 开头，后面可以跟 0 - 9、a - f 或 A - F 组成的数字序列。
        // 这里的 0x1F 转换为十进制是 1 * 16 + 15 = 31。
        int hexLiteral = 0x1F;
        // 输出十六进制整数转换为十进制后的结果。
        System.out.println("十六进制: " + hexLiteral);

        // 二进制整数，以 0b 或 0B 开头，后面跟由 0 和 1 组成的数字序列。
        // 这里的 0b1010 转换为十进制是 1 * 2^3 + 0 * 2^2 + 1 * 2^1 + 0 * 2^0 = 10。
        int binaryLiteral = 0b1010;
        // 输出二进制整数转换为十进制后的结果。
        System.out.println("二进制: " + binaryLiteral);

        // --------------- 浮点数字面量 ---------------
        // 浮点数字面量用于表示小数数值，在 Java 中有单精度和双精度之分。

        // 双精度浮点数字面量，默认情况下，Java 中的小数常量就是 double 类型。
        // 这里定义了一个 double 类型的变量 doubleLiteral，并赋值为 3.14。
        double doubleLiteral = 3.14;
        // 单精度浮点数字面量，需要在数字后面加上 f 或 F 来明确表示这是一个 float 类型的常量。
        // 定义 float 类型变量 floatLiteral，并赋值为 2.718f。
        float floatLiteral = 2.718f;

        // 输出提示信息，表明下面要输出浮点数字面量。
        System.out.println("\n浮点数字面量:");
        // 输出双精度浮点数字面量的值。
        System.out.println("双精度: " + doubleLiteral);
        // 输出单精度浮点数字面量的值。
        System.out.println("单精度: " + floatLiteral);

        // --------------- 字符字面量 ---------------
        // 字符字面量表示单个字符，用单引号括起来。

        // 普通英文字符的字符字面量，这里定义了一个 char 类型的变量 charLiteral1，并赋值为字符 'A'。
        char charLiteral1 = 'A';
        // 中文字符的字符字面量，同样用单引号括起来，定义 char 类型变量 charLiteral2 并赋值为 '中'。
        char charLiteral2 = '中';
        // 转义字符，用于表示一些特殊的字符，如换行符、制表符等。
        // 这里的 '\n' 表示换行符，定义 char 类型变量 charLiteral3 并赋值为 '\n'。
        char charLiteral3 = '\n';

        // 输出提示信息，表明下面要输出字符字面量。
        System.out.println("\n字符字面量:");
        // 输出普通英文字符字面量的值。
        System.out.println("普通字符: " + charLiteral1);
        // 输出中文字符字面量的值。
        System.out.println("中文字符: " + charLiteral2);
        // 先输出提示信息，表明要演示换行转义字符。
        System.out.print("转义字符（换行）: ");
        // 输出包含换行符的字符串，实现换行效果。
        System.out.print("这是换行前的内容" + charLiteral3);
        // 输出换行后的内容。
        System.out.println("这是换行后的内容");

        // --------------- 字符串字面量 ---------------
        // 字符串字面量表示由零个或多个字符组成的序列，用双引号括起来。

        // 普通的字符串字面量，定义一个 String 类型的变量 stringLiteral1，并赋值为 "Hello, World!"。
        String stringLiteral1 = "Hello, World!";
        // 空字符串字面量，即不包含任何字符的字符串，定义 String 类型变量 stringLiteral2 并赋值为空字符串。
        String stringLiteral2 = "";

        // 输出提示信息，表明下面要输出字符串字面量。
        System.out.println("\n字符串字面量:");
        // 输出普通字符串字面量的值。
        System.out.println("普通字符串: " + stringLiteral1);
        // 调用 String 类的 length() 方法获取空字符串的长度，结果为 0，并输出该长度。
        System.out.println("空字符串长度: " + stringLiteral2.length());

        // --------------- 布尔字面量 ---------------
        // 布尔字面量只有两个值：true 和 false，用于表示逻辑上的真和假。

        // 定义一个 boolean 类型的变量 trueLiteral，并赋值为 true，表示逻辑真。
        boolean trueLiteral = true;
        // 定义一个 boolean 类型的变量 falseLiteral，并赋值为 false，表示逻辑假。
        boolean falseLiteral = false;

        // 输出提示信息，表明下面要输出布尔字面量。
        System.out.println("\n布尔字面量:");
        // 输出布尔字面量 true 的值。
        System.out.println("真: " + trueLiteral);
        // 输出布尔字面量 false 的值。
        System.out.println("假: " + falseLiteral);

        // --------------- 空字面量 ---------------
        // 空字面量只有一个值：null，表示对象引用不指向任何对象。

        // 定义一个 Object 类型的变量 nullLiteral，并赋值为 null。
        // Object 是 Java 中所有类的基类，可以用来引用任何类型的对象。
        Object nullLiteral = null;

        // 输出提示信息，表明下面要输出空字面量。
        System.out.println("\n空字面量:");
        // 输出空字面量的值，会显示为 null。
        System.out.println("空对象引用: " + nullLiteral);
    }
}

输出结果：

整数字面量:
十进制: 100
负数: -20
八进制: 10
十六进制: 31
二进制: 10

浮点数字面量:
双精度: 3.14
单精度: 2.718

字符字面量:
普通字符: A
中文字符: 中
转义字符（换行）: 这是换行前的内容
这是换行后的内容

字符串字面量:
普通字符串: Hello, World!
空字符串长度: 0

布尔字面量:
真: true
假: false

空字面量:
空对象引用: null

 字面量：字面量是程序中能直接书写的数据，Java 程序中数据的书写格式。

三、数据类型

java是一种强类型语言。这就意味着必须为每个变量声明一种类型，在java中，一共有8种基本类型（primitive type）,其中有4种整型、2种浮点类型，1种用于表示Unicode编码的字符单元的字符类型char,和一种用于表示真值的boolean类型。

整型

 代码示例：

public class DataTypeExample {
    public static void main(String[] args) {
        // 定义byte类型变量
        byte b = 10;
        // 定义short类型变量
        short s = 100;
        // 定义int类型变量
        int i = 1000;
        // 定义long类型变量，需要在数字后面加上L或l
        long l = 10000000000L;

        System.out.println("byte类型变量b的值是：" + b);
        System.out.println("short类型变量s的值是：" + s);
        System.out.println("int类型变量i的值是：" + i);
        System.out.println("long类型变量l的值是：" + l);
    }
}

public class DataTypeExample {
    public static void main(String[] args) {
        // 定义float类型变量，需要在数字后面加上F或f
        float f = 3.14f;
        // 定义double类型变量
        double d = 3.141592653589793;

        System.out.println("float类型变量f的值是：" + f);
        System.out.println("double类型变量d的值是：" + d);
    }
}

• double表示这种类型的数值精度是float类型的两倍（有人称之为双精度数值）。
• 绝大部分应用程序都采用double类型。
• 实际上，只有很少的情况适合使用float类型。
• float类型的数值有一个后缀F或f（例如，3.14F）。没有后缀F的浮点数值（如
  3.14）默认为double类型。当然，也可以在浮点数值后面添加后缀D或d（例如，
  3.14D）。

char类型

char 类型：在 Java 中，char 类型用于表示单个字符，它在内存中占用 16 位（2 个字节），采用的是 Unicode 编码。这意味着 char 类型可以直接表示一个 Unicode 字符。

char类型原本用于表示单个字符。不过，现在情况已经有所变化。如今，有些 Unicode字符可以用一个char值描述，另外一些Unicode字符则需要两个char值。

Unicode：Unicode 是一种字符编码标准，它为世界上几乎所有的字符都分配了一个唯一的编号（码点），其目的是为了统一地表示和处理各种语言的文字。码点通常用十六进制表示，例如，字符 'A' 的 Unicode 码点是 U+0041。在 Java 中，可以通过转义序列 \u 后跟四位十六进制数来表示一个 Unicode 字符。例如：

char c = '\u0041';
System.out.println(c);

 上述代码同样将字符 'A' 赋值给 char 变量 c，这里使用了 Unicode 转义序列。

• UTF-16编码采用不同长度的编码表示所有Unicode码点。
• 在基本的多语言级别中， 每个字符用16位表示，通常被称为代码单元（code unit）；而辅助字符采用一对连续的代码单元进行编码。
• 这样构成的编码值落入基本的多语言级别中空闲的2048 字节内，通常被称为替代区域（surrogate area）［U+D800～U+DBFF用于第一个代码单元，U+DC00～U+DFFF用于第二个代码单元］。 

• 在Java中，char类型描述了UTF-16编码中的一个代码单元。
• 我们强烈建议不要在程序中使用char类型，除非确实需要处理UTF-16代码单元。最好将字符串作为抽象数据类型处理。

boolean类型

public class DataTypeExample {
    public static void main(String[] args) {
        // 定义boolean类型变量
        boolean b = true;

        System.out.println("boolean类型变量b的值是：" + b);
    }
}