简介
本节内容讲解 Java 基础语法内容。主要包含变量、常量、数据类型、String、运算符、关键字和语句、方法以及 IDE 的介绍。
Java 概述及版本
Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 程序设计语言(以下简称 Java 语言)和 Java 平台的总称。Java 语言是一种面向对象的编程语言。虽然 Java 仅仅只产生了短短 20 年,但是它的发展是非常迅速的。在 2009 年 4 月 20 号,ORACLE 收购了 Sun 公司,也就是说 Java 这门语言现在归属于 ORACLE 这家公司门下。
在 Java 这门语言体系当中,最基础的部分就是 Java SE 部分,Java 的标准版本。它包括 Java 最基础的一些结构,包括面向对象的一些特性等等,同时它也是 Java 技术基础和核心。在 Java SE 的基础之上,又分为了 Java EE(Java 的企业版),应用于大型企业级应用的开发。Java ME 主要用于嵌入式开发。初学的时候我们都是从 Java SE 开始的。
JVM 叫 Java 虚拟机,它也是整个 Java 技术的核心。Java 语言的跨平台就多亏了 JVM。
JDK 叫 Java 开发工具包,没有 JDK 就没有办法进行 Java 程序的开发。
JRE 叫 Java 运行环境,如果我们需要运行一个 Java 程序,就得安装 JRE。
JDK、JRE 和 JVM 之间的关系:
HelloWorld
每门语言学习前,都会有一个 HelloWorld 的示例,Java 当然也不例外。
public class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld!");
}
}
上面的例子虽然简单,但是包含了很多的知识点,Java 中所有的代码都必须包含在 class 中,main 方法是程序的入口,并且 Java 是区分大小写的,如果写成 Main,那么程序将因找不到程序入口而无法运行。使用 public 修饰的 class 名(HelloWorld)须和源代码文件名相同。
编译源代码:打开命令行,切换到源代码目录,这里是 /home/project。输入 javac HelloWorld.java,如果程序没有任何提示,并且在同级目录下生成了一个 .class 扩展名的文件,那么说明编译成功,反之编译失败。
运行程序:输入 java HelloWorld,这个时候不需要再添加扩展名了。
变量
变量可以指在计算机存储器里存在值的被命名的存储空间。
变量通常是可被修改的,即可以用来表示可变的状态。这是 Java 的基本概念之一。
程序通过改变变量的值来改变整个程序的状态。为了方便使用变量,所以变量都需要命名,叫做变量名。
在 Java 中,变量需要先声明 (declare) 才能使用。在声明中,说明变量的类型,赋予变量以特别名字,以便在后面的程序中调用它。你可以在程序中的任意位置声明变量,语法格式如下:
数据类型 变量名称;
例如:
int a = 1;
在该语法格式中,数据类型可以是 Java 语言中任意的类型,如 int。变量名称是该变量的标识符,需要符合标识符的命名规则,数据类型和变量名称之间使用空格进行间隔,使用 ; 作为结束。
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
常量
常量代表程序运行过程中不能改变的值。我们也可以把它们理解为特殊的变量,只是它们在程序的运行过程中是不允许改变的。常量的值是不能被修改的。
Java 中的 final 关键字可以用于声明属性(常量),方法和类。当 final 修饰属性时,代表该属性一旦被分配内存空间就必须初始化,它的含义是“这是无法改变的”或者“终态的”。在变量前面添加关键字 final 即可声明一个常量。在 Java 编码规范中,要求常量名必须大写。
语法格式:
final 数据类型 常量名 = 值;
例如:
final double PI = 3.14;
常量也可以先声明,再进行赋值,但只能赋值一次,比如:
final int FINAL_VARIABLE;
FINAL_VARIABLE = 100;
数据类型
数据类型
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 中布尔值不能和整数类型或者其它类型互相转换。
String
Java 中使用 String 类来定义一个字符串,字符串是常量,它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。
String 对象的初始化格式有如下两种:
String s0 = "abc";
String s1 = new String("abd");
String 类具有丰富的方法,比如计算字符串的长度、连接字符串、比较字符串、提取字符串等等。
计算字符串长度
length() 方法:
//方法原型
public int length(){
}
调用方法:字符串标识符.length(); 返回一个 int 类型的整数(字符串中字符数,中文字符也是一个字符)。例如:
String s1 = "abc";
String s2 = "Java语言";
int len1 = s1.length();
int len2 = s2.length();
则变量 len1 的值是 3,变量 len2 的值是 6。
字符串比较
1、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));
}
}
2、"==" 方法。这种方法比较的是两个对象在内存中存储的地址是否一样。例如:
String s1 = "abc";
String s2 = new String("abc");
boolean b = (s1 == s2);
则变量 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);
而且使用 + 进行连接,不仅可以连接字符串,也可以连接其他类型。但是要求进行连接时至少有一个参与连接的内容是字符串类型。
charAt() 方法
charAt() 方法的作用是按照索引值(规定字符串中第一个字符的索引值是 0,第二个字符的索引值是 1,依次类推),获得字符串中的指定字符。例如:
String s = "abc";
char c = s.charAt(1);
则变量 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));
}
}
编译结果:
$ javac StringTest.java
$ java StringTest
字符a第一次出现的位置为0
字符串bc第一次出现的位置为1
字符a最后一次出现的位置为6
从位置3开始到结束的字符串defabc
从位置3开始到6之间的字符串def
运算符
运算符顾名思义是一种符号,它是连接一个以上的操作符,实现某种功能的运算。
算术运算符
算术运算符用在数学表达式中,主要实现的是算术运算,如常见的加减乘除等。
表格中的例子中,变量 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–): 先进行表达式运算,再进行自增或者自减运算
位运算符
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));
}
}
编译运行:
$ 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 为假(true):
逻辑运算符 | 名称 | 描述 | 类型 | 举例 |
---|---|---|---|---|
&& 或 & | 与 | 当且仅当两个操作数都为真,条件才为真 | 双目运算符 | (a && b) 或 (a & b) 为假 |
或 | 两个操作数任何一个为真,条件为真 | 双目运算符 | ||
! | 非 | 用来反转操作数的逻辑状态。如果条件为真,则逻辑非运算符将得到假 | 单目运算符 | (!a)为假 |
^ | 异或 | 如果两个操作数逻辑相同,则结果为假,否则为真 | 双目运算符 | (a ^ b) 为真 |
&& 与 || 是具有短路性质,当按优先级顺序计算到当前表达式时,表达式的结果可以确定整个表达式的结果时,便不会继续向后进行判断和计算,而直接返回结果。
例如:当使用 && 逻辑运算符时,在两个操作数都为 true 时,结果才为 true,但是当得到第一个操作为 false 时,其结果就必定是 false,这时候就不会再判断第二个操作了。在计算表达式 (a | b) && (a & a) 时,首先计算 a | b 得到了 false,因为之后是 &&,任何值与 false 进行与操作都是 false,所以可以不用再计算下去,而直接返回 a | b 的结果 false。
举例:
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(假)。
关系运算符:==(等于)、!=(不等于)、<(小于)、>(大于)、<=(小于等于)、>=(大于等于)
强调:
== 和 != 适用于所有的基本数据类型,其他关系运算符不适用于 boolean,因为 boolean 值只有 true 和 false,比较没有任何意义。
== 和 != 也适用于所有对象,可以比较对象的引用是否相同。
Java 中一切都是对象,但操作的标识符实际是对象的一个引用。
关键字和语句
关键字
Java 的关键字对 Java 的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、方法名、类名、包名。
Java 关键字有如下表所列,目前共有 50 个 Java 关键字,其中,“const” 和 “goto” 这两个关键字在 Java 语言中并没有具体含义。
方法
Java 中的方法,可以将其看成一个功能的集合,它们是为了解决特定问题的代码组合。
方法的定义语法:
访问修饰符 返回值类型 方法名(参数列表) {
方法体
}
比如:
public void functionName(Object arg) {
System.out.println("Hello World.");
}
在上面的语法说明中:
1、访问修饰符:代表方法允许被访问的权限范围, 可以是 public、protected、private 或者省略(default) ,其中 public 表示该方法可以被其他任何代码调用。
2、返回值类型:方法返回值的类型,如果方法不返回任何值,则返回值类型指定为 void (代表无类型);如果方法具有返回值,则需要指定返回值的类型,并且在方法体中使用 return 语句返回值。
3、方法名:是方法的名字,必须使用合法的标识符。
4、参数列表:是传递给方法的参数列表,参数可以有多个,多个参数间以逗号隔开,每个参数由参数类型和参数名组成,以空格隔开。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。
5、方法体:方法体包含具体的语句,定义该方法的功能。
根据方法是否带参、是否带返回值,可将方法分为四类:
(1)无参无返回值方法
(2)无参带返回值方法
(3)带参无返回值方法
(4)带参带返回值方法
当方法定义好之后,需要调用才可以生效,我们可以通过 main 方法(main 方法是 Java 程序的入口,所以需要用它来调用)来调用它,比如:
public class MethodDemo {
public static void main(String[] args){
method();
}
//这里要加上static关键字 应为静态方法只能调用静态方法
public static void method(){
System.out.println("方法被调用");
}
}
IDE
Java 常见的 IDE 有 IDEA,Eclipse 等,同学们可以任选一种安装在本地学习,在实验楼环境中并不会使用这两种 IDE,而是使用 WebIDE 进行开发,同学们需要将这两种 IDE 之一装在本地进行学习。