Java基础部分

目录

1、标识符

Java 中标识符是为方法、变量或其他用户定义项所定义的名称。标识符可以有一个或多个字符。在 Java 语言中，标识符的构成规则如下。

  • 标识符由数字（0 ~ 9）和字母（A ~ Z 和 a ~ z）、美元符号（$）、下划线（_）以及 Unicode 字符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）。
  • 标识符的第一个符号为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。
  • 标识符是大小写敏感的。
  • 标识符可以包含关键字、保留字，但不能与关键字、保留字重名。
  • 标识符的长度没有限制
  • 合法标识符举例：age、#salary、_value。
  • 非法标识符举例：123age、-salaru、#abc。

2、关键字

关键字（或者保留字）是对编译器有特殊意义的固定单词，不能在程序中做其他目的使用。关键字具有专门的意义和用途，和自定义的标识符不同，不能当作一般的标识符来使用。

Java语言共定义了如下所示的关键字

abstract assert boolean break
case catch char class
continue default do double
enum extends final finally
for goto if implements
instanceof int interface long
new package private protected
return strictfp short static
switch synchronized this throw
transient try void volatile
  • 用于数据类型的关键字有 boolean、byte、char、 double、 false、float、int、long、new、short、true、void、instanceof。
  • 用于语句的关键字有break、case、 catch、 continue、 default 、do、 else、 for、 if、return、switch、try、 while、 finally、 throw、this、 super。
  • 用于修饰的关键字有 abstract、final、native、private、 protected、public、static、synchronized、
    transient、 volatile。
  • 用于方法、类、接口、包和异常的关键字有 class、 extends、 implements、interface、 package、import、throws。
  • 还有些关键字,如cat、 future、 generic、innerr、 operator、 outer、rest、var等都是Java保留的没有意义的关键字。
  • 另外，Java还有3个保留字:true、false、null。它们不是关键字，而是文字。包含Java定义的值。和关键字一样,它们也不可以作为标识符使用。

3、修饰符

Java语言提供了很多修饰符，主要分为以下两类：

  • 访问修饰符
  • 非访问修饰符

3.1、访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

  • default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
  • private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
  • public : 对所有类可见。使用对象：类、接口、变量、方法
  • protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
饰符 当前类 同一包内 子孙类(同一包) 子孙类(不同包) 其他包
public Y Y Y Y Y
protected Y Y Y Y/N N
default Y Y Y N N
private Y N N N N
  • 默认访问修饰符-不使用任何关键字

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

  • 私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。

声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

  • 公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

  • 受保护的访问修饰符-protected

protected 需要从以下两个点来分析说明：

  • 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；

  • 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

  • 访问控制和继承

请注意以下方法继承的规则：

  • 父类中声明为 public 的方法在子类中也必须为 public。
  • 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
  • 父类中声明为 private 的方法，不能够被继承。

3.2、非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。

  • static 修饰符

  • 静态变量：

    static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

  • 静态方法：

    static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

  • final 修饰符

final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

父类中的 final 方法可以被子类继承，但是不能被子类重写。

final 类不能被继承，没有类能够继承 final 类的任何特性。

  • abstract 修饰符

抽象类：

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

抽象类可以包含抽象方法和非抽象方法。

抽象方法

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

抽象方法的声明以分号结尾，例如：public abstract sample();。

  • synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

  • transient 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

  • volatile 修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

一个 volatile 对象引用可能是 null。

4、注释

  • 单行注释：以双斜杠“//”标识，只能注释一行内容，用在注释信息内容少的地方。
  • 多行注释：包含在 “ /* ” 和 “ */ ” 之间，能注释很多行的内容。
  • 文档注释：包含在 “ /** ” 和 “ */ ” 之间，也能注释多行内容，一般用在类、方法和变量上面，用来描述其作用。文档注释只放在类、接口、成员变量、方法之前，因为 Javadoc 只处理这些地方的文档注释，而忽略其它地方的文档注释。

Javadoc 是 Sun 公司提供的一种工具，它可以从程序源代码中抽取类、方法、成员等注释，然后形成一个和源代码配套的 API 帮助文档。也就是说，只要在编写程序时以一套特定的标签注释，在程序编写完成后，通过 Javadoc 就形成了程序的 API 帮助文档。

5、常量与变量

常量是指在程序的整个运行过程中值保持不变的量。在这里要注意常量和常量值是不同的概念，常量值是常量的具体和直观的表现形式，常量是形式化的表现。通常在程序中既可以直接使用常量值，也可以使用常量。

5.1、常量值

  • 整数型常量值
  • 实数型常量值
  • 布尔型常量值
  • 字符型和字符串常量值

5.2、常量

Java 语言使用 final 关键字来定义一个常量，其语法如下所示：

final dataType variableName = value

其中，final 是定义常量的关键字，dataType 指明常量的数据类型，variableName 是变量的名称，value 是初始值。

  • 静态常量：使用在 final 之前 public static 修饰。public static 修饰的常量作用域是全局的，不需要创建对象就可以访问它，在类外部访问形式为类.常量。这种常量在编程中使用很多。
  • 成员常量：在方法之外定义，作用域类似于成员变量，但不能修改。
  • 局部常量：在方法之内定义，作用域类似于局部变量，但不能修改。

5.3、变量

Java 语言是强类型（Strongly Typed）语言，强类型包含以下两方面的含义：

  • 所有的变量必须先声明、后使用。
  • 指定类型的变量只能接受类型与之匹配的值。

在 java 中用户可以通过指定数据类型和标识符来声明变量，其基本语法如下所示：

DataType identifier=value;

DataType：变量类型，如 int、string、 char 和 double 等。identifier：标识符，也叫变量名称。value：声明变量时的值。

Java变量的作用域：静态变量、全局变量和局部变量

名称 修饰 访问 生命周期
全局变量（实例变量） 无 static 修饰 对象名.变量名 只要对象被当作引用，实例变量就将存在
静态变量（类变量） 用 static 修饰 类名.变量名或对象名.变量名 其生命周期取决于类的生命周期。类被垃圾回收机制彻底回收时才会被销毁

局部变量是指在方法或者方法代码块中定义的变量，其作用域是其所在的代码块。可分为以下三种：

  • 方法参数变量（形参）：在整个方法内有效。
  • 方法局部变量（方法内定义）： 从定义这个变量开始到方法结束这一段时间内有效。
  • 代码块局部变量（代码块内定义）：从定义这个变量开始到代码块结束这一段时间内有效。

6、基本数据类型

基本数据类型包括 boolean（布尔型）、float（单精度浮点型）、char（字符型）、byte（字节型）、short（短整型）、int（整型）、long（长整型）和 double （双精度浮点型）共 8 种。

类型名称 关键字 占用内存 取值范围
字节型 byte 1 字节 -128~127
短整型 short 2 字节 -32768~32767
整型 int 4 字节 -2147483648~2147483647
长整型 long 8 字节 -9223372036854775808L~9223372036854775807L
单精度浮点型 float 4 字节 +/-3.4E+38F（6~7 个有效位）
双精度浮点型 double 8 字节 +/-1.8E+308 (15 个有效位）
字符型 char 2 字节 ISO 单一字符集
布尔型 boolean 1 字节 true 或 false

提示：char 代表字符型，实际上字符型也是一种整数类型，相当于无符号整数类型。

7、数组

数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

在计算机语言中数组是非常重要的集合类型，大部分计算机语言中数组具有如下三个基本特性：

  1. 一致性：数组只能保存相同数据类型元素，元素的数据类型可以是任何相同的数据类型。
  2. 有序性：数组中的元素是有序的，通过下标访问。
  3. 不可变性：数组一旦初始化，则长度（数组中元素的个数）不可变。

总的来说，数组具有以下特点：

  • 数组可以是一维数组、二维数组或多维数组。
  • 数值数组元素的默认值为 0，而引用元素的默认值为 null。
  • 数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。
  • 数组元素可以是任何类型，包括数组类型。
  • 数组类型是从抽象基类 Array 派生的引用类型。

1.数组第一种定义方式

int[] counts = {1,2,3,4,5};

2.数组第二种定义方式(先初始化，后赋值)

int[] numbers = new int[3];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[0] = 1000;//在索引范围以内可以更改

3.数组创建第三种方式

int[] nums = new int[] {1,2,3};
//修改
nums[0] = 1000;

4.二维数组可以初始化，和一维数组一样，可以通过 3 种方式来指定元素的初始值。这 3 种方式的语法如下：

type[][] arrayName = new type[][]{值 1,值 2,值 3,…,值 n};    // 在定义时初始化
type[][] arrayName = new type[size1][size2];    // 给定空间，在赋值
type[][] arrayName = new type[size][];    // 数组第二维长度为空，可变化

5.三维数组有三个层次，可以将三维数组理解为一个一维数组，其内容的每个元素都是二维数组。依此类推，可以获取任意维数的数组

public static void main(String[] args) {
    String[][][] namelist = { { { "张阳", "李风", "陈飞" }, { "乐乐", "飞飞", "小曼" } },
            { { "Jack", "Kimi" }, { "Lucy", "Lily", "Rose" } }, { { "徐璐璐", "陈海" }, { "李丽丽", "陈海清" } } };
    for (int i = 0; i < namelist.length; i++) {
        for (int j = 0; j < namelist[i].length; j++) {
            for (int k = 0; k < namelist[i][j].length; k++) {
                System.out.println("namelist[" + i + "][" + j + "][" + k + "]=" + namelist[i][j][k]);
            }
        }
    }
}

执行上述代码，输出结果如下所示。

namelist[0][0][0]=张阳
namelist[0][0][1]=李风
namelist[0][0][2]=陈飞
namelist[0][1][0]=乐乐
namelist[0][1][1]=飞飞
namelist[0][1][2]=小曼
namelist[1][0][0]=Jack
namelist[1][0][1]=Kimi
namelist[1][1][0]=Lucy
namelist[1][1][1]=Lily
namelist[1][1][2]=Rose
namelist[2][0][0]=徐璐璐
namelist[2][0][1]=陈海
namelist[2][1][0]=李丽丽
namelist[2][1][1]=陈海清

8、引用数据类型

引用数据类型建立在基本数据类型的基础上，包括数组、字符串、类和接口。引用数据类型是由用户自定义，用来限制其他数据的类型。另外，Java 语言中不支持 C++ 中的指针类型、结构类型、联合类型和枚举类型。

引用类型还有一种特殊的 null 类型。所谓引用数据类型就是对一个对象的引用，对象包括实例和数组两种。实际上，引用类型变量就是一个指针，只是 Java 语言里不再使用指针这个说法。

空类型（null type）就是 null 值的类型，这种类型没有名称。因为 null 类型没有名称，所以不可能声明一个 null 类型的变量或者转换到 null 类型。

空引用（null）是 null 类型变量唯一的值。空引用（null）可以转换为任何引用类型。

在实际开发中，程序员可以忽略 null 类型，假定 null 只是引用类型的一个特殊直接量。

注意：空引用（null）只能被转换成引用类型，不能转换成基本类型，因此不要把一个 null 值赋给基本数据类型的变量

9、数据类型转换

如果以下 2 个条件都满足，那么将一种类型的数据赋给另外一种类型变量的时，将执行自动类型转换（automatic type conversion）。

  • 两种数据类型彼此兼容
  • 目标类型的取值范围大于源数据类型（低级类型数据转换成高级类型数据）

在运算过程中，由于不同的数据类型会转换成同一种数据类型，所以整型、浮点型以及字符型都可以参与混合运算。自动转换的规则是从低级类型数据转换成高级类型数据。转换规则如下：

  • 数值型数据的转换：byte→short→int→long→float→double。
  • 字符型转换为整型：char→int。

10、直接量的类型

  • int 类型的直接量

在程序中直接给出的整型数值，可分为二进制、十进制、八进制和十六进制 4 种，其中二进制需要以 0B 或 0b 开头，八进制需要以 0 开头，十六进制需要以 0x 或 0X 开头。例如 123、012（对应十进制的 10）、0x12（对应十进制的 18）等。

  • long 类型的直接量

在整型数值后添加 l 或 L 后就变成了 long 类型的直接量。例如 3L、0x12L（对应十进制的 18L）。

  • float 类型的直接量

在一个浮点数后添加 f 或 F 就变成了 float 类型的直接量，这个浮点数可以是标准小数形式，也可以是科学计数法形式。例如 5.34F、3.14E5f。

  • double 类型的直接量

直接给出一个标准小数形式或者科学计数法形式的浮点数就是 double 类型的直接量。例如 5.34、3.14E5。

  • boolean 类型的直接量

这个类型的直接量只有 true 和 false。

  • char 类型的直接量

char 类型的直接量有三种形式，分别是用单引号括起来的字符、转义字符和 Unicode 值表示的字符。例如‘a’，‘\n’和‘\u0061’。

  • String 类型的直接量

一个用双引号括起来的字符序列就是 String 类型的直接量。

  • null 类型的直接量

这个类型的直接量只有一个值，即 null。

11、运算符

11.1、算术运算符

一元运算符

运 算 符 名 称 说 明 例 子
- 取反符号 取反运算 b=-a
++ 自加一 先取值再加一，或先加一再取值 a++ 或 ++a
-- 自减一 先取值再减一，或先减一再取值 a-- 或 --a

二元运算符

运 算 符 名 称 说 明 例 子
+ 加 求 a 加 b 的和，还可用于 String 类型，进行字符串连接操作 a + b
- 减 求 a 减 b 的差 a - b
* 乘 求 a 乘以 b 的积 a * b
/ 除 求 a 除以 b 的商 a / b
% 取余 求 a 除以 b 的余数 a % b

11.2、赋值运算符

运算符 含义 实例 结果
+= 将该运算符左边的数值加上右边的数值， 其结果赋值给左边变量本身 int a=5; a+=2; a=7
-= 将该运算符左边的数值减去右边的数值， 其结果赋值给左边变量本身 int a=5; a-=2; a=3
*= 将该运算符左边的数值乘以右边的数值， 其结果赋值给左边变量本身 int a=5; a*=2; a=10
/= 将该运算符左边的数值整除右边的数值， 其结果赋值给左边变量本身 int a=5; a/=2; a=2
%= 将该运算符左边的数值除以右边的数值后取余，其结果赋值给左边变量本身 int a=5; a%=2; a=1

11.3、逻辑运算符

运算符 用法 含义 说明 实例 结果
&& a&&b 短路与 ab 全为 true 时，计算结果为 true，否则为 false。 2>1&&3<4 true
|| a||b 短路或 ab 全为 false 时，计算结果为 false，否则为 true。 2<1||3>4 false
! !a 逻辑非 a 为 true 时，值为 false，a 为 false 时，值为 true !(2>4) true
| a|b 逻辑或 ab 全为 false 时，计算结果为 false，否则为 true 1>2|3>5 false
& a&b 逻辑与 ab 全为 true 时，计算结果为 true，否则为 false 1<2&3<5 true

11.4、关系运算符

运算符 含义 说明 实例 结果
> 大于运算符 只支持左右两边操作数是数值类型。如果前面变量的值大于后面变量的值， 则返回 true。 2>3 false
>= 大于或等于运算符 只支持左右两边操作数是数值类型。如果前面变量的值大于等于后面变量的值， 则返回 true。 4>=2 true
< 小于运算符 只支持左右两边操作数是数值类型。如果前面变量的值小于后面变量的值，则返回 true。 2<3 true
<= 小于或等于运算符 只支持左右两边操作数是数值类型。如果前面变量的值小于等于后面变量的值， 则返回 true。 4<=2 false
== 相等运算符 如果进行比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要它们的值相等，也都将返回 true。 如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。 Java 也支持两个 boolean 类型的值进行比较。 4== 4 97 == 'a' true == false true true false
!= 不相等运算符 如果进行比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要它们的值不相等，也都将返回 true。 如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。 4!=2 true

11.5、自增和自减运算符

运算符 含义 实例 结果
i++ 将 i 的值先使用再加 1 赋值给 i 变量本身 int i=1; int j=i++; i=2 j=1
++i 将 i 的值先加 1 赋值给变量 i 本身后再使用 int i=1; int j=++i; i=2 j=2
i-- 将 i 的值先使用再减 1 赋值给变量 i 本身 int i=1; int j=i--; i=0 j=1
--i 将 i 的值先减 1 后赋值给变量 i 本身再使用 int i=1; int j=--i; i=0 j=0

11.6、位逻辑运算符

运算符 含义 实例 结果
& 按位进行与运算（AND） 4 & 5 4
| 按位进行或运算（OR） 4 | 5 5
^ 按位进行异或运算（XOR） 4 ^ 5 1
~ 按位进行取反运算（NOT） ~ 4 -5

11.7、复合位赋值运算符

运算符 含义 实例 结果
&= 按位与赋值 num1 &= num2 等价于 num 1=num 1 & num2
|= 按位或赋值 num1 |= num2 等价于 num 1=num 1 | num2
^= 按位异或赋值 num1 ^= num2 等价于 num 1=num 1 ^ num2
-= 按位取反赋值 num1 ~= num2 等价于 num 1=num 1 ~ num2
«= 按位左移赋值 num1 «= num2 等价于 num 1=num 1 « num2
»= 按位右移赋值 num1 »= num2 等价于 num 1=num 1 » num2

11.8、三目运算符

Java 提供了一个特别的三元运算符（也叫三目运算符），经常用于取代某个类型的 if-then-else 语句。

result = <expression> ? <statement1> : <statement3>;

其中，expression 是一个布尔表达式。当 expression 为真时，执行 statement1， 否则就执行 statement3。此三元运算符要求返回一个结果，因此要实现简单的二分支程序，即可使用该条件运算符。

11.9、运算符优先级

优先级 运算符 结合性
1 ()、[]、{} 从左向右
2 !、+、-、~、++、-- 从右向左
3 *、/、% 从左向右
4 +、- 从左向右
5 «、»、>>> 从左向右
6 <、<=、>、>=、instanceof 从左向右
7 ==、!= 从左向右
8 & 从左向右
9 ^ 从左向右
10 | 从左向右
11 && 从左向右
12 || 从左向右
13 ?: 从右向左
14 =、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>= 从右向左

12、流程控制语句

Java 提供两种流程控制结构的语法，Java 提供了 if 和 switch 两种分支语句，并提供了 while、do while 和 for 三种循环语句。一般写循环语句时，分以下三步走：

  1. 定义初始值
  2. 设置判断条件
  3. 初始值变化

除此之外，JDK5 还提供了一种新的循环：foreach 循环，能以更简单的方式来遍历集合、数组的元素。

Java 还提供了 break、continue 和 return 来控制程序的循环结构，作用如下：

  • break：表示跳出当前层循环
  • continue：表示跳出本次循环，进入下一次循环
  • return：跳出当前方法的循环

12.1、for each语句

foreach 循环语句是 Java 1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发者提供了极大的方便。foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。

foreach 循环语句的语法格式如下：

for(类型 变量名:集合) {
    语句块;
}

其中，“类型”为集合元素的类型，“变量名”表示集合中的每一个元素，“集合”是被遍历的集合对象或数组。

假设有一个数组，采用 for 语句遍历数组的方式如下：

// 声明并初始化数组
int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };
System.out.println("----for----");
// for语句
for (int i = 0; i < numbers.length; i++) {
    System.out.println("Count is:" + numbers[i]);
}

那么采用 for-each 循环语句遍历数组的方式如下：

// 声明并初始化int数组
int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };
System.out.println("----for each----");
// for-each语句
for (int item : numbers) {
    System.out.println("Count is:" + item);
}
posted @ 2021-06-30 22:50  有一个大佬梦  阅读(99)  评论(0)    收藏  举报