写给大忙人看的 Java 基础知识

红太狼 2021-05-12 11:49 341阅读 0赞

众所周知，Java 是一门面向对象的编程语言。它最牛逼的地方就在于它是跨平台的，你可以在 Windows 操作系统上编写 Java 源代码，然后在 Linux 操作系统上执行编译后的字节码，而无需对源代码做任何的修改。

01、数据类型

Java 有 2 种数据类型，一种是基本数据类型，一种是引用类型。

基本数据类型用于存储简单类型的数据，比如说，int、long、byte、short 用于存储整数，float、double 用于存储浮点数，char 用于存储字符，boolean 用于存储布尔值。

不同的基本数据类型，有不同的默认值和大小，来个表格感受下。

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>默认值</th> 
   <th>大小</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean</td> 
   <td>false</td> 
   <td>1比特</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>‘\u0000’</td> 
   <td>2字节</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>0</td> 
   <td>1字节</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>0</td> 
   <td>2字节</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>0</td> 
   <td>4字节</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>0L</td> 
   <td>8字节</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>0.0f</td> 
   <td>4字节</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>0.0</td> 
   <td>8字节</td> 
  </tr> 
 </tbody> 
</table>

来看一段非常有意思的代码：

int i_max = Integer.MAX_VALUE;
    int become_min = i_max + 1;
    System.out.println("int 最大值：" + i_max);
    System.out.println("int 最小值：" + Integer.MIN_VALUE);
    System.out.println("+1 变最小值：" +become_min);
    
    double d_max = Double.MAX_VALUE;
    double still_max = d_max + 1;
    System.out.println("double 最大值：" + d_max);
    System.out.println("+1 仍然是最大值：" +still_max);

int 最大值加 1 后竟然变成了最小值，而 double 最大值加 1 后仍然是最大值。

基本类型都会有一个和它匹配的包装类型，比如说之前代码中出现的 int 和 Integer，double 和 Double。

既然有了基本类型和包装类型，肯定有些时候要在它们之间进行转换。把基本类型转换成包装类型的过程叫做装箱（boxing）。反之，把包装类型转换成基本类型的过程叫做拆箱（unboxing）。

在 Java SE5 之前，开发人员要手动进行装拆箱，比如说：

Integer chenmo = new Integer(10);  // 手动装箱
    int wanger = chenmo.intValue();  // 手动拆箱

Java SE5 为了减少开发人员的工作，提供了自动装箱与自动拆箱的功能。

Integer chenmo  = 10;  // 自动装箱
    int wanger = chenmo;     // 自动拆箱

上面这段代码使用 JAD 反编译后的结果如下所示：

Integer chenmo = Integer.valueOf(10);
    int wanger = chenmo.intValue();

也就是说，自动装箱是通过 `Integer.valueOf()` 完成的；自动拆箱是通过 `Integer.intValue()` 完成的。理解了原理之后，我们再来看一道老马当年给我出的面试题。

// 1）基本类型和包装类型
    int a = 100;
    Integer b = 100;
    System.out.println(a == b);
    
    // 2）两个包装类型
    Integer c = 100;
    Integer d = 100;
    System.out.println(c == d);
    
    // 3）
    c = 200;
    d = 200;
    System.out.println(c == d);

答案是什么呢？有举手要回答的吗？答对的奖励一朵小红花哦。

第一段代码，基本类型和包装类型进行 == 比较，这时候 b 会自动拆箱，直接和 a 比较值，所以结果为 true。

第二段代码，两个包装类型都被赋值为了 100，这时候会进行自动装箱，那 == 的结果会是什么呢？

我们之前的结论是：将“==”操作符应用于包装类型比较的时候，其结果很可能会和预期的不符。那结果是 false？但这次的结果却是 true，是不是感觉很意外？

第三段代码，两个包装类型重新被赋值为了 200，这时候仍然会进行自动装箱，那 == 的结果会是什么呢？

吃了第二段代码的亏后，是不是有点怀疑人生了，这次结果是 true 还是 false 呢？扔个硬币吧，哈哈。我先告诉你结果吧，false。

为什么？为什么？为什么呢？

事情到了这一步，必须使出杀手锏了——分析源码吧。

之前我们已经知道了，自动装箱是通过 `Integer.valueOf()` 完成的，那我们就来看看这个方法的源码吧。

public static Integer valueOf(int i) { 
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

难不成是 IntegerCache 在作怪？你猜对了！

private static class IntegerCache { 
        static final int low = -128;
        static final int high;
        static final Integer cache[];
    
        static { 
            // high value may be configured by property
            int h = 127;
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            high = h;
    
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
    
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
    }

大致瞟一下这段代码你就全明白了。-128 到 127 之间的数会从 IntegerCache 中取，然后比较，所以第二段代码（100 在这个范围之内）的结果是 true，而第三段代码（200 不在这个范围之内，所以 new 出来了两个 Integer 对象）的结果是 false。

看完上面的分析之后，我希望大家记住一点：**当需要进行自动装箱时，如果数字在 -128 至 127 之间时，会直接使用缓存中的对象，而不是重新创建一个对象**。

自动装拆箱是一个很好的功能，大大节省了我们开发人员的精力，但也会引发一些麻烦，比如下面这段代码，性能就很差。

long t1 = System.currentTimeMillis();
    Long sum = 0L;
    for (int i = 0; i < Integer.MAX_VALUE;i++) { 
        sum += i;
    }
    long t2 = System.currentTimeMillis();        
    System.out.println(t2-t1);

sum 由于被声明成了包装类型 Long 而不是基本类型 long，所以 `sum += i` 进行了大量的拆装箱操作（sum 先拆箱和 i 相加，然后再装箱赋值给 sum），导致这段代码运行完花费的时间足足有 2986 毫秒；如果把 sum 换成基本类型 long，时间就仅有 554 毫秒，完全不一个等量级啊。

引用类型用于存储对象（null 表示没有值的对象）的引用，String 是引用类型的最佳代表，比如说 `String cmower = "沉默王二"`。

### 02、变量声明 ###

要声明一个变量，必须指定它的名字和类型，来看一个简单的示例：

int age;
    String name;

count 和 name 在声明后会得到一个默认值，按照它们的数据类型——不能是局部变量（否则 Java 编译器会在你使用变量的时候提醒要先赋值），必须是类成员变量。

public class SyntaxLocalVariable { 
        int age;
        String name;
    
        public static void main(String[] args) { 
            SyntaxLocalVariable syntax = new SyntaxLocalVariable();
            System.out.println(syntax.age); // 输出 0
            System.out.println(syntax.name);  // 输出 null
        }
    }

也可以在声明一个变量后使用“=”操作符进行赋值，就像下面这样：

int age = 18;
    String name = "沉默王二";

我们定义了 2 个变量，int 类型的 age 和 String 类型的 name，age 赋值 18，name 赋值为“沉默王二”。

每行代码后面都跟了一个“;”，表示当前语句结束了。

在 Java 中，变量最好遵守命名约定，这样能提高代码的可阅读性。

*  以字母、下划线（\_）或者美元符号（$）开头
 *  不能使用 Java 的保留字，比如说 int 不能作为变量名

### 03、数组 ###

数组在 Java 中占据着重要的位置，它是很多集合类的底层实现。数组属于引用类型，它用来存储一系列指定类型的数据。

声明数组的一般语法如下所示：

type[] identiier = new type[length];

type 可以是任意的基本数据类型或者引用类型。来看下面这个例子：

public class ArraysDemo { 
        public static void main(String[] args) { 
            int [] nums = new int[10];
            nums[0] = 18;
            nums[1] = 19;
            System.out.println(nums[0]);
        }
    }

数组的索引从 0 开始，第一个元素的索引为 0，第二个元素的索引为 1。为什么要这样设计？感兴趣的话，你可以去探究一下。

通过变量名\[索引\]的方式可以访问数组指定索引处的元素，赋值或者取值是一样的。

### 04、关键字 ###

关键字属于保留字，在 Java 中具有特殊的含义，比如说 public、final、static、new 等等，它们不能用来作为变量名。为了便于你作为参照，我列举了 48 个常用的关键字，你可以瞅一瞅。

1.  **abstract：** abstract 关键字用于声明抽象类——可以有抽象和非抽象方法。
2.  **boolean：** boolean 关键字用于将变量声明为布尔值类型，它只有 true 和 false 两个值。
3.  **break：** break 关键字用于中断循环或 switch 语句。
4.  **byte：** byte 关键字用于声明一个可以容纳 8 个比特的变量。
5.  **case：** case 关键字用于在 switch 语句中标记条件的值。
6.  **catch：** catch 关键字用于捕获 try 语句中的异常。
7.  **char：** char 关键字用于声明一个可以容纳无符号 16 位比特的 Unicode 字符的变量。
8.  **class：** class 关键字用于声明一个类。
9.  **continue：** continue 关键字用于继续下一个循环。它可以在指定条件下跳过其余代码。
10. **default：** default 关键字用于指定 switch 语句中除去 case 条件之外的默认代码块。
11. **do：** do 关键字通常和 while 关键字配合使用，do 后紧跟循环体。
12. **double：** double 关键字用于声明一个可以容纳 64 位浮点数的变量。
13. **else：** else 关键字用于指示 if 语句中的备用分支。
14. **enum：** enum（枚举）关键字用于定义一组固定的常量。
15. **extends：** extends 关键字用于指示一个类是从另一个类或接口继承的。
16. **final：** final 关键字用于指示该变量是不可更改的。
17. **finally：** finally 关键字和 `try-catch` 配合使用，表示无论是否处理异常，总是执行 finally 块中的代码。
18. **float：** float 关键字用于声明一个可以容纳 32 位浮点数的变量。
19. **for：** for 关键字用于启动一个 for 循环，如果循环次数是固定的，建议使用 for 循环。
20. **if：** if 关键字用于指定条件，如果条件为真，则执行对应代码。
21. **implements：** implements 关键字用于实现接口。
22. **import：** import 关键字用于导入对应的类或者接口。
23. **instanceof：** instanceof 关键字用于判断对象是否属于某个类型（class）。
24. **int：** int 关键字用于声明一个可以容纳 32 位带符号的整数变量。
25. **interface：** interface 关键字用于声明接口——只能具有抽象方法。
26. **long：** long 关键字用于声明一个可以容纳 64 位整数的变量。
27. **native：** native 关键字用于指定一个方法是通过调用本机接口（非 Java）实现的。
28. **new：** new 关键字用于创建一个新的对象。
29. **null：** 如果一个变量是空的（什么引用也没有指向），就可以将它赋值为 null。
30. **package：** package 关键字用于声明类所在的包。
31. **private：** private 关键字是一个访问修饰符，表示方法或变量只对当前类可见。
32. **protected：** protected 关键字也是一个访问修饰符，表示方法或变量对同一包内的类和所有子类可见。
33. **public：** public 关键字是另外一个访问修饰符，除了可以声明方法和变量（所有类可见），还可以声明类。`main()` 方法必须声明为 public。
34. **return：** return 关键字用于在代码执行完成后返回（一个值）。
35. **short：** short 关键字用于声明一个可以容纳 16 位整数的变量。
36. **static：** static 关键字表示该变量或方法是静态变量或静态方法。
37. **strictfp：** strictfp 关键字并不常见，通常用于修饰一个方法，确保方法体内的浮点数运算在每个平台上执行的结果相同。
38. **super：** super 关键字可用于调用父类的方法或者变量。
39. **switch：** switch 关键字通常用于三个（以上）的条件判断。
40. **synchronized：** synchronized 关键字用于指定多线程代码中的同步方法、变量或者代码块。
41. **this：** this 关键字可用于在方法或构造函数中引用当前对象。
42. **throw：** throw 关键字主动抛出异常。
43. **throws：** throws 关键字用于声明异常。
44. **transient：** transient 关键字在序列化的使用用到，它修饰的字段不会被序列化。
45. **try：** try 关键字用于包裹要捕获异常的代码块。
46. **void：** void 关键字用于指定方法没有返回值。
47. **volatile：** volatile 关键字保证了不同线程对它修饰的变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
48. **while：** 如果循环次数不固定，建议使用 while 循环。

### 05、操作符 ###

除去“=”赋值操作符，Java 中还有很多其他作用的操作符，我们来大致看一下。

①、算术运算符

*  \+（加号）
 *  –（减号）
 *  \*（乘号）
 *  /（除号）
 *  ％（取余）

来看一个例子：

public class ArithmeticOperator { 
        public static void main(String[] args) { 
            int a = 10;
            int b = 5;
            
            System.out.println(a + b);//15 
            System.out.println(a - b);//5 
            System.out.println(a * b);//50 
            System.out.println(a / b);//2 
            System.out.println(a % b);//0 
        }
    }

“+”号比较特殊，还可以用于字符串拼接，来看一个例子：

String result = "沉默王二" + "一枚有趣的程序员";

②、逻辑运算符

逻辑运算符通常用于布尔表达式，常见的有：

*  &&（AND）多个条件中只要有一个为 false 结果就为 false
 *  ||（OR）多个条件只要有一个为 true 结果就为 true
 *  !（NOT）条件如果为 true，加上“!”就为 false，否则，反之。

来看一个例子：

public class LogicalOperator { 
        public static void main(String[] args) { 
            int a=10;
            int b=5;
            int c=20;
            System.out.println(a<b&&a<c);//false
            System.out.println(a>b||a<c);//true
            System.out.println(!(a<b)); // true
        }
    }

③、比较运算符

*  `<` (小于)
 *  `<=` (小于或者等于)
 *  `>` (大于)
 *  `>=` (大于或者等于)
 *  `==` (相等)
 *  `!=` (不等)

### 06、控制语句 ###

控制语句可以分为 3 种：

1）条件判断，包括 if / else / else if、三元运算符、switch。

if 语句可以单独使用，但通常和 else 在一起配合使用，如果条件判断超过两个以上，还会用到 else if。

来看一个简单的示例，判断闰年的。

public class LeapYear { 
        public static void main(String[] args) { 
            int year = 2020;
            if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) { 
                System.out.println("闰年");
            } else { 
                System.out.println("普通年份");
            }
        }
    }

如果执行语句比较简单的话，可以使用三元运算符来代替 if-else 语句，如果条件为 true，返回 ? 后面 : 前面的值；如果条件为 false，返回 : 后面的值。

public class IfElseTernaryExample { 
        public static void main(String[] args) { 
            int num = 13;
            String result = (num % 2 == 0) ? "偶数" : "奇数";
            System.out.println(result);
        }
    }

switch 语句用来判断变量与多个值之间的相等性。变量的类型可以是 byte、short、int、long，或者对应的包装器类型 Byte、Short、Integer、Long，以及字符串和枚举。

来看个简单的示例：

public class Switch1 { 
        public static void main(String[] args) { 
            int age = 20;
            switch (age) { 
                case 20 :
                    System.out.println("上学");
                    break;
                case 24 :
                    System.out.println("苏州工作");
                    break;
                case 30 :
                    System.out.println("洛阳工作");
                    break;
                default:
                    System.out.println("未知");
                    break; // 可省略
            }
        }
    }

2）循环遍历，包括 for、while、do-while。

![format_png][]

来看个简单的 for 循环示例：

public class PyramidForExample { 
        public static void main(String[] args) { 
            for (int i = 0; i < 5; i++) { 
                for (int j = 0;j<= i;j++) { 
                    System.out.print("❤");
                }
                System.out.println();
            }
        }
    }

输出结果如下所示：

❤
    ❤❤
    ❤❤❤
    ❤❤❤❤
    ❤❤❤❤❤

while 和 do-while 通常要和分支语句一块使用，随后来看。

3）分支语句，包括 continue、break。

来看一个在 do-while 循环中 continue（立即跳转到下一个循环）的例子。

public class ContinueDoWhileDemo { 
        public static void main(String[] args) { 
            int i=1;
            do{ 
                if(i==5){ 
                    i++;
                    continue;
                }
                System.out.println(i);
                i++;
            }while(i<=10);
        }
    }

再来看一个在 while 循环中 break（中断程序的当前流程）的例子：

int i = 1;
    while (i <= 10) { 
        if (i == 5) { 
            i++;
            break;
        }
        System.out.println(i);
        i++;
    }

### 07、程序结构 ###

Java 中最小的程序单元叫做类，一个类可以有一个或者多个字段（也叫作成员变量），还可以有一个或者多个方法，甚至还可以有一些内部类。

如果一个类想要执行，就必须有一个 main 方法——程序运行的入口，就好像人的嘴一样，嗯，可以这么牵强的理解一下。

public class StructureProgram { 
        public static void main(String[] args) { 
            System.out.println("没有成员变量，只有一个 main 方法");
        }
    }

*  类名叫做 StructureProgram，在它里面，只有一个 main 方法。
 *  `{}` 之间的代码称之为代码块。
 *  以上源代码将会保存在一个后缀名为 java 的文件中。

main 方法的写法通常来说是固定的，就像上面代码展示的那样，但它还有几种不常见的变体，你知道吗？

第一种，中括号“\[\]” 更靠近 args 而不是 String：

public static void main(String []args) {  }

第二种，中括号在 args 后面：

public static void main(String args[]) {  }

第三种，使用可变参数的形式而不是数组的形式：

public static void main(String...args) {  }

第四种，在 main 方法上加一个 `strictfp` 关键字（确保方法体内的浮点数运算在每个平台上执行的结果相同）：

public strictfp static void main(String[] args) {  }

第五种，为 args 参数加上 final 关键字修饰，确保 args 参数不会被修改：

public static void main(final String[] args) {  }

是不是有种豁然开朗的感觉？

![format_png 1][]

### 08、包 ###

在 Java 中，我们使用包对相关的类、接口进行分组。这样做有以下好处：

*  方便查找，通过包的路径就可以找到相关的类。
 *  避免类的命名冲突，比如说 com.niubi.Wanger 和 com.youxiu.Wanger 是不同的，因为 Wanger 类所在的包是不同的。
 *  通过包和访问权限符（public、private、protected）来控制类的可见性。

包的关键字叫 package，它通常在 Java 文件中的第一行。它的命名遵守以下约定：

*  必须使用小写字母
 *  可以由多个单词组成，使用英文“.”隔开
 *  一般由创建它的公司或者组织的倒序命名，比如说 `org.apache` 其实就是 apache.org 的倒序。

为了在一个包中使用另外一个包中的类，需要通过 import 关键字导入。

import com.cmower.Wanger;

### 09、编译然后执行代码 ###

通常，一些教程在介绍这块内容的时候，建议你通过命令行中先执行 `javac` 命令将源代码编译成字节码文件，然后再执行 `java` 命令指定代码。

但我不希望这个糟糕的局面再继续下去了——新手安装配置 JDK 真的蛮需要勇气和耐心的，稍有不慎，没入门就先放弃了。况且，在命令行中编译源代码会遇到很多莫名其妙的错误，这对新手是及其致命的——如果你再遇到这种老式的教程，可以吐口水了。

好的方法，就是去下载 IntelliJ IDEA，简称 IDEA，它被业界公认为最好的 Java 集成开发工具，尤其在智能代码助手、代码自动提示、代码重构、代码版本管理(Git、SVN、Maven)、单元测试、代码分析等方面有着亮眼的发挥。IDEA 产于捷克（位于东欧），开发人员以严谨著称。IDEA 分为社区版和付费版两个版本，新手直接下载社区版就足够用了。

安装成功后，可以开始敲代码了，然后直接右键运行（连保存都省了），结果会在 Run 面板中显示，如下图所示。

![format_png 2][]

想查看反编译后的字节码的话，可以在 src 的同级目录 target/classes 的包路径下找到一个 StructureProgram.class 的文件（如果找不到的话，在目录上右键选择「Reload from Disk」）。

可以双击打开它。

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package com.cmower.baeldung.basic;
    
    public class StructureProgram { 
        public StructureProgram() { 
        }
    
        public static void main(String[] args) { 
            System.out.println("没有成员变量，只有一个 main 方法");
        }
    }

IDEA 默认会用 Fernflower 将 class 字节码反编译为我们可以看得懂的 Java 代码。实际上，class 字节码（请安装 show bytecode 插件）长下面这个样子：

// class version 57.65535 (-65479)
    // access flags 0x21
    public class com/cmower/baeldung/basic/StructureProgram {
    
      // compiled from: StructureProgram.java
    
      // access flags 0x1
      public <init>()V
       L0
        LINENUMBER 3 L0
        ALOAD 0
        INVOKESPECIAL java/lang/Object.<init> ()V
        RETURN
       L1
        LOCALVARIABLE this Lcom/cmower/baeldung/basic/StructureProgram; L0 L1 0
        MAXSTACK = 1
        MAXLOCALS = 1
    
      // access flags 0x9
      public static main([Ljava/lang/String;)V
       L0
        LINENUMBER 5 L0
        GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
        LDC "\u6ca1\u6709\u6210\u5458\u53d8\u91cf\uff0c\u53ea\u6709\u4e00\u4e2a main \u65b9\u6cd5"
        INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
       L1
        LINENUMBER 6 L1
        RETURN
       L2
        LOCALVARIABLE args [Ljava/lang/String; L0 L2 0
        MAXSTACK = 2
        MAXLOCALS = 1
    }

新手看起来还是有些懵逼的，建议过过眼瘾就行了。

![format_png 3][]

### 最后，一定会有不少读者想要问我怎么学习 Java 的，那我干脆就把我看过的优质书籍贡献出来： ###

1）入门版：《Head First Java》、《Java 核心技术卷》

2）进阶版：《Java编程思想》、《Effective Java》、《Java网络编程》、《代码整洁之道》

3）大牛版：《Java并发编程》、《深入理解Java虚拟机》、《Java性能权威指南》、《重构》、《算法》

就先介绍这么多，希望对那些不知道看什么书的同学有所帮助。

> 对了，我介绍的这些书籍，已经顺便帮你整理好了，你可以在我的原创微信公众号『沉默王二』回复『书籍』获取哦

[format_png]: /images/20210511/0d557ec1a5fd4235ba93b9e5cd7c3fde.png
[format_png 1]: /images/20210511/93b5db6af305490785aaa152d0989cb0.png
[format_png 2]: /images/20210511/a47c32e2975246e3921dd3a11c04c568.png
[format_png 3]: /images/20210511/2a91ec6e9b8b497c8489a2d9e407f029.png