Java入门1: 基础语法

MangoGO 芒狗狗

---

---

1 基础语法

1.1 Hello World

  每门语言学习前，都会有一个 HelloWorld 的示例，Java 当然也不例外。Java 中所有的代码都必须包含在 class 中，main 方法是程序的入口，并且 Java 是区分大小写的。
  我们创建 HelloWorld.java ，内容如下：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

  执行下面shell命令进行编译：

!javac HelloWorld.java

  会在同级目录下生成对应 class 文件。执行下面 shell 命令进行运行：

!java HelloWorld

Hello World!

1.2 常量

  常量代表程序运行过程中不能改变的值。我们也可以把它们理解为特殊的变量，只是它们在程序的运行过程中是不允许改变的。

  Java 中的 final 关键字可以用于声明属性（常量），方法和类。当 final 修饰属性时，代表该属性一旦被分配内存空间就必须初始化，它的含义是“这是无法改变的”或者“终态的”。在变量前面添加关键字 final 即可声明一个常量。在 Java 编码规范中，要求常量名必须大写。

// final 数据类型 常量名 = 值;
final double PI = 3.14;

  或者先声明变量，再进行赋值：

final int FINAL_VARIABLE;
FINAL_VARIABLE = 100;

  创建 FinalVar.java 文件，并编译运行。

public class FinalVar {
    public static void main(String[] args){
        final String FINAL_STRING = "MangoGO";
        System.out.println(FINAL_STRING);
    }
}

!java FinalVar.java

MangoGO

1.3 数据类型

  Java 中一共八种基本数据类型，下表列出了基本数据类型的数据范围、存储格式、默认值和包装类型等。

数据类型	默认值	存储格式	数据范围	包装类型
short	0	2 个字节	-32,768 到 32,767	Short
int	0	4 个字节	-2,147,483,648 到 2,147,483,647	Integer
byte	0	1 个字节	-128 到 127	Byte
char	空	2 个字节	Unicode 的字符范围：\u0000（即为 0）到 \uffff（即为 65,535）	Character
long	0L 或 0l	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	Long
float	0.0F 或 0.0f	4 个字节	32 位 IEEEE-754 单精度范围	Float
double	0.0 或 0.0D(d)	8 个字节	64 位 IEEE-754 双精度范围	Double
boolean	false	1 位	true 或 false	Boolean

1. 整数
   byte、short、int、long 四种基本数据类型表示整数，需要注意的是 long 类型，使用 long 修饰的变量需要在数值后面加上 L 或者 l，比如 long num = 1L;，一般使用大写 L，为了避免小写 l 与数值 1 混淆。
2. 浮点数
   float 和 double 类型表示浮点数，即可以表示小数部分。需要注意的是 float 类型的数值后面需要加上 F 或者 f，否则会被当成 double 类型处理。double 类型的数值可以加上 D 或 d，也可以不加。
3. char 类型
   char 类型用于表示单个字符。需要将字符用单引号括起来char a = ‘a’，char 可以和整数互相转换，如果字符 a 也可以写成char a = 97。也可以用十六进制表示char a = ‘\u0061’。
4. boolean 类型
   boolean 类型（布尔类型）用于表示真值 true或者假值 false，Java 中布尔值不能和整数类型或者其它类型互相转换。

1.4 String

  Java 中使用 String 类来定义一个字符串，字符串是常量，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。String 对象的初始化格式有如下两种：

String s0 = "abc";

String s1 = new String("abd")

  String 类具有丰富的方法，比如计算字符串的长度、连接字符串、比较字符串、提取字符串等等。

  （1）字符串长度
  调用方法：字符串标识符.length(); 返回一个 int 类型的整数（字符串中字符数，中文字符也是一个字符）。例如：

String s1 = "abc";
String s2 = "Java语言";
int len1 = s1.length();  // 3
int len2 = s2.length();  // 6

  （2）字符串比较

  equals() 方法，该方法的作用是判断两个字符串对象的内容是否相同。如果相同则返回 true，否则返回 false。

  equals() 方法比较是从第一字符开始，一个字符一个字符依次比较。

  如果想忽略掉大小写关系，比如：java 和 Java 是一样的，可以调用 equalsIgnoreCase() 方法：

String s = new String("Java");
String m = "java";
System.out.println(s.equals(m));  // false
System.out.println(s.equalsIgnoreCase(m));  // true

  而使用 “==” 比较的是两个对象在内存中存储的地址是否一样。

String s1 = "abc";
String s2 = new String("abc");
boolean b = (s1 == s2);  // false

  （3）字符串连接
  字符串连接有两种方法：

1. 使用 +，比如 String s = "Hello " + “World!”。
2. 使用 String 类的 concat() 方法。

String s0 = new String("Hello ");
String s1 = "World" + "!";   // +号连接
String s2 = s0.concat(s1);   // concat()方法连接
System.out.println(s2);

  （4）字符串索引

  charAt() 方法的作用是按照索引值（规定字符串中第一个字符的索引值是 0，第二个字符的索引值是 1，依次类推），获得字符串中的指定字符。

String s = "abc";
char c = s.charAt(1);  // 6

  （5）字符串提取

方法	返回值	功能描述
indexOf(char ch)	int	搜索字符 ch 第一次出现的索引
indexOf(String value)	int	搜索字符串 value 第一次出现的索引
lastIndexOf(char ch)	int	搜索字符 ch 最后一次出现的索引
lastIndexOf(String value)	int	搜索字符串 value 最后一次出现的索引
substring(int index)	String	提取从位置索引开始到结束的字符串
substring(int beginindex, int endindex)	String	提取 beginindex 和 endindex 之间的字符串部分
trim()	String	返回一个前后不含任何空格的调用字符串的副本

public class StringTest {
    public static void main(String[] args){
        String s0 = new String("Java");
        String s1 = "java";
        System.out.println("用equals()比较，java和Java结果为"+s0.equals(s1));
        System.out.println("用equalsIgnoreCase()比较，java和Java结果为"+s0.equalsIgnoreCase(s1));

        String s2 = "abcdefabc";
        System.out.println("字符串s2："+s2);
        System.out.println("字符a第一次出现的位置为"+s2.indexOf('a'));
        System.out.println("字符串bc第一次出现的位置为"+s2.indexOf("bc"));
        System.out.println("字符a最后一次出现的位置为"+s2.lastIndexOf('a'));
        System.out.println("从位置3开始到结束的字符串"+s2.substring(3));
        System.out.println("从位置3开始到6之间的字符串"+s2.substring(3,6));
    }
}

!java StringTest.java

用equals()比较，java和Java结果为false
用equalsIgnoreCase()比较，java和Java结果为true
字符串s2：abcdefabc
字符a第一次出现的位置为0
字符串bc第一次出现的位置为1
字符a最后一次出现的位置为6
从位置3开始到结束的字符串defabc
从位置3开始到6之间的字符串def

1.5 StringBuilder

  String 是无法被修改的，对 String 的修改，其实是新建了一个 String 对象。如果需要修改字符串的内容，可以使用 StringBuilder。它相当于一个存储字符的容器。

  初始化格式有以下三种：

// 构造一个不包含任何字符且初始容量为 16 的 StringBuilder
StringBuilder a = new StringBuilder();

// 构造一个不包含任何字符且容量为 cap 的 StringBuilder
StringBuilder b = new StringBuilder(int cap);
// 构造一个 StringBuilder，内容初始化为 str
StringBuilder  c = new StringBuilder(String str);

public class StringBuilderTest {
    public static void main(String[] args){
        StringBuilder s1 = new StringBuilder();
        s1.append("java");
        StringBuilder s2 = new StringBuilder(5);
        StringBuilder s3 = new StringBuilder("MangoGO");
        System.out.println("s1:" + s1.toString() + "\tcap:" + s1.capacity());
        System.out.println("s2:" + s2.toString() + "\tcap:" + s2.capacity());
        System.out.println("s3:" + s3.toString() + "\tcap:" + s3.capacity());
    }
}

!java StringBuilderTest.java

s1:java	cap:16
s2:	cap:5
s3:MangoGO	cap:23
s2:MangoGO	cap:12

  其中 s3 的 capacity 为 23 是因为初始容量 16 + MangoGO 的长度 7。

  StringBuilder 常用方法：

方法	返回值	功能描述
deleteCharAt(int index)	StringBuilder	删除 StringBuilder 中指定位置的 char
indexOf()	int	返回子字符串首次出现在该字符串中的索引
capacity()	int	返回当前容量
charAt(int index)	char	返回序列中指定索引的 char 值
toString()	String	返回序列数据的 string 格式

1.6 运算符

算术运算符	名称	描述	类型	举例
+	加法	相加运算符两侧的值	双目运算符	a + b 等于 8
-	减法	左操作数减去右操作数	双目运算符	a - b 等于 2
*	乘法	相乘操作符两侧的值	双目运算符	a * b 等于 15
/	除法	左操作数除以右操作数	双目运算符	a / b 等于 1
%	取余	左操作数除右操作数的余数	双目运算符	a % b 等于 2
++	自增	操作数的值增加 1	单目运算符	++i（或 i++） 等于 2
--	自减	操作数的值减少 1	单目运算符	--i（或 i--） 等于 0

  其中，自增 (++) 和自减 (–) 运算符有两种写法：前缀（++i,–i）和后缀（i++,i–）。

• 前缀自增自减法 (++i,--i): 先进行自增或者自减运算，再进行表达式运算。
• 后缀自增自减法 (i++,i--): 先进行表达式运算，再进行自增或者自减运算

public class ArithmeticOperation {
    public static void main(String args[]) {
        int a = 5;
        int b = 3;
        int c = 3;
        int d = 3;
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));
        System.out.println("a++ = " + (a++));
        System.out.println("++a = " + (++a));
        System.out.println("b-- = " + (b--));
        System.out.println("--b = " + (--b));
        System.out.println("c++ = " + (c++));
        System.out.println("++d = " + (++d));
    }
}

!java ArithmeticOperation.java

a + b = 8
a - b = 2
a * b = 15
a / b = 1
a % b = 2
a++ = 5
++a = 7
b-- = 3
--b = 1
c++ = 3
++d = 4

1.7 位运算符

  Java 定义了位运算符，应用于整数类型 (int)，长整型 (long)，短整型 (short)，字符型 (char)，和字节型 (byte) 等类型。位运算时先转换为二进制，再按位运算。

  表格中的例子中，变量 a 的值为 60（二进制：00111100），变量 b 的值为 13（二进制：00001101）：

位运算符	名称	描述	举例
&	按位与	如果相对应位都是 1，则结果为 1，否则为 0	（a＆b），得到 12，即 0000 1100
丨	按位或	如果相对应位都是 0，则结果为 0，否则为 1	（ a 丨 b ）得到 61，即 0011 1101
^	按位异或	如果相对应位值相同，则结果为 0，否则为 1	（a^b）得到 49，即 0011 0001
~	按位补	翻转操作数的每一位，即 0 变成 1，1 变成 0	（~a）得到 -61，即 1100 0011
<<	按位左移	左操作数按位左移右操作数指定的位数	a<<2 得到 240，即 1111 0000
>>	按位右移	左操作数按位右移右操作数指定的位数	a>>2 得到 15 即 1111
>>>	按位右移补零	左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充	a>>>2 得到 15 即 0000 1111

public class BitOperation {
    public static void main(String[] args) {
        int a = 60;
        int b = 13;
        System.out.println("a & b = " + (a & b));
        System.out.println("a | b = " + (a | b));
        System.out.println("a ^ b = " + (a ^ b));
        System.out.println("~a = " + (~a));
        System.out.println("a << 2 = " + (a << 2));
        System.out.println("a >> 2 = " + (a >> 2));
        System.out.println("a >>> 2 = " + (a >>> 2));
    }
}

!java BitOperation.java

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15

1.8 逻辑运算符

  逻辑运算符是通过运算符将操作数或等式进行逻辑判断的语句。

  表格中的例子中，假设布尔变量 a 为真（true），变量 b 为假（false）：

逻辑运算符	名称	描述	类型	举例
&& 或 &	与	当且仅当两个操作数都为真，条件才为真	双目运算符	(a && b) 或 (a & b) 为假
| | 或 |	或	两个操作数任何一个为真，条件为真	双目运算符	(a || b) 或 (a | b) 为真
!	非	用来反转操作数的逻辑状态。如果条件为真，则逻辑非运算符将得到假	单目运算符	(!a）为假
^	异或	如果两个操作数逻辑相同，则结果为假，否则为真	双目运算符	(a ^ b) 为真

public class LogicOperation {
    public static void main(String args[]) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b = " + (a && b));
        System.out.println("a || b = " + (a || b));
        System.out.println("!a = " + (!a));
        System.out.println("a ^ b = " + (a ^ b));
    }
}

!java LogicOperation.java

a && b = false
a || b = true
!a = false
a ^ b = true

1.9 关系运算符

关系运算符生成的是一个 boolean（布尔）结果，它们计算的是操作数的值之间的关系。如果关系是真实的，结果为 true（真），否则，结果为 false（假）。

比较运算符	名称	描述	举例
==	等于	判断两个操作数的值是否相等，如果相等则条件为真	(a == b） 为 false
!=	不等于	判断两个操作数的值是否相等，如果值不相等则条件为真	(a != b) 为 true
>	大于	判断左操作数的值是否大于右操作数的值，如果是那么条件为真	(a > b) 为 false
<	小于	判断左操作数的值是否小于右操作数的值，如果是那么条件为真	(a < b) 为 true
>=	大于等于	判断左操作数的值是否大于或等于右操作数的值，如果是那么条件为真	(a >= b) 为 false
<=	小于等于	判断左操作数的值是否小于或等于右操作数的值，如果是那么条件为真	(a <= b) 为 true

public class RelationalOperation {
    public static void main(String[] args) {
        int a = 3;
        int b = 5;
        System.out.println("a == b: " + (a == b));
        System.out.println("a != b: " + (a != b));
        System.out.println("a > b: " + (a > b));
        System.out.println("a < b: " + (a < b));
        System.out.println("a >= b: " + (a >= b));
        System.out.println("a <= b: " + (a <= b));
        System.out.println("(a > b ? a : b) = " + (a > b ? a : b));
    }
}

!java RelationalOperation.java

a == b: false
a != b: true
a > b: false
a < b: true
a >= b: false
a <= b: true
(a > b ? a : b) = 5

1.10 练习：计算数字和

  需要实现以下需求：

• 获取控制台输入的两个整型参数。
• 输出两个整型参数和。

  比如输入 3 和 4 对应输出 7。

import java.util.Scanner;

public class Sum {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int x1 = in.nextInt();
        int x2 = in.nextInt();

        int sum = x1 + x2;
        System.out.println("The sum of " + x1 + " and " + x2 + " is " + sum);
    }
}

  Jupyter执行java代码不支持从键盘获取输入，就不演示了。

1.11 关键字和语句

• 关键字

  Java 的关键字对 Java 的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名。

• 方法

  Java 中的方法，可以将其看成一个功能的集合，它们是为了解决特定问题的代码组合。

  方法的定义语法：

访问修饰符 返回值类型 方法名(参数列表) {
    方法体;
}

  例如：

public void functionName(Objetc arg){
    System.out.println("Hello World.")
}

  在上面的语法说明中：

1. 访问修饰符：代表方法允许被访问的权限范围， 可以是 public、protected、private 或者省略（default） ，其中 public 表示该方法可以被其他任何代码调用。

2. 返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void （代表无类型）；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值。

3. 方法名：是方法的名字，必须使用合法的标识符。

4. 参数列表：是传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

5. 方法体：方法体包含具体的语句，定义该方法的功能。

  当方法定义好之后，需要调用才可以生效，我们可以通过 main 方法（main 方法是 Java 程序的入口，所以需要用它来调用）来调用它，比如：

public class MethodDemo {
    public static void main(String[] args) {
        method();
    }
    
    public static void method() {
        System.out.println("方法被调用");
    }
}

!java MethodDemo.java

方法被调用

1.12 流程控制

  常见主要为：条件语句、循环语句、跳转语句。

1. 条件语句

  语法：

if (条件表达式) {
    条件成立时执行的代码;
}

  或者：

if (条件表达式) {
    条件成立时执行的代码;
}
else {
    条件不成立时执行的代码;
}

  或者：

if (条件表达式) {
    代码块1;
}
else if {
    代码块2;
}
···
else {
    代码块3;
}

public class ScoreJudge {
    public static void main(String[] args) {
        int score = 78;
        if (score >= 60) {
            if (score >= 80) {
                if (score >= 90) {
                    System.out.println("优秀");
                } else {
                    System.out.println("良好");
                }
            } else {
                System.out.println("及格");
            }
        } else {
            System.out.println("不及格");
        }
    }
}

!java ScoreJudge.java

及格

2. switch 语句

switch(表达式) {
    case 值1:
        语句块1;
        break;
    case 值2:
        语句块2;
        break;
    ···
    default:
        默认语句块;
}

```java
public class Draw {
    public static void main(String[] args) {
        int num = 2;
        switch (num) {
            case 1:
                System.out.println("恭喜你，获得了一等奖");
                break;
            case 2:
                System.out.println("恭喜你，获得了二等奖");
                break;
            case 3:
                System.out.println("恭喜你，获得了三等奖");
            default:
                System.out.println("很遗憾，你没有获奖");
        }
    }
}

!java Draw.java

恭喜你，获得了二等奖

3. while 和 do-while 语句

  while 语法：

while(条件表达式) {
    循环体;
}

  do-while 语法：

do {
    循环体;
} while (条件表达式);

public class SumOfEven {
    public static void main(String[] args) {
        int i1 = 1, i2 = 1;
        int sum1 = 0, sum2 = 0;

        while (i1 <= 1000) {
            if (0 == i1 % 2) {
                sum1 += i1;
            }
            i1++;
        }
        System.out.println("用while，1到1000中，所有偶数的和为：" + sum1);

        do {
            if (0 == i2 % 2) {
                sum2 += i2;
            }
            i2++;
        } while (i2 <= 1000);
        System.out.println("用do-while，1到1000中，所有偶数的和为：" + sum2);
    }
}

!java SumOfEven.java

用while，1到1000中，所有偶数的和为：250500
用do-while，1到1000中，所有偶数的和为：250500

4. for 语句

  for 语法：

for (初始化表达式; 条件表达式; 迭代表达式) {
    循环体;
}

public class SumOfEvenWithFor {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 1000; i++) {
            if (0 == i % 2) {
                sum += i;
            }
        }
        System.out.println("用for循环，1到1000中，所有偶数的和为：" + sum);
    }
}

!java SumOfEvenWithFor.java

用for循环，1到1000中，所有偶数的和为：250500

5. 跳转语句

  break 关键字经常用在条件和循环语句中，用来跳出循环语句。

  continue关键字的作用是跳过循环体中剩余的语句执行下一次循环。

public class Jump {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println("循环第" + i + "次");
            if (0 == i % 3) {
                break;
            }
            if (0 == i % 5) {
                System.out.println("我进来了！");
            }
        }

        for (int i = 1; i <= 10; i++) {
            if (0 == i % 2) {
                continue;
            }
            System.out.println(i);
        }
    }
}

!java Jump.java

循环第1次
循环第2次
循环第3次
1
3
5
7
9

1.13 数组

  数组就是相同数据类型的元素按一定顺序排列的集合。可以把它看成一个大的盒子，里面按顺序存放了多个数据类型相同的数据。

  数组中的元素都可以通过下标来访问，下标从 0 开始，到数组长度 -1 结束。

  数组的声明语法：

数据类型[] 数组名;

  例如：

int[] ages;
char[] symbols;
String[] names;

  声明数组后，需要为数组分配内存空间，也就是定义多大的数组：

数组名 = new 数据类型[数组长度];

  数组长度就是数组最多可存放元素的个数。可以在数组声明的时候初始化数组，或者在声明时就为它分配好空间，这样就不用再为数组分配空间:

int [] ages = {12, 21, 22, 32, 45}; //声明并初始化一个整型数组，有5个元素
char [] symbols = new char[10]; //声明并分配一个长度为10的字符数组

  分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的：

age[0] = 12;

  Java 中可以将一个数组赋值给另一个数组，如:

int[] arr1 = {1, 2, 3};
int[] arr2;
arr2 = arr1;

  这里只是复制了一个引用，即 a2 和 a1 是相同数组的不同名称。

public class ArrayTest {
    public static void main(String[] args) {
        int [] a1 = {1, 2, 3};
        int [] a2;
        a2 = a1;
        for (int i = 0; i < a2.length; i++) {
            a2[i]++;
        }
        for (int i = 0; i < a1.length; i++) {
            System.out.println(a1[i]);
        }
    }
}

!java ArrayTest.java

2
3
4

  for 语句在数组内可以使用特殊简化版本，在遍历数组、集合时，foreach 更简单便捷。从英文字面意思理解 foreach 也就是“ for 每一个”的意思:

for (元素类型 变量名 : 数组名) {
    循环体;
}

public class JudgePrime {
    public static void main(String[] args) {
        int[] ages = {12, 18, 9, 33, 45, 60};
        int i = 1;
        for (int age : ages) {
            Sys1tem.out.println("数组中的第“ + i +"个元素是: " + age);
            i++;
        }
    }
}

!java JudgePrime.java

数组中的第1个元素是: 12
数组中的第2个元素是: 18
数组中的第3个元素是: 9
数组中的第4个元素是: 33
数组中的第5个元素是: 45
数组中的第6个元素是: 60

  二维数组可以看成是一间有座位的教室，座位一般用第几排的第几个进行定位，每一个座位都有一个行和一个列的属性，一排的座位相当于一个一维数组，所以可以将二维数组简单的理解为是一种“特殊”的一维数组，它的每个数组空间中保存的是一个一维数组。

数据类型 [][] 数组名 = new 数据类型[行数][列数];

//或者
数据类型[][] 数组名;
数组名 = new 数据类型[行数][列数];

//或者
数据类型 [][] 数组名 = {
    {值11, 值12, 值13, ...},
    {值21, 值22, 值23, ...},
    ···
}

//二维数组赋值与访问也是通过下标进行
数组名[行索引][列索引] = 值;

public class ArrayTest2 {
    public static void main(String[] args) {
        String[][] name = {{"xiaoming", "xiaohua", "xiaohong"},
            {"zhangsan", "lisi", "wangwu"}};
        for (int i = 0; i < name.length; i++) {
            for (int j = 0; j < name[0].length; j++) {
                System.out.println(name[i][j]);
            }
        }
    }
}

!java ArrayTest2.java

xiaoming
xiaohua
xiaohong
zhangsan
lisi
wangwu

1.14 用户输入操作

  在 Java 中使用 java.util 包下的Scanner 类来获取用户的输入。使用 import java.util.Scanner; 即可导入 Scanner，使用方法示例：

import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        System.out.println(s);

        while (!in.hasNext("exit")) {
            System.out.println(in.nextLine());
        }
        in.close();
    }
}

  由于jupyter中不能接收键盘输入，故不做展示。

参考代码

  GitCode

---

系列文章专栏：
Java入门

  1 基础部分 \

  2 面向对象 \

  3 常用类 \

  持续更新中：\