Java学习记录——基础语法（上）

说明：该文本是在实验楼学习过程中做的一些记载

基础语法（上）

知识点

1.变量

变量可以指在计算机存储器里存在值的被命名的存储空间。

变量通常是可被修改的，即可以用来表示可变的状态。这是 Java 的基本概念之一。

程序通过改变变量的值来改变整个程序的状态。为了方便使用变量，所以变量都需要命名，叫做变量名。

在 Java 中，变量需要先声明 (declare) 才能使用。在声明中，说明变量的类型，赋予变量以特别名字，以便在后面的程序中调用它。你可以在程序中的任意位置声明变量，语法格式如下：

数据类型 变量名称;

例如：

int a = 1;

在该语法格式中，数据类型可以是 Java 语言中任意的类型，如 int。变量名称是该变量的标识符，需要符合标识符的命名规则，数据类型和变量名称之间使用空格进行间隔，使用 ; 作为结束。

在 /home/project/ 新建一个 VarTest.java 文件：

public class VarTest
{
  public static void main(String[] args)
  {
    System.out.println("Define a variable a is ");
    int a; //声明变量a
    a = 5;
    System.out.println(a);  // 打印一个整数a
  }
}

编译运行：

$ javac VarTest.java
$ java VarTest
Define a variable a is
5

2.常量

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

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

语法格式：

final 数据类型 常量名 = 值;

例如：

final double PI = 3.14;

常量也可以先声明，再进行赋值，但只能赋值一次，比如：

final int FINAL_VARIABLE;
FINAL_VARIABLE = 100;

在 /home/project/ 下新建一个 FinalVar.java：

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

编译运行：

$ javac FinalVar.java
$ java FinalVar
shiyanlou

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

整数

byte、short、int、long 四种基本数据类型表示整数，需要注意的是 long 类型，使用 long 修饰的变量需要在数值后面加上 L 或者 l，比如 long num = 1L;，一般使用大写 L，为了避免小写 l 与数值 1 混淆。

浮点数

float 和 double 类型表示浮点数，即可以表示小数部分。需要注意的是 float 类型的数值后面需要加上 F 或者 f，否则会被当成 double 类型处理。double 类型的数值可以加上 D 或 d，也可以不加。

char 类型

char 类型用于表示单个字符。需要将字符用单引号括起来char a = 'a'，char 可以和整数互相转换，如果字符 a 也可以写成char a = 97。也可以用十六进制表示char a = '\u0061'。

boolean 类型

boolean 类型（布尔类型）用于表示真值 true或者假值 false，Java 中布尔值不能和整数类型或者其它类型互相转换。

4.String

Java 中使用 String 类来定义一个字符串，字符串是常量，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。

String 对象的初始化格式有如下两种：

String s0 = "abc";
String s1 = new String("abd");copy

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

计算字符串长度

length() 方法：

//方法原型
public int length(){
}copy

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

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

则变量 len1 的值是 3，变量 len2 的值是 6。

字符串比较

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

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

如果想忽略掉大小写关系，比如：java 和 Java 是一样的，那怎么办呢？可以调用 equalsIgnoreCase() 方法，其用法与 equals() 一致，不过它会忽视大小写。

比如：

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

编译运行：

$ javac StringTest.java
$ java StringTest
用equals()比较，java和Java结果为false
用equalsIgnoreCase()比较，java和Java结果为truecopy

而使用 "==" 比较的是两个对象在内存中存储的地址是否一样。例如：

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

则变量 b 的值是 false，因为 s1 对象对应的地址是 "abc" 的地址，而 s2 使用 new 关键字申请新的内存，所以内存地址和 s1 的 "abc" 的地址不一样，所以获得的值是 false。

字符串连接

字符串连接有两种方法：

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);copy

而且使用 + 进行连接，不仅可以连接字符串，也可以连接其他类型。但是要求进行连接时至少有一个参与连接的内容是字符串类型。

charAt() 方法

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

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

则变量 c 的值是 'b'。

字符串常用提取方法

方法	返回值	功能描述
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	返回一个前后不含任何空格的调用字符串的副本

说明：在字符串中，第一个字符的索引为 0，子字符串包含 beginindex 的字符，但不包含 endindex 的字符。

来写一些代码，验证一下上面的方法吧。

public class StringTest {
    public static void main(String[] args) {
         String s = "abcdefabc";
         System.out.println("字符a第一次出现的位置为"+s.indexOf('a'));
         System.out.println("字符串bc第一次出现的位置为"+s.indexOf("bc"));
         System.out.println("字符a最后一次出现的位置为"+s.lastIndexOf('a'));
         System.out.println("从位置3开始到结束的字符串"+s.substring(3));
         System.out.println("从位置3开始到6之间的字符串"+s.substring(3,6));
    }
}copy

编译运行：

$ javac StringTest.java
$ java StringTest
字符a第一次出现的位置为0
字符串bc第一次出现的位置为1
字符a最后一次出现的位置为6
从位置3开始到结束的字符串defabc
从位置3开始到6之间的字符串def

5.运算符

算术运算符

算术运算符用在数学表达式中，主要实现的是算术运算，如常见的加减乘除等。

表格中的例子中，变量 a 的值为 5，变量 b 的值为 3，变量 i 的值为 1：

算术运算符	名称	描述	类型	举例
+	加法	相加运算符两侧的值	双目运算符	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–): 先进行表达式运算，再进行自增或者自减运算

新建一个源代码文件 ArithmeticOperation.java：

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));
    }
}

编译运行：

$ javac ArithmeticOperation.java
$ java ArithmeticOperation
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

位运算符

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

在 /home/project 目录下新建一个源代码文件 BitOperation.java：

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));
    }
}

编译运行：

$ javac BitOperation.java
$ java BitOperation
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15

逻辑运算符

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

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

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

&& 与 || 是具有短路性质，当按优先级顺序计算到当前表达式时，表达式的结果可以确定整个表达式的结果时，便不会继续向后进行判断和计算，而直接返回结果。

例如：当使用 && 逻辑运算符时，在两个操作数都为 true 时，结果才为 true，但是当得到第一个操作为 false 时，其结果就必定是 false，这时候就不会再判断第二个操作了。在计算表达式 (a & b) && (a | b) 时，首先计算 a & b 得到了 false，因为之后是 &&，任何值与 false 进行与操作都是 false，所以可以不用再计算下去，而直接返回 a & b 的结果 false。

在/home/project目录下新建一个LogicOperation.java。

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));
    }
}

编译运行：

$ javac LogicOperation.java
$ java LogicOperation
a && b = false
a || b = true
!a = false
a ^ b = true

关系运算符

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

表格中的例子中，假设变量 a 为 3，变量 b 为 5：

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

除了上表列出的二元运算符，Java 还有唯一的一个三目运算符 ?: 。

语法格式：

布尔表达式 ？表达式 1 : 表达式 2;

运算过程：如果布尔表达式的值为 true，则返回表达式 1的值，否则返回表达式 2的值。

在 /home/project 目录下新建一个源代码文件 RelationalOperation.java：

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));
    }
}

编译运行：

$ javac RelationalOperation.java
$ java RelationalOperation
a == b = false
a != b = true
a > b = false
a < b = true
a >= b = false
a <= b = true
a > b ? a : b = 5

强调：

• == 和 != 适用于所有的基本数据类型，其他关系运算符不适用于 boolean，因为 boolean 值只有 true 和 false，比较没有任何意义。
• == 和 != 也适用于所有对象，可以比较对象的引用是否相同。

引用：Java 中一切都是对象，但操作的标识符实际是对象的一个引用。

运算符优先级

运算符的优先级是帮助我们在一个表达式中如何对于不同的运算符和相同的运算符，进行正确的运算顺序。

运算符的优先级不需要特别地去记忆它，比较复杂的表达式一般使用圆括号 () 分开，提高可读性。

!

6.关键字和语句

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

Java 关键字有如下表所列，目前共有 50 个 Java 关键字，其中，“const” 和 “goto” 这两个关键字在 Java 语言中并没有具体含义。

7.方法

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

方法的定义语法：

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

比如：

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

在上面的语法说明中：

1. 访问修饰符：代表方法允许被访问的权限范围， 可以是 public、protected、private 或者省略（default） ，其中 public 表示该方法可以被其他任何代码调用。
2. 返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void （代表无类型）；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值。
3. 方法名：是方法的名字，必须使用合法的标识符。
4. 参数列表：是传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
5. 方法体：方法体包含具体的语句，定义该方法的功能。

根据方法是否带参、是否带返回值，可将方法分为四类：

• 无参无返回值方法
• 无参带返回值方法
• 带参无返回值方法
• 带参带返回值方法

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

在 /home/project 下建立 MethodDemo.java：

public class MethodDemo {
    public static void main(String[] args){
        method();
    }
    //这里要加上 static 关键字 因为静态方法只能调用静态方法
    public static void method(){
        System.out.println("方法被调用");
    }
}

编译运行：

javac MethodDemo.java
java MethodDemo
方法被调用