您的位置：首页 > 编程语言 > Java开发

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

2020-04-07 18:26 1376 查看

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

01、数据类型

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

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

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

数据类型	默认值	大小
boolean	false	1比特
char	‘\u0000’	2字节
byte	0	1字节
short	0	2字节
int	0	4字节
long	0L	8字节
float	0.0f	4字节
double	0.0	8字节

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

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 个常用的关键字，你可以瞅一瞅。

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

来看个简单的 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) { }

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

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 面板中显示，如下图所示。

想查看反编译后的字节码的话，可以在 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
}

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

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

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

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

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

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

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

点赞
收藏
分享
文章举报

沉默王二博客专家发布了680 篇原创文章 · 获赞 1万+ · 访问量 403万+ 他的留言板关注

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航