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

众所周知,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 个常用的关键字,你可以瞅一瞅。

  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。

来看个简单的 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性能权威指南》、《重构》、《算法》

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

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

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读