Java 程序基础

骑猪看日落 2024-03-17 14:23 11阅读 0赞

### 一、Java 程序基本结构 ###

我们先剖析一个完整的Java程序，它的基本结构是什么：

/**
     * 可以用来自动创建文档的注释
     */
    public class Hello {
        
        public static void main(String[] args) {
        
            // 向屏幕输出文本:
            System.out.println("Hello, world!");
            /* 多行注释开始
            注释内容
            注释结束 */
        }
    } // class定义结束

因为Java 是面向对象的语言，一个程序的基本单位就是 class，class 是关键字，这里定义的 class 名字就是 Hello：

public class Hello {
         
    // 类名是Hello
        // ...
    } //

类名要求：

*  类名必须以英文字母开头，后接字母，数字和下划线的组合
 *  习惯以大写字母开头

要注意遵守命名习惯，好的类命名：

*  Hello
 *  NoteBook
 *  VRPlayer

不好的类命名：

*  hello
 *  Good123
 *  Note\_Book
 *  \_World

注意到 public 是访问修饰符，表示该 class 是公开的。  
不写 public，也能正确编译，但是这个类将无法从命令行执行。  
在 class 内部，可以定义若干方法（method）：

public class Hello {
        
        public static void main(String[] args) {
         // 方法名是main
            // 方法代码...
        } // 方法定义结束
    }

方法定义了一组执行语句，方法内部的代码将会被依次顺序执行。

这里的方法名是main，返回值是void，表示没有任何返回值。

我们注意到public除了可以修饰class外，也可以修饰方法。而关键字static是另一个修饰符，它表示静态方法，后面我们会讲解方法的类型，目前，我们只需要知道，Java入口程序规定的方法必须是静态方法，方法名必须为main，括号内的参数必须是String数组。

方法名也有命名规则，命名和class一样，但是首字母小写：

好的方法命名：

*  main
 *  goodMorning
 *  playVR

不好的方法命名：

*  Main
 *  good123
 *  good\_morning
 *  \_playVR

在方法内部，语句才是真正的执行代码。Java的每一行语句必须以分号结束：

public class Hello {
        
        public static void main(String[] args) {
        
            System.out.println("Hello, world!"); // 语句
        }
    }

在Java程序中，注释是一种给人阅读的文本，不是程序的一部分，所以编译器会自动忽略注释。

Java有3种注释，第一种是单行注释，以双斜线开头，直到这一行的结尾结束：

// 这是注释...

而多行注释以/*星号开头，以*/结束，可以有多行：

/*
    这是注释
    blablabla...
    这也是注释
    */

还有一种特殊的多行注释，以/\**开头，以*/结束，如果有多行，每行通常以星号开头：

/**
     * 可以用来自动创建文档的注释
     * 
     * @auther liaoxuefeng
     */
    public class Hello {
        
        public static void main(String[] args) {
        
            System.out.println("Hello, world!");
        }
    }

这种特殊的多行注释需要写在类和方法的定义处，可以用于自动创建文档。

Java程序对格式没有明确的要求，多几个空格或者回车不影响程序的正确性，但是我们要养成良好的编程习惯，注意遵守Java社区约定的编码格式。

### 二、变量和数据类型 ###

什么是变量？

变量就是初中数学的代数的概念，例如一个简单的方程，x，y都是变量：

y = x 2 + 1 y = x^2 + 1 y=x2\+1

在Java中，变量分为两种：基本类型的变量和引用类型的变量。

我们先讨论基本类型的变量。

在 Java 中，变量必须先定义后使用，在定义变量的时候，可以给它一个初始值。例如：

int x = 1;

上述语句定义了一个整型int类型的变量，名称为x，初始值为1。

不写初始值，就相当于给它指定了默认值。默认值总是0。

来看一个完整的定义变量，然后打印变量值的例子：

public class Main {
        
        public static void main(String[] args) {
        
            int x = 100; // 定义int类型变量x，并赋予初始值100
            System.out.println(x); // 打印该变量的值
        }
    }

变量的一个重要特点是可以重新赋值。例如，对变量x，先赋值100，再赋值200，观察两次打印的结果：

public class Main {
        
        public static void main(String[] args) {
        
            int x = 100; // 定义int类型变量x，并赋予初始值100
            System.out.println(x); // 打印该变量的值，观察是否为100
            x = 200; // 重新赋值为200
            System.out.println(x); // 打印该变量的值，观察是否为200
        }
    }

注意到第一次定义变量x的时候，需要指定变量类型int，因此使用语句int x = 100;。而第二次重新赋值的时候，变量x已经存在了，不能再重复定义，因此不能指定变量类型int，必须使用语句x = 200;。

public class Main {
        
        public static void main(String[] args) {
        
            int n = 100; // 定义变量n，同时赋值为100
            System.out.println("n = " + n); // 打印n的值
    
            n = 200; // 变量n赋值为200
            System.out.println("n = " + n); // 打印n的值
    
            int x = n; // 变量x赋值为n（n的值为200，因此赋值后x的值也是200）
            System.out.println("x = " + x); // 打印x的值
    
            x = x + 100; // 变量x赋值为x+100（x的值为200，因此赋值后x的值是200+100=300）
            System.out.println("x = " + x); // 打印x的值
            System.out.println("n = " + n); // 再次打印n的值，n应该是200还是300？
       }
    }

我们一行一行地分析代码执行流程：

执行int n = 100;，该语句定义了变量n，同时赋值为100，因此，JVM在内存中为变量n分配一个“存储单元”，填入值100：  
![在这里插入图片描述][8cdaf3c127444290b362319b53d6848e.png]

执行n = 200;时，JVM把200写入变量n的存储单元，因此，原有的值被覆盖，现在n的值为200：

![在这里插入图片描述][812feb3ee7ec4988909a412f75167fcd.png]  
执行int x = n;时，定义了一个新的变量x，同时对x赋值，因此，JVM需要新分配一个存储单元给变量x，并写入和变量n一样的值，结果是变量x的值也变为200  
![在这里插入图片描述][acc6015b6f4b4e1cb576fcfb7e7dda09.png]

执行x = x + 100;时，JVM首先计算等式右边的值x + 100，结果为300（因为此刻x的值为200），然后，将结果300写入x的存储单元，因此，变量x最终的值变为300

![在这里插入图片描述][d8e5a96216de4f0f868efa920f0db8e0.png]  
可见，变量可以反复赋值。注意，等号=是赋值语句，不是数学意义上的相等，否则无法解释x = x + 100。

### 三、基本数据类型 ###

基本数据类型是CPU可以直接进行运算的类型。Java定义了以下几种基本数据类型：

*  整数类型：byte，short，int，long
 *  浮点数类型：float，double
 *  字符类型：char
 *  布尔类型：boolean
 *

Java定义的这些基本数据类型有什么区别呢？要了解这些区别，我们就必须简单了解一下计算机内存的基本结构。

计算机内存的最小存储单元是字节（byte），一个字节就是一个8位二进制数，即8个bit。它的二进制表示范围从00000000-11111111，换算成十进制是 0-255，换算成十六进制是00~ff。

内存单元从0开始编号，称为内存地址。每个内存单元可以看作一间房间，内存地址就是门牌号。

![在这里插入图片描述][5671770b516f4f819c57a83005077618.png]  
一个字节是1byte，1024字节是1K，1024K是1M，1024M是1G，1024G是1T。一个拥有4T内存的计算机的字节数量就是：

4T = 4 x 1024G
       = 4 x 1024 x 1024M
       = 4 x 1024 x 1024 x 1024K
       = 4 x 1024 x 1024 x 1024 x 1024
       = 4398046511104

不同的数据类型占用的字节数不一样。我们看一下Java基本数据类型占用的字节数：

![在这里插入图片描述][99a782de9905439e8237471f3085f578.png]  
byte恰好就是一个字节，而long和double需要8个字节。

#### 整型 ####

对于整型类型，Java只定义了带符号的整型，因此，最高位的bit表示符号位（0表示正数，1表示负数）。各种整型能表示的最大范围如下：

*  byte：-128 ~ 127
 *  short: -32768 ~ 32767
 *  int: -2147483648 ~ 2147483647
 *  long: -9223372036854775808 ~ 9223372036854775807

我们来看定义整型的例子：

public class Main {
        public static void main(String[] args) {
            int i = 2147483647;
            int i2 = -2147483648;
            int i3 = 2_000_000_000; // 加下划线更容易识别
            int i4 = 0xff0000; // 十六进制表示的16711680
            int i5 = 0b1000000000; // 二进制表示的512
            long l = 9000000000000000000L; // long型的结尾需要加L
        }
    }

特别注意：同一个数的不同进制的表示是完全相同的，例如15=0xf＝0b1111。

#### 浮点型 ####

浮点类型的数就是小数，因为小数用科学计数法表示的时候，小数点是可以“浮动”的，如1234.5可以表示成12.345x102，也可以表示成1.2345x103，所以称为浮点数。

下面是定义浮点数的例子：

float f1 = 3.14f;
    float f2 = 3.14e38f; // 科学计数法表示的3.14x10^38
    double d = 1.79e308;
    double d2 = -1.79e308;
    double d3 = 4.9e-324; // 科学计数法表示的4.9x10^-324

对于float类型，需要加上f后缀。  
浮点数可表示的范围非常大，float类型可最大表示3.4x1038，而double类型可最大表示1.79x10308。

#### 布尔类型 ####

布尔类型boolean只有true和false两个值，布尔类型总是关系运算的计算结果：

boolean b1 = true;
    boolean b2 = false;
    boolean isGreater = 5 > 3; // 计算结果为true
    int age = 12;
    boolean isAdult = age >= 18; // 计算结果为false

Java语言对布尔类型的存储并没有做规定，因为理论上存储布尔类型只需要1 bit，但是通常JVM内部会把boolean表示为4字节整数。

#### 字符类型 ####

字符类型char表示一个字符。Java的char类型除了可表示标准的ASCII外，还可以表示一个Unicode字符：

public class Main {
        public static void main(String[] args) {
            char a = 'A';
            char zh = '中';
            System.out.println(a);
            System.out.println(zh);
        }
    }

注意char类型使用单引号’，且仅有一个字符，要和双引号"的字符串类型区分开。

#### 引用类型 ####

除了上述基本类型的变量，剩下的都是引用类型。例如，引用类型最常用的就是String字符串：

String s = "hello";

引用类型的变量类似于C语言的指针，它内部存储一个“地址”，指向某个对象在内存的位置，后续我们介绍类的概念时会详细讨论。

#### 常量 ####

定义变量的时候，如果加上 final 修饰符，这个变量就变成了常量：

final double PI = 3.14; // PI是一个常量
    double r = 5.0;
    double area = PI * r * r;
    PI = 300; // compile error!

常量在定义时进行初始化后就不可再次赋值，再次赋值会导致编译错误。

常量的作用是用有意义的变量名来避免魔术数字（Magic number），例如，不要在代码中到处写3.14，而是定义一个常量。如果将来需要提高计算精度，我们只需要在常量的定义处修改，例如，改成 3.1416，而不必在所有地方替换 3.14。

根据习惯，常量名通常全部大写。

#### var关键字 ####

有些时候，类型的名字太长，写起来比较麻烦。例如：

StringBuilder sb = new StringBuilder();

这个时候，如果想省略变量类型，可以使用var关键字：

var sb = new StringBuilder();

编译器会根据赋值语句自动推断出变量sb的类型是StringBuilder。对编译器来说，语句：

var sb = new StringBuilder();

实际上会自动变成：

StringBuilder sb = new StringBuilder();

因此，使用var定义变量，仅仅是少写了变量类型而已。

#### 变量的作用范围 ####

在Java中，多行语句用\{ \}括起来。很多控制语句，例如条件判断和循环，都以\{ \}作为它们自身的范围，例如：

if (...) {
         // if开始
        ...
        while (...) {
         // while 开始
            ...
            if (...) {
         // if开始
                ...
            } // if结束
            ...
        } // while结束
        ...
    } // if结束

只要正确地嵌套这些\{ \}，编译器就能识别出语句块的开始和结束。而在语句块中定义的变量，它有一个作用域，就是从定义处开始，到语句块结束。超出了作用域引用这些变量，编译器会报错。举个例子：

{
        ...
        int i = 0; // 变量i从这里开始定义
        ...
        {
            ...
            int x = 1; // 变量x从这里开始定义
            ...
            {
                ...
                String s = "hello"; // 变量s从这里开始定义
                ...
            } // 变量s作用域到此结束
            ...
            // 注意，这是一个新的变量s，它和上面的变量同名，
            // 但是因为作用域不同，它们是两个不同的变量:
            String s = "hi";
            ...
        } // 变量x和s作用域到此结束
        ...
    } // 变量i作用域到此结束

定义变量时，要遵循作用域最小化原则，尽量将变量定义在尽可能小的作用域，并且，不要重复使用变量名。

### 四、整数运算 ###

Java的整数运算遵循四则运算规则，可以使用任意嵌套的小括号。四则运算规则和初等数学一致。例如：

public class Main {
        
        public static void main(String[] args) {
        
            int i = (100 + 200) * (99 - 88); // 3300
            int n = 7 * (5 + (i - 9)); // 23072
            System.out.println(i);
            System.out.println(n);
        }
    }

[8cdaf3c127444290b362319b53d6848e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/41ec7165ec8e490cbd38827b780fbcf6.png
[812feb3ee7ec4988909a412f75167fcd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/832ecf87ba004ace8d12049b3e9aa375.png
[acc6015b6f4b4e1cb576fcfb7e7dda09.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/cdf6f9e17b1a427b8bc44e3a20e2355d.png
[d8e5a96216de4f0f868efa920f0db8e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/f8b5cda4bb6446a49469f3fe59f7b321.png
[5671770b516f4f819c57a83005077618.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/e5c70157cfd846748aba86cbd70f08e3.png
[99a782de9905439e8237471f3085f578.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/25e9988628ba4425b80cf73285553242.png