java基础知识点总结2024版（8万字超详细整理）

java基础知识点总结2024版（超详细整理）

这里写目录标题

• java基础知识点总结2024版（超详细整理）
• • java语言的特点
  • • 1.简单性
    • 2.面向对象
    • 3.分布式
    • 4.健壮性
    • 5.安全性
    • 6.体系结构中立
    • 7.可移植性
    • 8.解释性
    • 9.多线程
    • 10.动态性
  • 初识java中的main方法
  • • main方法示例
    • 运行java程序
  • 数据类型与运算符
  • • 1.变量和类型
    • 1.1整形变量
    • 1.2长整型变量
    • 1.3双精度浮点型变量
    • 1.4单精度浮点型变量
    • [1.5 字符类型变量](#1.5 字符类型变量)
    • [1.6 字节类型变量](#1.6 字节类型变量)
    • 1.7短整型变量
    • 1.8布尔类型变量
    • [1.9 字符串类型变量(重点)](#1.9 字符串类型变量(重点))
    • 1.10变量的作用域
    • [1.11 变量的命名规则](#1.11 变量的命名规则)
    • 1.12常量
    • [1.12 类型转换](#1.12 类型转换)
    • [1.13 理解数值提升](#1.13 理解数值提升)
    • [1.14int 和String之间的相互转换](#1.14int 和String之间的相互转换)
    • 2.运算符
    • [2.1 算术运算符](#2.1 算术运算符)
    • [2.2 关系运算符](#2.2 关系运算符)
    • [2.3 逻辑运算符(重点)](#2.3 逻辑运算符(重点))
    • 2.4位运算符
    • [2.5 移位运算](#2.5 移位运算)
    • [2.6 条件运算符](#2.6 条件运算符)
    • [2.7 运算符的优先级](#2.7 运算符的优先级)
    • 2.8小结
    • 3注释
    • [3.1 基本规则](#3.1 基本规则)
    • 3.2注释规范
    • [4. 关键字](#4. 关键字)
  • 逻辑控制
  • • 1.顺序结构
    • [2. 分支结构](#2. 分支结构)
    • [2.1 if 语句](#2.1 if 语句)
    • [2.2switch 语句](#2.2switch 语句)
    • [3. 循环结构](#3. 循环结构)
    • [3.1 while 循环](#3.1 while 循环)
    • [3.2 break](#3.2 break)
    • [3.3 continue](#3.3 continue)
    • [3.4 for 循环](#3.4 for 循环)
    • [3.5 do while 循环](#3.5 do while 循环)
    • [4. 输入输出](#4. 输入输出)
    • [4.1 输出到控制台](#4.1 输出到控制台)
    • [4.2 从键盘输入](#4.2 从键盘输入)
  • 方法的使用
  • • [1. 方法的基本用法](#1. 方法的基本用法)
    • [1.1 什么是方法(method)](#1.1 什么是方法(method))
    • [1.2 方法定义语法](#1.2 方法定义语法)
    • 1.3方法调用的执行过程
    • [1.4 实参和形参的关系](#1.4 实参和形参的关系)
    • [1.5 没有返回值的方法](#1.5 没有返回值的方法)
    • [2. 方法的重载](#2. 方法的重载)
    • [2.1 重载要解决的问题](#2.1 重载要解决的问题)
    • [2.2 使用重载](#2.2 使用重载)
    • [2.3 重载的规则](#2.3 重载的规则)
    • [3. 方法递归](#3. 方法递归)
    • [3.1 递归的概念](#3.1 递归的概念)
    • [3.2 递归执行过程分析](#3.2 递归执行过程分析)
    • [3.3 递归练习](#3.3 递归练习)
    • [3.4 递归小结](#3.4 递归小结)
  • 数组的定义与使用
  • • [1. 数组基本用法](#1. 数组基本用法)
    • [1.1 什么是数组](#1.1 什么是数组)
    • [1.2 创建数组](#1.2 创建数组)
    • [1.3 数组的使用](#1.3 数组的使用)
    • [2. 数组作为方法的参数](#2. 数组作为方法的参数)
    • [2.1 基本用法](#2.1 基本用法)
    • [2.2 引用类型](#2.2 引用类型)
    • [2.3 认识 null](#2.3 认识 null)
    • [2.4 初识 JVM 内存区域划分(重点)](#2.4 初识 JVM 内存区域划分(重点))
    • [3. 数组作为方法的返回值](#3. 数组作为方法的返回值)
    • [4. 数组练习](#4. 数组练习)
    • [4.1 数组转字符串](#4.1 数组转字符串)
    • [4.2 数组拷贝](#4.2 数组拷贝)
    • [4.3 找数组中的最大元素](#4.3 找数组中的最大元素)
    • 4.4数组逆序
  • 类和对象
  • • [1. 类与对象的初步认知](#1. 类与对象的初步认知)
    • [2. 类和类的实例化](#2. 类和类的实例化)
    • [3. 类的成员](#3. 类的成员)
    • [3.1 字段/属性/成员变量](#3.1 字段/属性/成员变量)
    • [3.2 方法 (method)](#3.2 方法 (method))
    • [3.3 static 关键字](#3.3 static 关键字)
    • 4.封装
    • [4.1 private实现封装](#4.1 private实现封装)
    • [4.2 getter和setter方法](#4.2 getter和setter方法)
    • [5. 构造方法](#5. 构造方法)
    • [5.1 基本语法](#5.1 基本语法)
    • [5.2 this关键字](#5.2 this关键字)
    • [6. 认识代码块](#6. 认识代码块)
    • 代码块初始化
    • [6.1 什么是代码块](#6.1 什么是代码块)
    • [6.2 构造代码块](#6.2 构造代码块)
    • [6.3 静态代码块](#6.3 静态代码块)
  • 再谈类和对象
  • • 1.1简单认识类
    • 1.2类的定义格式
    • 2.1定义一个狗类
    • [2.2 定义一个学生类](#2.2 定义一个学生类)
    • [3. 类的实例化](#3. 类的实例化)
    • [3.1 什么是实例化](#3.1 什么是实例化)
    • [3.2 类和对象的说明](#3.2 类和对象的说明)
  • 4.this引用
  • • [4.1 什么是this引用](#4.1 什么是this引用)
    • 4.2this引用的特性
    • [5. 对象的构造及初始化](#5. 对象的构造及初始化)
    • [5.1 如何初始化对象](#5.1 如何初始化对象)
    • [5.2 构造方法](#5.2 构造方法)
    • 5.2.1**概念**
    • [5.2.2 特性](#5.2.2 特性)
    • [5.3 就地初始化](#5.3 就地初始化)
  • [6. 封装](#6. 封装)
  • • [6.1 封装的概念](#6.1 封装的概念)
    • [6.2 访问限定符](#6.2 访问限定符)
    • [6.3 封装扩展之包](#6.3 封装扩展之包)
    • [6.3.1 包的概念](#6.3.1 包的概念)
    • [6.3.2 导入包中的类](#6.3.2 导入包中的类)
    • 内部类
    • [8.1 内部类的分类](#8.1 内部类的分类)
    • [9.1 内部类](#9.1 内部类)
    • [9.1.1 实例内部类](#9.1.1 实例内部类)
    • [8.1.2 静态内部类](#8.1.2 静态内部类)
    • [8.2 局部内部类](#8.2 局部内部类)
  • 继承和多态
  • • [1 继承](#1 继承)
    • [1.1 为什么需要继承](#1.1 为什么需要继承)
    • [1.2 继承概念](#1.2 继承概念)
    • [1.3 继承的语法](#1.3 继承的语法)
    • [1.4 父类成员访问](#1.4 父类成员访问)
    • [1.4.1 子类中访问父类的成员变量](#1.4.1 子类中访问父类的成员变量)
    • [1.4.2 子类中访问父类的成员方法](#1.4.2 子类中访问父类的成员方法)
    • [1.5 super关键字](#1.5 super关键字)
    • [1.6 子类构造方法](#1.6 子类构造方法)
    • [1.7 super和this](#1.7 super和this)
    • [1.8 再谈初始化](#1.8 再谈初始化)
    • 1.10继承方式
    • 1.11final关键字
    • 多态
    • [2.1 多态的概念](#2.1 多态的概念)
    • [2.2 多态实现条件](#2.2 多态实现条件)
    • [2.3 重写](#2.3 重写)
    • [2.4 向上转移和向下转型](#2.4 向上转移和向下转型)
    • [2.4.1 向上转型](#2.4.1 向上转型)
    • [2.4.2 向下转型](#2.4.2 向下转型)
  • 抽象类和接口
  • • [1.2 抽象类语法](#1.2 抽象类语法)
    • [1.3 抽象类特性](#1.3 抽象类特性)
    • [1.4 抽象类的作用](#1.4 抽象类的作用)
    • [2. 接口](#2. 接口)
    • [2.1 接口的概念](#2.1 接口的概念)
    • [2.2 语法规则](#2.2 语法规则)
    • [2.3 接口使用](#2.3 接口使用)
    • [2.4 接口特性](#2.4 接口特性)
    • [2.5 实现多个接口](#2.5 实现多个接口)
    • [2.6 接口间的继承](#2.6 接口间的继承)
    • [2.8Clonable 接口和深拷贝](#2.8Clonable 接口和深拷贝)
    • 2.9对象比较equals方法
    • [认识 String 类](#认识 String 类)
    • [1. 创建字符串](#1. 创建字符串)
    • [2. 字符串比较相等](#2. 字符串比较相等)
    • [3. 字符串常量池](#3. 字符串常量池)
    • [5. 字符, 字节与字符串](#5. 字符, 字节与字符串)
    • [5.1 字符与字符串](#5.1 字符与字符串)
    • [5.2 字节与字符串](#5.2 字节与字符串)
    • [6. 字符串常见操作](#6. 字符串常见操作)
    • [6.1 字符串比较](#6.1 字符串比较)
    • [6.2 字符串查找](#6.2 字符串查找)
    • [6.3 字符串替换](#6.3 字符串替换)
    • [6.4 字符串拆分](#6.4 字符串拆分)
    • [6.5 字符串截取](#6.5 字符串截取)
    • [6.6 其他操作方法](#6.6 其他操作方法)
    • [7. StringBuffer 和 StringBuilder](#7. StringBuffer 和 StringBuilder)
    • 小结
  • 认识异常
  • • [1. 异常的背景](#1. 异常的背景)
    • 防御式编程
    • 异常的好处
    • [2. 异常的基本用法](#2. 异常的基本用法)
    • 异常处理流程
    • 自定义异常类

java语言的特点

1.简单性

Java语法是C++语法的一个"纯净版本"。这里没有头文件、指针运算（甚至指针语法）、结构、联合、操作符重载、虚基类等等。不仅如此，Java开发环境远远超出大多数其他编程语言的开发环境。

2.面向对象

什么是面向对象？ 这里我们用木匠打一个比方，一个"面向对象"的木匠始终关注的是所制作的椅子，第二位才是所使用的工具；而一个"非面向对象的"木匠首先考虑的是所使用的工具。

在Java的世界里，一切皆对象。

Java的面向对象特性与C++旗鼓相当，与C++的主要不同点在于多重继承。在Java中，取而代之的是更简单的接口概念。而且与C++相比，Java提供了更丰富的运行时自省功能。

3.分布式

Java有丰富的例程库，用于处理像HTTP和FTP之类的TCP/IP协议。Java应用程序能够通过URL打开和访问网络上的对象，其便捷程度就好像访问本地文件一样。

4.健壮性

Java与C++最大的不同在于Java采用的指针模型可以消除重写内存和损坏数据的可能性（对于曾经花费几个小时来检查由于指针bug而引起内存冲突的人来说，一定很喜欢Java的这一特性）。不仅如此，Java编译器能够检测许多在其他语言中仅在运行时才能够检测出来的问题。

5.安全性

Java适用于网络/分布式环境。为了达到这个目标，在安全性方面投入了大量的精力。使用Java可以构建防病毒、防篡改的系统

从一开始，Java就设计成能够防范常见的各种攻击：

运行时堆栈溢出。蠕虫和病毒常用的攻击手段。

破坏自己进程空间之外的内存。

未经授权读写文件

6.体系结构中立

编译器生成一个体系结构中立的目标文件格式，这是一种编译过的代码，只要有Java运行时系统，这些编译后的代码就可以在许多处理器上运行。Java编译器通过生成与特定计算机体系结构无关的字节码指令来实现这一特性。

精心设计的字节码不仅可以很容易的在任何机器上解释执行，而且还可以动态地翻译成本地机器代码。

7.可移植性

与C/C++不同，Java规范中没有"依赖具体实现的地方"。基本数据类型的大小以及有关运算都做了明确的说明。

例如，Java中的int永远是32位的整数，而在C/C++中，int可能是16位整数、32位整数，也可能是编译器提供商指定的其他大小。在Java中，数据类型具有固定的大小，这消除了代码移植时令人头疼的主要问题。

8.解释性

Java解释器可以在任何移植了解释器的机器上执行Java字节码。由于链接是一个增量式且轻量级的过程。所以开发过程也变得更加快捷，更加具有探索性。

9.多线程

java在当时很超前。它是第一个支持并发程序设计的主流语言。多线程可以带来更好的交互响应和实时行为。并发程序设计绝非易事，但是Java在这方面表现出色，可以很好的管理这个工作。

10.动态性

Java与C/C++相比更加具有动态性。它能够适应不断发展的环境。库中可以自由的添加新方法和实例变量，而对客户端没有任何影响。在Java中找出运行时类型信息十分简单（反射的特性）

初识java中的main方法

main方法示例

public class Test{
	 public static void main(String[] args){
		 System.out.println("Hello,Java");
		 System.out.println("My name is:"+args[0]);
  	}
 }

通过上述代码，我们可以看到一个完整的Java程序的结构，Java程序的结构由如下三个部分组成:

1.源文件（扩展名为*.java)：源文件带有类的定义。类用来表示程序的一个组件，小程序或许只会有一个类。类的内容必须包含在花括号里面。

2.类：类中带有一个或多个方法。方法必须在类的内部声明。

3.方法：在方法的花括号中编写方法应该执行的语句。

总结一下：类存在于源文件里面；方法存在于类中；语句存在于方法中.

运行java程序

Java是一门半编译型、半解释型语言。先通过javac编译程序把源文件进行编译，编译后生成的.class文件是由字节码组成的平台无关、面向JVM的文件。最后启动java虚拟机来运行.class文件，此时JVM会将字节码转换成平台能够理解的形式来运行。

JRE(Java Runtime Environment):Java运行时环境，包含了JVM，Java基础类库。是使用Java语言编写程序运行的所需环境。

JDK(Java Development Kit):Java开发工具包，提供给Java程序员使用，包含了JRE，同时还包含了编译器javac与自带的调试工具Jconsole、jstack等。

Java程序运行需要经过编译，运行两个阶段。

• 编译：javac 命令
• 运行：java 命令

数据类型与运算符

1.变量和类型

变量指的是程序运行时可变的量. 相当于开辟一块内存空间来保存一些数据.

类型则是对变量的种类进行了划分, 不同的类型的变量具有不同的特性。

1.1整形变量

基本语法格式

int 变量名 = 初始值;

代码示例：

int num = 10; // 定义一个整型变量

注意事项:

1. int 表示变量的类型是一个整型
2. 变量名是变量的标识. 后续都是通过这个名字来使用变量
3. Java 中 = 表示赋值(和数学不一样), 意思是给变量设置一个初始值.
4. 初始化操作是可选的, 但是建议创建变量的时候都显式初始化.
5. 最后不要忘记分号, 否则会编译失败.
6. // 表示注释. 注释作为代码的解释说明部分, 不参与编译运行.

1.2长整型变量

基本语法格式：

 long 变量名 = 初始值;

代码示例

long num = 10L; // 定义一个长整型变量, 初始值写作 10l 也可以(小写的 L, 不是数字1). 

注意事项:

1. 基本语法格式和创建 int 变量基本一致, 只是把类型修改成 long
2. 初始化设定的值为 10L , 表示一个长整型的数字. 10l 也可以.
3. 使用 10初始化也可以, 10 的类型是 int, 10L 的类型是 long, 使用 10 L 或者 10 l 更好一些.

1.3双精度浮点型变量

基本语法格式

double 变量名 = 初始值;

代码示例：

double num = 1.0;

神奇的代码1

 int a = 1;
 int b = 2;
 System.out.println(a / b);
 // 执行结果
0

在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃小数部分).

如果想得到 0.5, 需要使用 double 类型计算.

 double a = 1.0;
 double b = 2.0;
 System.out.println(a / b);
 // 执行结果
0.5

神奇的代码2：

double num = 1.1;
 System.out.println(num * num)
 // 执行结果
1.2100000000000002

Java 中的 double 虽然也是 8 个字节, 但是浮点数的内存布局和整数差别很大, 不能单纯的用 2 ^ n 的形式表示数据范围。

Java 的 double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差。

1.4单精度浮点型变量

基本格式：

 float 变量名 = 初始值;

代码示例:

float num = 1.0f;    
// 写作 1.0F 也可以

float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float

1.5 字符类型变量

基本格式:

char 变量名 = 初始值;

代码示例：

char ch = 'A';

注意事项:

1. Java 中使用
   单引号 + 单个字母 的形式表示字符字面值.
2. 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文

使用一个字符表示一个汉字:

 char ch = '呵'; 
System.out.println(ch);

执行 javac 的时候可能出现以下错误:

 Test.java:3: 错误: 未结束的字符文字 
        char ch = '鍛?'; 
                  ^ 

此时我们在执行 javac 时加上 -encoding UTF-8 选项即可

javac -encoding UTF-8 Test.java 

1.6 字节类型变量

基本语法格式：

byte 变量名 = 初始值; 

代码示例：

byte value = 0; 
System.out.println(value);

注意事项：

1. 字节类型表示的也是整数. 只占一个字节, 表示范围较小 (-128 -> +127)
2. 字节类型和字符类型互不相干

1.7短整型变量

基本语法格式：

 short 变量名 = 初始值; 

代码示例:

 short value = 0; 
System.out.println(value); 

注意事项：

1. short 占用 2 个字节, 表示的数据范围是 -32768 -> +32767
2. 这个表示范围比较小, 一般不推荐使用.

1.8布尔类型变量

基本语法格式:

boolean 变量名 = 初始值;

代码示例：

 boolean value = true; 
System.out.println(value); 

注意事项：

1. boolean 类型的变量只有两种取值, true 表示真, false 表示假.
2. Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.
3. boolean 类型有些 JVM 的实现是占 1 个字节, 有些是占 1 个比特位, 这个没有明确规定

1.9 字符串类型变量(重点)

把一些字符放到一起就构成了字符串

基本语法格式：

String 变量名 = "初始值";

代码示例：

 String name = "zhangsan"; 
System.out.println(name); 

注意事项：

1. Java 使用 双引号 + 若干字符 的方式表示字符串字面值.
2. 和上面的类型不同, String 不是基本类型, 而是引用类型
3. 字符串中的一些特定的不太方便直接表示的字符需要进行转义

转义字符示例：

// 创建一个字符串 My name is "张三" 
String name = "My name is \"张三\""; 

字符串的 + 操作, 表示字符串拼接：

 String a = "hello"; 
String b = "world"; 
String c = a + b; 
System.out.println(c);

还可以用字符串和整数进行拼接：

 String str = "result = "; 
int a = 10; 
int b = 20; 
String result = str + a + b; 
System.out.println(result); 
// 执行结果 
result = 1020 

以上代码说明, 当一个 + 表达式中存在字符串的时候, 都是执行字符串拼接行为.

因此我们可以很方便的使用 System.out.println 同时打印多个字符串或数字

int a = 10; 
int b = 20; 
System.out.println("a = " + a + ",b = " + b) 

1.10变量的作用域

也就是该变量能生效的范围, 一般是变量定义所在的代码块 (大括号）

class Test { 
    public static void main(String[] args) { 
        { 
            int x = 10; 
            System.out.println(x);   // 编译通过; 
        } 
        System.out.println(x);  // 编译失败, 找不到变量 x. 
    } 
} 

1.11 变量的命名规则

硬性指标：

1. 一个变量名只能包含数字, 字母, 下划线
2. 数字不能开头.
3. 变量名是大小写敏感的. 即 num 和 Num 是两个不同的变量.
   注意: 虽然语法上也允许使用中文/美元符($)命名变量, 但是 强烈 不推荐这样做

软性指标：

1. 变量命名要具有描述性, 见名知意.
2. 变量名不宜使用拼音(但是不绝对).
3. 变量名的词性推荐使用名词.
4. 变量命名推荐 小驼峰命名法, 当一个变量名由多个单词构成的时候, 除了第一个单词之外, 其他单词首字母都大写.

小驼峰命名示例

int maxValue = 100; 
String studentName = "张三"; 

1.12常量

上面讨论的都是各种规则的变量, 每种类型的变量也对应着一种相同类型的常量.

常量指的是运行时类型不能发生改变.

常量主要有以下两种体现形式:
1. 字面值常量

10 // int 字面值常量(十进制)

010 // int 字面值常量(八进制) 由数字 0 开头. 010 也就是十进制的 8

0x10 // int 字面值常量(十六进制) 由数字 0x 开头. 0x10 也就是十进制的 16

10L // long 字面值常量. 也可以写作 10l (小写的L)

1.0 // double 字面值常量. 也可以写作 1.0d 或者 1.0D

1.5e2 // double 字面值常量. 科学计数法表示. 相当于 1.5 * 10^2

1.0f // float 字面值常量, 也可以写作 1.0F

true // boolen 字面值常量, 同样的还有 false

'a' // char 字面值常量, 单引号中只能有一个字符

"abc" // String 字面值常量, 双引号中可以有多个字符.

2. final 关键字修饰的常量

final int a = 10; 
a = 20;    // 编译出错. 提示 无法为最终变量a分配值

常量不能在程序运行过程中发生修改

1.12 类型转换

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验.

先看以下几个代码场景:
int 和 long/double 相互赋值

int a = 10; 
long b = 20; 
a = b;         // 编译出错, 提示可能会损失精度.  
b = a;         // 编译通过.  

int a = 10; 
double b = 1.0; 
a = b;             // 编译出错, 提示可能会损失精度. 
b = a;     			// 编译通过.  

long 表示的范围更大, 可以将 int 赋值给 long, 但是不能将 long 赋值给 int.

double 表示的范围更大, 可以将 int 赋值给 double, 但是不能将 double 赋值给 int.
结论: 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型, 反之则不行

int 和 boolean 相互赋值

int a = 10; 
boolean b = true; 
b = a;               // 编译出错, 提示不兼容的类型 
a = b;    			// 编译出错, 提示不兼容的类型 

结论: int 和 boolean 是毫不相干的两种类型, 不能相互赋值.

int字面值常量 给 byte 赋值

byte a = 100;     // 编译通过 
byte b = 256;     // 编译报错, 提示 从int转换到byte可能会有损失

注意: byte 表示的数据范围是 -128 -> +127, 256 已经超过范围, 而 100 还在范围之内.
结论: 使用字面值常量赋值的时候, Java 会自动进行一些检查校验, 判定赋值是否合理.

使用强制类型转换

int a = 0; 
double b = 10.5; 
a = (int)b; 
int a = 10; 
boolean b = false; 
b = (boolean)a;          // 编译出错, 提示不兼容的类型.

结论: 使用 (类型) 的方式可以将 double 类型强制转成 int. 但是

1. 强制类型转换可能会导致精度丢失. 如刚才的例子中, 赋值之后, 10.5 就变成 10 了, 小数点后面的部分被忽略.
2. 强制类型转换不是一定能成功, 互不相干的类型之间无法强转

类型转换小结

1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型.
2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失.
3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查.

1.13 理解数值提升

int 和 long 混合运算

int a = 10; 
long b = 20; 
int c = a + b;  // 编译出错, 提示将 long 转成 int 会丢失精度 
long d = a + b;   // 编译通过.

结论: 当 int 和 long 混合运算的时候, int 会提升成 long, 得到的结果仍然是 long 类型, 需要使用 long 类型的变量来接收结果. 如果非要用 int 来接收结果, 就需要使用强制类型转换.

byte 和 byte 的运算

byte a = 10; 
byte b = 20; 
byte c = a + b; 
System.out.println(c); 
// 编译报错 
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失 
                byte c = a + b; 
                           ^

结论: byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.

由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于4 个字节的类型, 会先提升成 int, 再参与计算

正确的写法:

byte a = 10; 
byte b = 20; 
byte c = (byte)(a + b); 
System.out.println(c); 

类型提升小结:

1. 不同类型的数据混合运算, 范围小的会提升成范围大的.
2. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算

1.14int 和String之间的相互转换

int 转成 String

int num = 10; 
// 方法1 
String str1 = num + "";   
// 方法2 
String str2 = String.valueOf(num); 

String 转成 int

String str = "100"; 
int num = Integer.parseInt(str); 

2.运算符

2.1 算术运算符

• 基本四则运算符 + - * / %
  a) int / int 结果还是 int, 需要使用 double 来计算.

 int a = 1; 
int b = 2; 
System.out.println(a / b); 
// 结果为 0

b) 0 不能作为除数

int a = 1; 
int b = 0; 
System.out.println(a / b) 
// 运行结果 
Exception in thread "main" java.lang.ArithmeticException: / by zero 
        at Test.main(Test.java:5) 

c) % 表示取余, 不仅仅可以对 int 求模, 也能对 double 来求模

System.out.println(11.5 % 2.0); 
// 运行结果 
1.5 

• 增量赋值运算符 *+= -= = /= %=

 int a = 10; 
 a += 1;    // 等价于 a = a + 1 
System.out.println(a);

• 自增/自减运算符 ++ --

int a = 10; 
int b = ++a; 
System.out.println(b); 
int c = a++; 
System.out.println(c); 

结论:

1. 如果不取自增运算的表达式的返回值, 则前置自增和后置自增没有区别.
2. 如果取表达式的返回值, 则前置自增的返回值是自增之后的值, 后置自增的返回值是自增之前的值

2.2 关系运算符

关系运算符主要有六个:

== != < > <= >=

int a = 10; 
int b = 20; 
System.out.println(a == b); 
System.out.println(a != b); 
System.out.println(a < b); 
System.out.println(a > b); 
System.out.println(a <= b); 
System.out.println(a >= b); 

注意: 关系运算符的表达式返回值都是 boolean 类型.

2.3 逻辑运算符(重点)

逻辑运算符主要有三个:

&& || !

注意: 逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean .

逻辑与 &&

规则: 两个操作数都为 true, 结果为 true, 否则结果为 false

 int a = 10; 
int b = 20; 
int c = 30; 
System.out.println(a < b && b < c); 

逻辑或 ||

规则: 操作数为 true, 结果为 false; 操作数为 false, 结果为 true(这是个单目运算符, 只有一个操作数)

 int a = 10; 
int b = 20; 
System.out.println(!a < b); 

短路求值

&& 和 || 遵守短路求值的规则.

System.out.println(10 > 20 && 10 / 0 == 0);             // 打印 false 
System.out.println(10 < 20 || 10 / 0 == 0);             // 打印 true 

我们都知道, 计算

10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值.

结论:

1. 对于 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式.

2. 对于 ||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式.

& 和 | (不推荐使用)

& 和 | 如果操作数为 boolean 的时候, 也表示逻辑运算. 但是和 && 以及 || 相比, 它们不支持短路求值

System.out.println(10 > 20 & 10 / 0 == 0);             // 程序抛出异常 
System.out.println(10 < 20 | 10 / 0 == 0);             // 程序抛出异常

2.4位运算符

Java 中对数据的操作的最小单位不是字节, 而是二进制位.

位运算符主要有四个:

& | ~ ^

位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算.

按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0

 int a = 10; 
int b = 20; 
System.out.println(a & b); 

进行按位运算, 需要先把 10 和 20 转成二进制, 分别为 1010 和 10100

按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1

 int a = 10; 
int b = 20; 
System.out.println(a | b); 

运算方式和按位于类似.

注意: 当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算

按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0

 int a = 0xf; 
System.out.printf("%x\n", ~a) 

注意：

1. 0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4 个二进制位.
2. 0xf 表示 10 进制的 15, 也就是二进制的 1111
3. printf 能够格式化输出内容, %x 表示按照十六进制输出.
4. \n 表示换行符

按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

 int a = 0x1; 
int b = 0x2; 
System.out.printf("%x\n", a ^ b); 

2.5 移位运算

移位运算符有三个:

<< >> >>>

都是按照二进制位来运算.

左移 <<: 最左侧位不要了, 最右侧补 0.

 int a = 0x10; 
System.out.printf("%x\n", a << 1); 
// 运行结果(注意, 是按十六进制打印的) 
20 

右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

int a = 0x10; 
System.out.printf("%x\n", a >> 1); 
// 运行结果(注意, 是按十六进制打印的) 
8 
int b = 0xffff0000; 
System.out.printf("%x\n", b >> 1); 
// 运行结果(注意, 是按十六进制打印的) 
ffff8000 

无符号右移 >>>:最右侧位不要了, 最左侧补 0.

 int a = 0xffffffff; 
System.out.printf("%x\n", a >>> 1); 
// 运行结果(注意, 是按十六进制打印的) 
7fffffff 

注意:

1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
3. 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
4. 移动负数位或者移位位数过大都没有意义.

2.6 条件运算符

条件运算符只有一个:

 表达式1 ? 表达式2 : 表达式3

当 表达式1 的值为 true 时, 整个表达式的值为.表达式2 的值; 当 表达式1 的值为 false 时, 整个表达式的值为 表达式 3 的值

也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法

// 求两个整数的最大值 
int a = 10; 
int b = 20; 
int max = a > b ? a : b; 

2.7 运算符的优先级

先看一段代码

System.out.println(1 + 2 * 3);

结果为 7, 说明先计算了 2*3 , 再计算 1+

另外一个例子

System.out.println(10 < 20 && 20 < 30);

此时明显是先计算的 10 < 20 和 20 < 30, 再计算 &&. 否则 20 && 20 这样的操作是语法上有误的(&& 的操作数只能是boolean)

运算符之间是有优先级 的，在可能存在歧义的代码中加上括号即可。

2.8小结

1. % 操作再 Java 中也能针对 double 来计算.
2. 需要区分清楚 前置自增 和 后置自增之间的区别.
3. 由于 Java 是强类型语言, 因此对于类型检查较严格, 因此像 && 之类的运算操作数必须是 boolean.
4. 要区分清楚 & 和 | 什么时候是表示按位运算, 什么时候表示逻辑运算.
   整体来看, Java 的运算符的基本规则和 C 语言基本一致.

3注释

注释是为了让代码更容易被读懂而附加的描述信息. 不参与编译运行, 但是却非常重要.

3.1 基本规则

Java中的注释主要分为以下三种

单行注释：// 注释内容（用的最多）

多行注释：/* 注释内容*/（不推荐）

文档注释： /** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可用来自动生成文档

3.2注释规范

1. 内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.
2. 篇幅合理: 注释既不应该太精简, 也不应该长篇大论

4. 关键字

关键字是 Java 中的一些具有特定含义的单词.

逻辑控制

1.顺序结构

顺序结构比较简单. 像我们之前写过的代码就是顺序结构的, 按照代码书写的顺序一行一行执行

System.out.println("aaa");
 System.out.println("bbb");
 System.out.println("ccc");
 // 运行结果
aaa
 bbb
 ccc

如果调整代码的书写顺序, 则执行顺序也发生变化

System.out.println("aaa");
 System.out.println("ccc");
 System.out.println("bbb");
 // 运行结果
aaa
 ccc
 bbb

2. 分支结构

2.1 if 语句

基本语法形式1

 if(布尔表达式){
 //条件满足时执行代码
}

基本语法形式2

if(布尔表达式){
 //条件满足时执行代码
}else{
 //条件不满足时执行代码
}

基本语法形式3 多分支的情况

if(布尔表达式){
 //条件满足时执行代码
}else if(布尔表达式){
 //条件满足时执行代码
}else{
 //条件都不满足时执行代码
}

代码示例1: 判定一个数字是奇数还是偶数

int num = 10;
 if (num % 2 == 0) {
 System.out.println("num 是偶数");
 } else {
 System.out.println("num 是奇数");
 }

代码示例2: 判定一个数字是正数还是负数

int num = 10;
 if (num > 0) {
 System.out.println("num 是正数");
 } else if (num < 0) {
 System.out.println("num 是负数");
 } else {
 System.out.println("num 是 0");
 }

代码示例3: 判定某一年份是否是闰年

int year = 2000;
 if (year % 100 == 0) {
 // 判定世纪闰年
if (year % 400 == 0) {
 System.out.println("是闰年");
    } 
else {
 System.out.println("不是闰年");
    }
 } else {
 // 普通闰年
if (year % 4 == 0) {
 System.out.println("是闰年");
   } else {
 System.out.println("不是闰年");
     }
 }

注意事项1 悬垂 else 问题

int x = 10;
 int y = 10;
 if (x == 10) 
	if (y == 10)
		 System.out.println("aaa");
 else 
	System.out.println("bbb");

if / else 语句中可以不加 大括号 . 但是也可以写语句(只能写一条语句). 此时 else 是和最接近的 if 匹配.

但是实际开发中我们 不建议 这么写. 最好加上大括号

注意事项2 分号问题

int x = 20;
 if (x == 10); {
 System.out.println("hehe");
 }
 // 运行结果
hehe

此处多写了一个 分号, 导致分号成为了 if 语句的语句体, 而 { } 中的代码已经成为了和一个 if 无关的代码块

2.2switch 语句

基本语法

switch(整数|枚举|字符|字符串){
 case 内容1 : {
内容满足时执行语句;
 [break;]
 }
 case 内容2 : {
内容满足时执行语句;
 [break;]
 }
 ...
 default:{
内容都不满足时执行语句;
 [break;]
 }       
}

代码示例: 根据 day 的值输出星期

int day = 1;
 switch(day) {
 case 1:
 	System.out.println("星期一");
 	 break;
 case 2:
 	System.out.println("星期二");
	 break;
 case 3:
 	System.out.println("星期三");
	 break;
 case 4:
 	 System.out.println("星期四");
	 break;
 case 5:
	 System.out.println("星期五");
	 break; 	
 case 6:
 	System.out.println("星期六");
 	break;
 case 7:
 	System.out.println("星期日");
	 break;
 default:
 	System.out.println("输入有误");
 	 break;

根据 switch 中值的不同, 会执行对应的 case 语句. 遇到 break 就会结束该 case 语句.

如果 switch 中的值没有匹配的 case, 就会执行 default 中的语句.

我们建议一个 switch 语句最好都要带上 default.

注意事项1 break 不要遗漏, 否则会失去 "多分支选择" 的效果

int day = 1;
 switch(day) {
 case 1:
	 System.out.println("星期一");
 // break;
 case 2:
	 System.out.println("星期二");
 break;
 }
 // 运行结果
星期一
星期二

我们发现, 不写 break 的时候, case 语句会依次向下执行, 从而失去了多分支的效果

注意事项2 switch 中的值只能是 整数|枚举|字符|字符串

double num = 1.0;
 switch(num) {
 case 1.0:
	 System.out.println("hehe");
 break;
 case 2.0:
	 System.out.println("haha");
 break;
 }
 // 编译出错
Test.java:4: 错误: 不兼容的类型: 从double转换到int可能会有损失

注意事项3 switch 不能表达复杂的条件

// 例如: 如果 num 的值在 10 到 20 之间, 就打印 hehe
 // 这样的代码使用 if 很容易表达, 但是使用 switch 就无法表示. 
if (num > 10 && num < 20) {
 System.out.println("hehe");
 }

3. 循环结构

3.1 while 循环

基本语法格式:

while(循环条件){ 
循环语句; 
} 

循环条件为 true, 则执行循环语句; 否则结束循环
代码示例1: 打印 1 - 10 的数字

int num = 1; 
while (num <= 10) { 
    System.out.println(num); 
    num++; 
} 

代码示例2: 计算 1 - 100 的和

int n = 1; 
int result = 0; 
while (n <= 100) { 
    result += n; 
n++; 
} 
System.out.println(num); 
// 执行结果 
5050

代码示例3: 计算 5 的阶乘

int n = 1; 
int result = 1; 
while (n <= 5) { 
    result *= n; 
n++; 
} 
System.out.println(num); 
// 执行结果 
120

代码示例4: 计算 1! + 2! + 3! + 4! + 5!

 int num = 1; 
int sum = 0; 
// 外层循环负责求阶乘的和 
while (num <= 5) { 
    int factorResult = 1; 
    int tmp = 1; 
    // 里层循环负责完成求阶乘的细节.  
    while (tmp <= num) { 
        factorResult *= tmp; 
        tmp++; 
    } 
    sum += factorResult; 
    num++; 
} 
System.out.println("sum = " + sum); 

这里我们发现, 当一个代码中带有多重循环的时候, 代码的复杂程度就大大提高了. 而比较复杂的代码就更容易出错.
注意事项:

1. 和 if 类似, while 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }
2. 和 if 类似, while 后面的 { 建议和 while 写在同一行.
3. 和 if 类似, while 后面不要多写 分号, 否则可能导致循环不能正确执行

 int num = 1; 
while (num <= 10); { 
    System.out.println(num); 
    num++; 
} 
// 执行结果 
[无任何输出, 程序死循环]

此时 ; 为 while 的语句体(这是一个空语句), 实际的 { } 部分和循环无关. 此时循环条件 num <= 10 恒成立, 导致代码死循环了.

3.2 break

break 的功能是让循环提前结束
代码示例:找到 100 - 200 中第一个 3 的倍数

int num = 100; 
while (num <= 200) { 
    if (num % 3 == 0) { 
        System.out.println("找到了 3 的倍数, 为:" + num); 
        break; 
    } 
    num++; 
} 
// 执行结果 
找到了 3 的倍数, 为:102 

执行到 break 就会让循环结束

3.3 continue

continue 的功能是跳过这次循环, 立即进入下次循环
代码示例: 找到 100 - 200 中所有 3 的倍数

int num = 100; 
while (num <= 200) { 
    if (num % 3 != 0) { 
        num++;  // 这里的 ++ 不要忘记! 否则会死循环.  
        continue; 
    } 
    System.out.println("找到了 3 的倍数, 为:" + num); 
    num++; 
} 

执行到 continue 语句的时候, 就会立刻进入下次循环(判定循环条件), 从而不会执行到下方的打印语句

3.4 for 循环

基本语法

for(表达式1;表达式2;表达式3){ 
循环体; 
}

表达式1: 用于初始化循环变量.

表达式2: 循环条件

表达式3: 更新循环变量.

相比于 while 循环, for 循环将这三个部分合并在一起, 写代码时不容易遗漏

代码示例1: 打印 1 - 10 的数字

for (int i = 1; i <= 10; i++) { 
    System.out.println(i); 
} 

代码示例2: 计算 1 - 100 的和

int sum = 0; 
for (int i = 1; i <= 100; i++) { 
    sum += i; 
} 
System.out.println("sum = " + sum); 
// 执行结果 
5050 

代码示例3: 计算 5 的阶乘

int result = 0; 
for (int i = 1; i <= 5; i++) { 
    result *= i; 
} 
System.out.println("result = " + result);

注意事项 (和while循环类似)

1. 和 if 类似, for 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }
2. 和 if 类似, for 后面的 { 建议和 while 写在同一行.
3. 和 if 类似, for 后面不要多写 分号, 否则可能导致循环不能正确执行

3.5 do while 循环

基本语法

do{ 
循环语句; 
}while(循环条件); 

先执行循环语句, 再判定循环条件

代码示例: 打印 1 - 10

 int num = 1; 
do { 
    System.out.println(num); 
    num++; 
} while (num <= 10) 

注意事项

1. do while 循环最后的分号不要忘记
2. 一般 do while 很少用到, 更推荐使用 for 和 while.

4. 输入输出

4.1 输出到控制台

基本语法

System.out.println(msg);            // 输出一个字符串, 带换行 
System.out.print(msg);              // 输出一个字符串, 不带换行 
System.out.printf(format, msg);  
// 格式化输出 

println 输出的内容自带 \n, print 不带 \n

printf 的格式化输出方式和 C 语言的 printf 是基本一致的.

代码示例

System.out.println("hello world"); 
int x = 10; 
System.out.printf("x = %d\n", x) 

4.2 从键盘输入

使用 Scanner 读取字符串/整数/浮点数

import java.util.Scanner;  // 需要导入 util 包 
Scanner sc = new Scanner(System.in); 
System.out.println("请输入你的姓名："); 
String name = sc.nextLine(); 
System.out.println("请输入你的年龄："); 
int age = sc.nextInt(); 
System.out.println("请输入你的工资："); 
float salary = sc.nextFloat(); 
System.out.println("你的信息如下："); 
System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary); 
sc.close(); // 注意, 要记得调用关闭方法 
// 执行结果 
请输入你的姓名： 
张三 
请输入你的年龄： 
18 
请输入你的工资： 
1000 
你的信息如下： 
姓名: 张三 
年龄：18 
工资：1000.0

使用 Scanner 循环读取 N 个数字

Scanner sc = new Scanner(System.in); 
double sum = 0.0; 
int num = 0; 
while (sc.hasNextDouble()) { 
    double tmp = sc.nextDouble(); 
    sum += tmp; 
    num++; 
}
System.out.println("sum = " + sum); 
System.out.println("avg = " + sum / num); 
sc.close(); 
 
// 执行结果 
10 
40.0 
50.5 
^Z 
sum = 150.5 
avg = 30.1 

注意事项: 当循环输入多个数据的时候, 使用 ctrl + z 来结束输入

方法的使用

1. 方法的基本用法

1.1 什么是方法(method)

方法就是一个代码片段. 类似于 C 语言中的 "函数".

方法存在的意义

1. 是能够模块化的组织代码(当代码规模比较复杂的时候).
2. 做到代码被重复使用, 一份代码可以在多个位置使用.
3. 让代码更好理解更简单.
4. 直接调用现有方法开发, 不必重复造轮子

回忆一个之前写过的代码， 计算 1! + 2! + 3! + 4! + 5！

	 int sum = 0;
 for (int i = 1; i <= 5; i++) {
	 int tmp = 1;
 for (int j = 1; j <= i; j++) {
	 tmp *= j;
	    }
	 sum += tmp;
 }
 System.out.println("sum = " + sum);

这个代码中使用双重循环, 比较容易写错.

接下来我们可以使用方法来优化这个代码

1.2 方法定义语法

基本语法

// 方法定义
public static 方法返回值 方法名称（[参数类型 形参 ...]){
方法体代码;
 [return 返回值];
 }
 // 方法调用
返回值变量 = 方法名称(实参...);

代码示例: 实现一个方法实现两个整数相加

class Test {
 	public static void main(String[] args) {
		 int a = 10;
		 int b = 20;
		 // 方法的调用
		int ret = add(a, b);
		 System.out.println("ret = " + ret);
	 }
		 // 方法的定义
	public static int add(int x, int y) {
		 return x + y;
	 }
 }
 // 执行结果
ret = 30

注意事项

1. public 和 static 两个关键字在此处具有特定含义, 我们暂时不讨论, 后面会详细介绍.
2. 方法定义时, 参数可以没有. 每个参数要指定类型
3. 方法定义时, 返回值也可以没有, 如果没有返回值, 则返回值类型应写成 void
4. 方法定义时的参数称为 "形参", 方法调用时的参数称为 "实参".
5. 方法的定义必须在类之中, 代码书写在调用位置的上方或者下方均可.
6. Java 中没有 "函数声明" 这样的概念

1.3方法调用的执行过程

基本规则

• 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.

• 当方法被调用的时候, 会将实参赋值给形参.

• 参数传递完毕后, 就会执行到方法体代码.

• 当方法执行完毕之后(遇到 return 语句), 就执行完毕, 回到方法调用位置继续往下执行

• 一个方法可以被多次调用

代码示例1 计算两个整数相加

class Test {
	 public static void main(String[] args) {
 		int a = 10;
		 int b = 20;
		 System.out.println("第一次调用方法之前");
 		int ret = add(a, b);
 		System.out.println("第一次调用方法之后");
 		System.out.println("ret = " + ret);
		
		 System.out.println("第二次调用方法之前");
		 ret = add(30, 50);
		 System.out.println("第二次调用方法之后");
		 System.out.println("ret = " + ret);
	 }
	
	 public static int add(int x, int y) {
 		System.out.println("调用方法中 x = " + x + " y = " + y);
		 return x + y;
 		}
 }
 // 执行结果
一次调用方法之前
调用方法中 x = 10 y = 20
第一次调用方法之后
ret = 30
第二次调用方法之前
调用方法中 x = 30 y = 50
第二次调用方法之后
ret = 80

1.4 实参和形参的关系

代码示例: 交换两个整型变量

class Test {
	 public static void main(String[] args) {
		 int a = 10;
		 int b = 20;
		 swap(a, b);
		 System.out.println("a = " + a + " b = " + b);
	 }
 	public static void swap(int x, int y) {
		 int tmp = x;
		 x = y;
		 y = tmp;
	 }
 }
 // 运行结果
a = 10 b = 20

原因分析

刚才的代码, 没有完成数据的交换.

对于基础类型 来说, 形参相当于实参的拷贝. 即 传值调用

int a = 10;
 int b = 20;

 int x = a;
 int y = b;

 int tmp = x;
 x = y;
 y = tmp;

可以看到, 对 x 和 y 的修改, 不影响 a 和 b

1.5 没有返回值的方法

方法的返回值是可选的. 有些时候可以没有的
代码示例

class Test {
 	public static void main(String[] args) {
		 int a = 10;
		 int b = 20;
		 print(a, b);
 }
 public static void print(int x, int y) {
 	System.out.println("x = " + x + " y = " + y);
 }
}

2. 方法的重载

有些时候我们需要用一个函数同时兼容多种参数的情况, 我们就可以使用到方法重载

2.1 重载要解决的问题

代码示例

class Test {
	 public static void main(String[] args) {
		 int a = 10;
		 int b = 20;
		 int ret = add(a, b);
		
		 System.out.println("ret = " + ret);
		 
		 double a2 = 10.5;
		 double b2 = 20.5;
		 double ret2 = add(a2, b2);
		 System.out.println("ret2 = " + ret2);
	 }
	 public static int add(int x, int y) {
		 return x + y;
	 }
 }
 // 编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失
				double ret2 = add(a2, b2);

由于参数类型不匹配, 所以不能直接使用现有的 add 方法.

那么是不是应该创建这样的代码呢?
代码示例

class Test {
	public static void main(String[] args) {
 		int a = 10;
 		int b = 20;
 		int ret = addInt(a, b);
		 System.out.println("ret = " + ret);
		
		 double a2 = 10.5;
		 double b2 = 20.5;
		 double ret2 = addDouble(a2, b2);
		 System.out.println("ret2 = " + ret2);
	 }
	 public static int addInt(int x, int y) {
		 return x + y;
	 }
 	public static double addDouble(double x, double y) {
		 return x + y;
	}
}

这样的写法是对的(例如 Go 语言就是这么做的), 但是 Java 认为 addInt 这样的名字不友好, 不如直接就叫 add

2.2 使用重载

代码示例

class Test {
	 public static void main(String[] args) {
		 int a = 10;
 		 int b = 20;
		 int ret = add(a, b);
		 System.out.println("ret = " + ret);
 		
 		double a2 = 10.5;
 		double b2 = 20.5;
		 double ret2 = add(a2, b2);
		 System.out.println("ret2 = " + ret2);
	
		 double a3 = 10.5;
		 double b3 = 10.5;
		 double c3 = 20.5;
		 double ret3 = add(a3, b3, c3);
		
		 System.out.println("ret3 = " + ret3)
 }
 	public static int add(int x, int y) {
		 return x + y;
	 }
	 public static double add(double x, double y) {
		 return x + y;
	 }
	 public static double add(double x, double y, double z) {
		 return x + y + z;
	 }
 }

方法的名字都叫 add. 但是有的 add 是计算 int 相加, 有的是 double 相加; 有的计算两个数字相加, 有的是计算三个数字相加

同一个方法名字, 提供不同版本的实现, 称为 方法重载

2.3 重载的规则

针对同一个类:

• 方法名相同
• 方法的参数不同(参数个数或者参数类型)
• 方法的返回值类型不影响重载

代码示例

class Test {
 	public static void main(String[] args) {
		 int a = 10;
		 int b = 20;
		 int ret = add(a, b);
		 System.out.println("ret = " + ret);
	 }
	 public static int add(int x, int y) {
		 return x + y;
	 }
	 public static double add(int x, int y) {
		 return x + y;
	 }
 }
 // 编译出错
Test.java:13: 错误: 已在类 Test中定义了方法 add(int,int)
 public static double add(int x, int y) {
 ^
 1 个错误

当两个方法的名字相同, 参数也相同, 但是返回值不同的时候, 不构成重载.

3. 方法递归

3.1 递归的概念

一个方法在执行过程中调用自身, 就称为 "递归".
代码示例: 递归求 N 的阶乘

public static void main(String[] args) {
 	int n = 5;
	 int ret = factor(n);
	 System.out.println("ret = " + ret);
 }
 public static int factor(int n) {
	 if (n == 1) {
	 return 1;
    }
	 return n * factor(n - 1); // factor 调用函数自身
}
 // 执行结果
ret = 120

3.2 递归执行过程分析

递归的程序的执行过程不太容易理解, 要想理解清楚递归, 必须先理解清楚 "方法的执行过程", 尤其是 "方法执行结束之后, 回到调用位置继续往下执行"

代码示例: 递归求 N 的阶乘, 加上日志版本

public static void main(String[] args) {
 	int n = 5;
 	int ret = factor(n);
 	System.out.println("ret = " + ret);
 }
 public static int factor(int n) {
 	System.out.println("函数开始, n = " + n);
	 if (n == 1) {
 	System.out.println("函数结束, n = 1 ret = 1");
 	return 1;
    }
	 int ret = n * factor(n - 1);
	 System.out.println("函数结束, n = " + n + " ret = " + ret);
	 return ret;
 }
 // 执行结果
函数开始, n = 5
函数开始, n = 4
函数开始, n = 3
函数开始, n = 2
函数开始, n = 1
函数结束, n = 1 ret = 1
函数结束, n = 2 ret = 2
函数结束, n = 3 ret = 6
函数结束, n = 4 ret = 24
函数结束, n = 5 ret = 120
 ret = 120

3.3 递归练习

代码示例1 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

public static void print(int num) {
 if (num > 9) {
 print(num / 10);
    }
 System.out.println(num % 10);
 }

代码示例2 递归求 1 + 2 + 3 + ... + 10

 public static int sum(int num) { 
    if (num == 1) { 
        return 1; 
    } 
    return num + sum(num - 1); 
} 

代码示例3 求斐波那契数列的第 N 项

斐波那契数列介绍

 public static int fib(int n) { 
    if (n == 1 || n == 2) { 
        return 1; 
    } 
    return fib(n - 1) + fib(n - 2); 
} 

当我们求 fib(40) 的时候发现, 程序执行速度极慢. 原因是进行了大量的重复运算.

可以使用循环的方式来求斐波那契数列问题, 避免出现冗余运算

 public static int fib(int n) { 
    int last2 = 1; 
    int last1 = 1; 
    int cur = 0; 
    for (int i = 3; i <= n; i++) { 
        cur = last1 + last2; 
        last2 = last1; 
        last1 = cur; 
    } 
    return cur; 
} 

此时程序的执行效率大大提高了

3.4 递归小结

递归是一种重要的编程解决问题的方式.

有些问题天然就是使用递归方式定义的(例如斐波那契数列, 二叉树等), 此时使用递归来解就很容易.

有些问题使用递归和使用非递归(循环)都可以解决. 那么此时更推荐使用循环, 相比于递归, 非递归程序更加高效.

数组的定义与使用

1. 数组基本用法

1.1 什么是数组

数组本质上就是让我们能 "批量" 创建相同类型的变量

例如:

如果需要表示两个数据, 那么直接创建两个变量即可 int a; int b

如果需要表示五个数据, 那么可以创建五个变量 int a1; int a2; int a3; int a4; int a5;

但是如果需要表示一万个数据, 那么就不能创建一万个变量了. 这时候就需要使用数组, 帮我们批量创建.

注意事项:在 Java 中, 数组中包含的变量必须是 相同类型.

1.2 创建数组

基本语法

// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
 // 静态初始化
数据类型[] 数组名称 = { 初始化数据 };

代码示例

int[] arr = new int[]{1, 2, 3};
 
 int[] arr = {1, 2, 3};

注意事项: 静态初始化的时候, 数组元素个数和初始化数据的格式是一致的

其实数组也可以写成

int arr[] = {1, 2, 3};

这样就和 C 语言更相似了. 但是我们还是更推荐写成 int[] arr 的形式. int和 [] 是一个整体

1.3 数组的使用

代码示例: 获取长度 & 访问元素

int[] arr = {1, 2, 3};
 // 获取数组长度
System.out.println("length: " + arr.length); // 执行结果: 3

 // 访问数组中的元素
System.out.println(arr[1]);         
System.out.println(arr[0]);         
arr[2] = 100;
 System.out.println(arr[2]);         
// 执行结果: 2
 // 执行结果: 1
 // 执行结果: 100

注意事项

1. 使用 arr.length 能够获取到数组的长度. . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
2. 使用[ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
3. 使用 [ ] 操作既能读取数据, 也能修改数据.
4. 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常

代码示例: 下标越界

int[] arr = {1, 2, 3};
 System.out.println(arr[100]);

 // 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
 at Test.main(Test.java:4)

抛出了 java.lang.ArrayIndexOutOfBoundsException 异常. 使用数组一定要下标谨防越界

代码示例: 遍历数组

所谓 "遍历" 是指将数组中的所有元素都访问一遍, 不重不漏. 通常需要搭配循环语句.

int[] arr = {1, 2, 3};
 for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
 }
 
// 执行结果
1
 2
 3

代码示例: 使用 for-each 遍历数组

int[] arr = {1, 2, 3};
 for (int x : arr) {
    System.out.println(x);
 }
 
// 执行结果
1
 2
 3

for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错.

2. 数组作为方法的参数

2.1 基本用法

代码示例：打印数组内容

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    printArray(arr);
 }
 
public static void printArray(int[] a) {
    for (int x : a) {
        System.out.println(x);
    }
 }
 
// 执行结果
1
 2
 3

在这个代码中

• int[] a 是函数的形参, int[] arr 是函数实参.
• 如果需要获取到数组长度, 同样可以使用 a.length

2.2 引用类型

代码示例1 参数传内置类型

public static void main(String[] args) {
    int num = 0;
    func(num);
    System.out.println("num = " + num);
 }
 
public static void func(int x) {
    x = 10;
    System.out.println("x = " + x);
 }
 
// 执行结果
x = 10
 num = 0

我们发现, 修改形参 x 的值, 不影响实参的 num 值

代码示例2 参数传数组类型

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    func(arr);
    System.out.println("arr[0] = " + arr[0]);
 }
 	public static void func(int[] a) {
	 a[0] = 10;
	 System.out.println("a[0] = " + a[0]);
 }
 // 执行结果
a[0] = 10
 arr[0] = 10

我们发现, 在函数内部修改数组内容, 函数外部也发生改变.

此时数组名 arr 是一个 "引用" . 当传参的时候, 是按照引用传参.

这里我们要先从内存开始说起
如何理解内存?

内存就是指我们熟悉的 "内存". 内存可以直观的理解成一个宿舍楼. 有一个长长的大走廊, 上面有很多房间.

每个房间的大小是 1 Byte (如果计算机有 8G 内存, 则相当于有 80亿 个这样的房间).

每个房间上面又有一个门牌号, 这个门牌号就称为 地址

啥又是引用?

什么是引用?

引用相当于一个 "别名", 也可以理解成一个指针.

创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址.

针对 int[] arr = new int[]{1, 2, 3}

a) 当我们创建 new int[]{1, 2, 3} 的时候, 相当于创建了一块内存空间保存三个 int

b) 接下来执行 int[] arr = new int[]{1, 2, 3} 相当于又创建了一个int[] 变量, 这个变量是一个引用类型, 里面只保存了一个整数(数组的起始内存地址)

c) 接下来我们进行传参相当于 int[] a = arr , 内存布局如图

d) 接下来我们修改 a[0] , 此时是根据 0x100 这样的地址找到对应的内存位置, 将值改成 100

此时已经将 0x100 地址的数据改成了 100 . 那么根据实参 arr 来获取数组内容

arr[0] , 本质上也是获取 地址上的数据, 也是 100

总结: : 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).

2.3 认识 null

null 在 Java 中表示 "空引用" , 也就是一个无效的引用

 int[] arr = null;
 System.out.println(arr[0]);
 // 执行结果
Exception in thread "main" java.lang.NullPointerException
 at Test.main(Test.java:6)

null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException

注意: Java 中并没有约定 null 和 0 号地址的内存有任何关联.

2.4 初识 JVM 内存区域划分(重点)

一个宿舍楼会划分成几个不同的区域: 大一学生, 大二学生... 计算机专业学生, 通信专业学生...

内存也是类似, 这个大走廊被分成很多部分, 每个区域存放不同的数据.

JVM 的内存被划分成了几个区域, 如图所示:

• 虚拟机栈(JVM Stack): 重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[] arr这样的存储地址的引用就是在这里保存.
• 本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.
• 堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} ）
• 方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域
• 运行时常量池(Runtime Constant Pool): 是方法区的一部分, 存放字面量(字符串常量)与符号引用. (注意 从 JDK 1.7 开始, 运行时常量池在堆上)

我们重点理解 虚拟机栈 和 堆.

局部变量和引用保存在栈上, new 出的对象保存在堆上

堆的空间非常大, 栈的空间比较小

堆是整个 JVM 共享一个, 而栈每个线程具有一份(一个 Java 程序中可能存在多个栈)

3. 数组作为方法的返回值

代码示例: 写一个方法, 将数组中的每个元素都 * 2

 

 // 直接修改原数组
class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        transform(arr);
        printArray(arr);
    }
 
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
 
    public static void transform(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * 2;
        }
    }
 }

这个代码固然可行, 但是破坏了原有数组. 有时候我们不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回出来.

//返回一个新的数组
class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int[] output = transform(arr);
        printArray(output);
    }
 
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
 
    public static int[] transform(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i] * 2;
        }
        return ret;
    }
 }

这样的话就不会破坏原有数组了.

另外由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效.

4. 数组练习

4.1 数组转字符串

代码示例

import java.util.Arrays
 
int[] arr = {1,2,3,4,5,6};
 
String newArr = Arrays.toString(arr);
 System.out.println(newArr);
 
// 执行结果
[1, 2, 3, 4, 5, 6]

使用这个方法后续打印数组就更方便一些

Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法.

什么是包?

例如做一碗油泼面, 需要先和面, 擀面, 扯出面条, 再烧水, 下锅煮熟, 放调料, 泼油.
但是其中的 "和面, 擀面, 扯出面条" 环节难度比较大, 不是所有人都能很容易做好. 于是超市就提供了一些直接已经扯好的面条, 可以直接买回来下锅煮. 从而降低了做油泼面的难度, 也提高了制作效率.
程序开发也不是从零开始, 而是要站在巨人的肩膀上.

像我们很多程序写的过程中不必把所有的细节都自己实现, 已经有大量的标准库(JDK提供好的代码)和海量的第三方库(其他机构组织提供的代码)供我们直接使用. 这些代码就放在一个一个的 "包" 之中, 所谓的包就相当于卖面条的超市. 只不过, 超市的面条只有寥寥几种, 而我们可以使用的 "包" , 有成千上万

我们实现一个自己版本的数组转字符串

public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6};
    System.out.println(toString(arr));
 }
 
public static String toString(int[] arr) {
    String ret = "[";
    for (int i = 0; i < arr.length; i++) {
        // 借助 String += 进行拼接字符串
        ret += arr[i];
        // 除了最后一个元素之外, 其他元素后面都要加上 ", "
        if (i != arr.length - 1) {
            ret += ", ";
        }
    }
    ret += "]";
    return ret;
 }

4.2 数组拷贝

代码示例

import java.util.Arrays
 
int[] arr = {1,2,3,4,5,6};
 int[] newArr = Arrays.copyOf(arr, arr.length);
 System.out.println("newArr: " + Arrays.toString(newArr));
 
arr[0] = 10;
 System.out.println("arr: " + Arrays.toString(arr));
 System.out.println("newArr: " + Arrays.toString(newArr));
 
// 拷贝某个范围. 
int[] newArr = Arrays.copyOfRange(arr, 2, 4);
 System.out.println("newArr2: " + Arrays.toString(newArr2));

注意事项: 相比于 newArr = arr 这样的赋值, copyOf 是将数组进行了 深拷贝, 即又创建了一个数组对象, 拷贝原有数组中的所有元素到新数组中. 因此, 修改原数组, 不会影响到新数组.

实现自己版本的拷贝数组

public static int[] copyOf(int[] arr) {
    int[] ret = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        ret[i] = arr[i];
    }
    return ret;
 }

4.3 找数组中的最大元素

给定一个整型数组, 找到其中的最大元素 (找最小元素同理)
代码示例

public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6};
    System.out.println(max(arr));
 }
 
public static int max(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
 }
 
// 执行结果
6

类似于 "打擂台" 这样的过程. 其中 max 变量作为 擂台, 比擂台上的元素大, 就替换上去, 否则就下一个对手.

4.4数组逆序

给定一个数组, 将里面的元素逆序排列
思路

设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.

然后让前一个下标自增, 后一个下标自减, 循环继续即可

代码示例

public static void main(String[] args) {
    int[] arr = {1, 2, 3, 4};
    reverse(arr);
    System.out.println(Arrays.toString(arr));
 }
 
public static void reverse(int[] arr) {
    int left = 0;
      int right = arr.length - 1;
    while (left < right) {
        int tmp = arr[left];
        arr[left] = arr[right];
        arr[right] = tmp;
        left++;
        right--;
    }
 }

类和对象

1. 类与对象的初步认知

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
面向过程 注重的是过程，在整个过程中所涉及的行为，就是功能。
面向对象 注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来
面向过程： 1.把冰箱打开 2. 把大象放入 3. 冰箱关起来 面向对象： 打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。

【面向对象概念】

1.面向对象是思考问题的一种思考方式，是一种思想。比如：概念与实例。理论与实践。名和实等等

2.类就是一类对象的统称。对象就是这一类具体化的一个实例。

3.面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。

【面向对象设计】

面向对象设计把握一个重要的经验：谁拥有数据，谁对外提供操作这些数据（私有）的方法！（被动的一方是数据的拥有者，主动的一方是执行者）

开发时：找对象，建对象，用对象，并维护对象之间的关系。

简而言之

面向对象就是用代码(类)来描述客观世界的事物的一种方式. 一个类主要包含一个事物的属性和行为。

2. 类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例。

简单的例子：我们做月饼的模子就是一个类，而通过这个模子可以做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象,所以月饼就是一个实体。一个模子可以实例化无数个对象。

总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。

声明一个类就是创建一个新的数据类型，而类在java 中属于引用类型，java 使用关键字class 来声明类。我们来看以下简单的声明一个类。

基本语法

// 创建类
class <class_name>{  
field;//成员属性
method;//成员方法
}
 Java 使用关键字
class 来声明类。我们来
// 实例化对象
<class_name> <对象名> = new <class_name>();

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中的元素称为：成员属性。类中的函数称为：成员方法。
示例：

class Person {
 public int age;//成员属性  实例变量
public String name;
 public String sex;
 public void eat() {//成员方法
System.out.println("吃饭!");  
    }
 public void sleep() {
 System.out.println("睡觉!");  
    }
 }

注意事项:

和之前写的方法不同, 此处写的方法不带 static 关键字. 后面我们会详细解释 static 是干啥的

类的实例化

用类类型创建对象的过程，称为类的实例化

1. 类只是一个模型一样的东西，限定了类有哪些成员.
2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

class Person {
 	public int age;//成员属性  实例变量
	public String name;
	 public String sex;
	 public void eat() {//成员方法
		System.out.println("吃饭!");  
    }
	 public void sleep() {
		 System.out.println("睡觉!");  
    }
 }
	 public class Main{
 		public static void main(String[] args) {
		 Person person = new Person();//通过new实例化对象
		person.eat();//成员方法调用需要通过对象的引用调用
		person.sleep();
		 //产生对象 实例化对象
		Person person2 = new Person();
		 Person person3 = new Person() ;  
	}
 }

输出结果为：

吃饭!
睡觉!

注意事项

new 关键字用于创建一个对象的实例.

使用 . 来访问对象中的属性和方法.

同一个类可以创建对个实例.

3. 类的成员

类的成员可以包含以下：字段、方法、代码块、内部类和接口等。

此处重点介绍前三个

3.1 字段/属性/成员变量

在类中, 但是方法外部定义的变量. 这样的变量我们称为 "字段" 或 "属性" 或 "成员变量"(三种称呼都可以, 一般不会严格区分)

用于描述一个类中包含哪些数据

 class Person {
		 public String name;   
		public int age;
 }
 // 字段
class Test {
	 public static void main(String[] args) {
		 Person person = new Person();
		 System.out.println(person.name);
		 System.out.println(person.age);
    }
 }
 // 执行结果
null
 0

注意事项

• 使用 . 访问对象的字段.
• "访问" 既包含读, 也包含写.
• .对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值

认识 null

null 在 Java 中为 "空引用", 表示不引用任何对象. 类似于 C 语言中的空指针. 如果对 null 进行 . 操作就会引发异常

 class Person {
 	public String name;
 	public int age;
 }
 class Test {
 	public static void main(String[] args) {
	 Person person = new Person();
	 System.out.println(person.name.length());   
    }
 }
 // 获取字符串长度
// 执行结果
Exception in thread "main" java.lang.NullPointerException
 at Test.main(Test.java:9)

字段就地初始化

很多时候我们不希望字段使用默认值, 而是需要我们显式设定初值. 可以这样写:

 class Person {
	 public String name = "张三";
 	public int age = 18;
 }
 class Test {
 public static void main(String[] args) {
	 Person person = new Person();
	 System.out.println(person.name);
	 System.out.println(person.age);
    }
 }
 // 执行结果
张三
18

3.2 方法 (method)

就是我们曾经讲过的方法.

用于描述一个对象的行为.

 class Person {
	 public int age = 18;
	 public String name = "张三";
	 public void show() {
		 System.out.println("我叫" + name + ", 今年" + age + "岁");
    }
 }
 class Test {
	 public static void main(String[] args) {
		 Person person = new Person();
		 person.show();
    }
 }
 // 执行结果
我叫张三, 今年18岁

此处的 show 方法, 表示 Person 这个对象具有一个 "展示自我" 的行为.

这样的 show 方法是和 person 实例相关联的. 如果创建了其他实例, 那么 show 的行为就会发生变化

Person person2 = new Person();
 person2.name = "李四";
 person2.age = 20;
 person2.show()
 // 执行结果
我叫李四, 今年20岁

方法中还有一种特殊的方法称为 构造方法 (construction method)

在实例化对象的时候会被自动调用到的方法, 方法名字和类名相同, 用于对象的初始化.

虽然前面已经能将属性就地初始化, 但是有些时候可能需要进行一些更复杂的初始化逻辑, 那么就可以使用构造方法.

3.3 static 关键字

1、修饰属性

2、修饰方法

3、代码块

a) 修饰属性，Java静态属性和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态属性.

class TestDemo{
	 public int a;
 	public static int count;
 }
 public class Main{
	 public static void main(String[] args) {
		 TestDemo t1 = new TestDemo();
		 t1.a++;
		 TestDemo.count++;
		 System.out.println(t1.a);
		 System.out.println(TestDemo.count);
		 System.out.println("============");
		 TestDemo t2 = new TestDemo();
		 t2.a++;
		 TestDemo.count++;
		 System.out.println(t2.a);
 		System.out.println(TestDemo.count);
    }
}

输出结果为:

1
 1
 ============
 1
 2

b) 修饰方法

如果在任何方法上应用static 关键字，此方法称为静态方法。

• 静态方法属于类，而不属于类的对象。
• 可以直接调用静态方法，而无需创建类的实例。
• 静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

class TestDemo{
 	public int a;
	 public static int count;
	 public static void change() {
		 count = 100;
	 //a = 10; error  不可以访问非静态数据成员
    }
 }
 public class Main{
	 public static void main(String[] args) {
		 TestDemo.change()；//无需创建实例对象 就可以调用
		System.out.println(TestDemo.count);   
    }
   }

输出结果

100

注意事项1: 静态方法和实例无关, 而是和类相关. 因此这导致了两个情况

• 静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).

• this和super两个关键字不能在静态上下文中使用(this 是当前实例的引用, super是当前实例父类实例的引用,

  也是和当前实例相关).

注意事项2

• 我们曾经写的方法为了简单, 都统一加上了 static. 但实际上一个方法具体要不要带 static, 都需要是情形而定.
• main 方法为 static 方法

4.封装

什么叫封装?

<<代码大全>> 开篇就在讨论一个问题: 软件开发的本质就是对程序复杂程度的管理. 如果一个软件代码复杂程度太高, 那么就无法继续维护. 如何管理复杂程度? 封装就是最基本的方法.

在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.

这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度

4.1 private实现封装

private/ public 这两个关键字表示 "访问权限控制

• 被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
• 被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用

换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的成本来使用类

直接使用 public

class Person {
 public String name = "张三";
 public int age = 18;
 }
 class Test {
 public static void main(String[] args) {
 Person person = new Person();
 System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");
    }
 }
 // 执行结果
我叫张三, 今年18岁

• 这样的代码导致类的使用者(main方法的代码)必须要了解 Person 类内部的实现, 才能够使用这个类. 学习成本较高
• 一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维护成本较高.

范例：使用 private 封装属性, 并提供 public 方法供类的调用者使用

class Person { 
	private String name = "张三"; 
    private int age = 18; 
    public void show() { 
        System.out.println("我叫" + name + ", 今年" + age + "岁"); 
    } 
} 
class Test { 
    public static void main(String[] args) { 
        Person person = new Person(); 
        person.show(); 
    } 
} 
// 执行结果 
我叫张三, 今年18岁

• 此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法.
  此时类的使用者就不必了解 Person 类的实现细节.
• 同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到 name, age 这样的字段)

那么问题来了~~ 类的实现者万一修改了 public 方法 show 的名字, 岂不是类的调用者仍然需要大量修改代码

嘛?

这件事情确实如此, 但是一般很少会发生. 一般类的设计都要求类提供的 public 方法能比较稳定, 不应该频繁发

生大的改变. 尤其是对于一些基础库中的类, 更是如此. 每次接口的变动都要仔细考虑兼容性问题

注意事项

• private 不光能修饰字段, 也能修饰方法
• 通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希望一个类只提供
  "必要的" public 方法, 而不应该是把所有的方法都无脑设为 public.

4.2 getter和setter方法

当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了
代码示例

class Person { 
private String name = "张三"; 
    private int age = 18; 
    public void show() { 
        System.out.println("我叫" + name + ", 今年" + age + "岁"); 
    }
 }
 class Test {
     public static void main(String[] args) { 
        Person person = new Person(); 
        person.age = 20; 
        person.show(); 
    } 
} 
// 编译出错 
Test.java:13: 错误: age可以在Person中访问private 
        person.age = 20; 
              ^ 
1 个错误 

此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法

代码示例

class Person {   
	private String name;//实例成员变量 
	private  int age; 
	public void setName(String name){ 
        //name = name;//不能这样写 
		this.name = name;//this引用，表示调用该方法的对象 
	} 
	public String getName(){ 
		return name; 
	} 
	public void show(){ 
		System.out.println("name: "+name+" age: "+age); 
	} 
} 
public static void main(String[] args) { 
    Person person = new Person(); 
    person.setName("caocao"); 
    String name = person.getName(); 
    System.out.println(name); 
    person.show(); 
} 
// 运行结果 
caocao 
name: caocao age: 0

注意事项

• getName 即为 getter 方法, 表示获取这个成员的值.
• setName 即为 setter 方法, 表示设置这个成员的值.
• 当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值. this 表示当前实例的引用
• 不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法
• 在 IDEA 中可以使用 alt + insert (或者 alt + F12) 快速生成 setter / getter 方法. 在 VSCode 中可以使用鼠标右键菜单 -> 源代码操作 中自动生成 setter / getter 方法

5. 构造方法

5.1 基本语法

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作.new 执行过程

• 为对象分配内存空间
• 调用对象的构造方法

语法规则

• 1.方法名称必须与类名称相同
• 2.构造方法没有返回值类型声明
• 3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

注意事项

• 如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
• 若类中定义了构造方法，则默认的无参构造将不再生成.
• 构造方法支持重载. 规则和普通方法的重载一致

代码示例

class Person { 
    private String name;//实例成员变量 
    private  int age; 
    private String sex; 
    //默认构造函数    构造对象
      
    public Person() {   
        this.name = "caocao"; 
        this.age = 10; 
        this.sex = "男"; 
    } 
    //带有3个参数的构造函数 
    public Person(String name,int age,String sex) { 
        this.name = name; 
        this.age = age; 
        this.sex = sex; 
        }
         public void show(){ 
        System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
    } 
} 
public class Main{  
    public static void main(String[] args) { 
        Person p1 = new Person();//调用不带参数的构造函数  如果程序没有提供会调用不带参数的构造函数 
        p1.show(); 
        Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数 
        p2.show(); 
    } 
} 
// 执行结果 
name: caocao age: 10 sex: 男 
name: zhangfei age: 80 sex: 男 

5.2 this关键字

this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法.

 class Person { 
    private String name;//实例成员变量 
    private  int age; 
    private String sex; 
    //默认构造函数    构造对象 
    
    public Person() {    
        //this调用构造函数 
        this("bit", 12, "man");//必须放在第一行进行显示 
    } 
    //这两个构造函数之间的关系为重载。 
    public Person(String name,int age,String sex) { 
        this.name = name; 
        this.age = age; 
        this.sex = sex; 
    } 
    public void show() { 
        System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
    } 
} 
public class Main{  
    public static void main(String[] args) { 
        Person person = new Person();//调用不带参数的构造函数 
        person.show(); 
    }
   }
   // 执行结果 
name: bit age: 12 sex: man 

我们会发现在构造函数的内部，我们可以使用this关键字，构造函数是用来构造对象的，对象还没有构造好，我们就使用了this，那this还代表当前对象吗？当然不是，this代表的是当前对象的引用。

6. 认识代码块

字段的初始化方式有：

1. 就地初始化
2. 使用构造方法初始化
3. 使用代码块初始化

代码块初始化

6.1 什么是代码块

使用{}定义的一段代码.

根据代码块定义的位置以及关键字，又可分为以下四种：

• 普通代码块
• 构造块
• 静态块
• 同步代码块（后续讲解多线程部分再谈）

6.2 构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量

class Person{  
	private String name;//实例成员变量 
	private  int age; 
	private String sex;  
	public Person() { 
		System.out.println("I am Person init()!"); 
	} 
	//实例代码块 
	{ 
	this.name = "bit"; 
	this.age = 12; 
	this.sex = "man"; 
        System.out.println("I am instance init()!"); 
} 
public void show(){ 
	System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
	} 
} 
public class Main { 
	public static void main(String[] args) { 
		Person p1 = new Person(); 
		p1.show(); 
	} 
} 
// 运行结果 
I am instance init()! 
I am Person init()! 
name: bit age: 12 sex: man 

注意事项: 实例代码块优先于构造函数执行。

6.3 静态代码块

使用static定义的代码块。一般用于初始化静态成员属性。

class Person{ 
	private String name;//实例成员变量 
	private  int age; 
		private String sex; 
	private static int count = 0;//静态成员变量    
	由类共享数据  方法区 
	public Person(){ 
	System.out.println("I am Person init()!"); 
	} 
     //实例代码块 
	{ 
	this.name = "bit"; 
	this.age = 12; 
	this.sex = "man"; 
        System.out.println("I am instance init()!"); 
} 
//静态代码块 
	static { 
		count = 10;//只能访问静态数据成员  
        System.out.println("I am static init()!"); 
} 
	public void show(){ 
		System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
	} 
} 
	public class Main { 
	public static void main(String[] args) { 
		Person p1 = new Person(); 
         Person p2 = new Person();//静态代码块是否还会被执行？ 
	} 
} 

注意事项

• 静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
• 静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

再谈类和对象

1.1简单认识类

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。

比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。

属性：产品品牌，型号，产品重量，外观尺寸，颜色...

功能：洗衣，烘干、定时...

1.2类的定义格式

在java中定义类时需要用到class关键字，具体语法如下

// 创建类
class ClassName{  
f
 ield;       
// 字段(属性) 或者 成员变量
method;      
}
 // 行为 或者 成员方法

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。

class WashMachine{
    public String brand;   // 品牌
    public String type;    // 型号
    public double weight;  // 重量
    public double length;  // 长
    public double width;  // 宽
    public double height;  // 高
    public String color;   // 颜色
    
    public void washClothes(){   // 洗衣服
        System.out.println("洗衣功能");
    }
    
    public void dryClothes(){    // 脱水
        System.out.println("脱水功能");
    }
    
    public void setTime(){       // 定时
        System.out.println("定时功能");
    }
 }

采用Java语言将洗衣机类在计算机中定义完成，经过javac编译之后形成.class文件，在JVM的基础上计算机就可以识别了.
注意事项

• 类名注意采用大驼峰定义

2.1定义一个狗类

class PetDog {
 	public String name;//名字
	public String color;//颜色
	// 狗的属性
	public void barks() {
		 System.out.println(name + ": 旺旺旺~~~");
	 }
	 // 狗的行为
	public void wag() {
		 System.out.println(name + ": 摇尾巴~~~");
	  }
 }

2.2 定义一个学生类

public class Student{
	 public String name;
 	public String gender;
	 public short  age;
 	public double score;

	 public void DoClass(){}
 	public void DoHomework(){}
 	public void Exam(){}
 }

注意事项：

1. 一般一个文件当中只定义一个类
2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)
3. public修饰的类必须要和文件名相同
4. 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改

3. 类的实例化

3.1 什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：PetDog类和Student类。它们都是类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

public class Main{
    public static void main(String[] args) {
        PetDog dogh = new PetDog();     //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        
        PetDog dogs = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
    }
 }
 
输出结果：
阿黄: 旺旺旺~~~
阿黄: 摇尾巴~~~
赛虎: 旺旺旺~~~
赛虎: 摇尾巴~~~

注意事项

• new 关键字用于创建一个对象的实例.
• 使用 . 来访问对象中的属性和方法.
• 同一个类可以创建对个实例.

3.2 类和对象的说明

1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.
2. 类是一种自定义的类型，可以用来定义变量.
3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

4.this引用

4.1 什么是this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

public class Date {
	 public int year;
	 public int month;
	 public int day;
 	public void setDay(int year, int month, int day){
 		this.year = year;
 		this.month = month;
		 this.day = day;
	 }
 public void printDate(){
	 System.out.println(this.year + "/" + this.month + "/" + this.day)
	 }
 }

注意：this引用的是调用成员方法的对象。

public static void main(String[] args) {
 Date d = new Date();
 d.setDay(2020,9,15);
 d.printDate();
 }

4.2this引用的特性

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

2. this只能在"成员方法"中使用

   比特就业课

3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象

4. this是"成员方法"第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法，对象的引用传递给该成员方法，this负责来接收

5. 对象的构造及初始化

5.1 如何初始化对象

通过前面知识点的学习知道，在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败。

public static void main(String[] args) {
 int a;
 System.out.println(a);
 }
 // Error:(26, 28) java: 可能尚未初始化变量
 

要让上述代码通过编译，非常简单，只需在正式使用a之前，给a设置一个初始值即可。如果是对象：

public static void main(String[] args) {
 Date d = new Date();
 d.printDate();
 d.setDate(2021,6,9);
 d.printDate();
 }

需要调用之前写的SetDate方法才可以将具体的日期设置到对象中。通过上述例子发现两个问题：

1. 每次对象创建好后调用SetDate方法设置具体日期，比较麻烦，那对象该如何初始化？
2. 局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

5.2 构造方法

5.2.1概念

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

public class Date {
    public int year;
    public int month;
    public int day;
 
    // 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Date(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("Date(int,int,int)方法被调用了");
    }
 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
 
    public static void main(String[] args) {
        // 此处创建了一个Date类型的对象，并没有显式调用构造方法
        Date d = new Date(2021,6,9);   // 输出Date(int,int,int)方法被调用了
        d.printDate();    // 2021-6-9
    }
   }

注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

5.2.2 特性

1. 名字必须与类名相同
2. 没有返回值类型，设置为void也不行
3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法
    public Date(){
        this.year = 1900;
        this.month = 1;
        this.day = 1;
    }
     // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
 
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
    }

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。

5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

public class Date {
    public int year;
    public int month;
    public int day;
 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
 
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
    }
 }

上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。

注意：一旦用户定义，编译器则不再生成

public class Date {
    public int year;
    public int month;
    public int day;
 
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
    }
 
    public static void main(String[] args) {
        // 如果编译器会生成，则生成的构造方法一定是无参的
        // 则此处创建对象是可以通过编译的
        // 但实际情况是：编译期报错
        Date d = new Date();
        d.printDate();
    }
 }
 
/*
 Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
  需要: int,int,int
  找到: 没有参数
  原因: 实际参数列表和形式参数列表长度不同
*/
    

6. 构造方法中，可以通过this调用其他构造方法来简化代码
   注意：
   this(...)必须是构造方法中第一条语句

 public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
    // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    // 但是this(1900,1,1);必须是构造方法中第一条语句
    public Date(){
        //System.out.println(year);   注释取消掉，编译会失败
        this(1900, 1, 1);
        
        //this.year = 1900;
        //this.month = 1;
        //this.day = 1;
    }
 
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    }

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下

1. 检测对象对应的类是否加载了，如果没有加载则加载
2. 为对象分配内存空间
3. 处理并发安全问题
   比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突
4. 初始化所分配的空间
5. 调用构造方法，给对象中各个成员赋值

5.3 就地初始化

在声明成员变量时，就直接给出了初始值。

public class Date {
	 public int year = 1900;
	 public int month = 1;
	 public int day = 1;
 		public Date(){
	 }
	 public Date(int year, int month, int day) {
	 }
	 public static void main(String[] args) {
		 Date d1 = new Date(2021,6,9);
		 Date d2 = new Date();
	 }
 }

注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

6. 封装

6.1 封装的概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互

6.2 访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：

public,default,private,protect.

public：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：只有自己知道，其他人都不知道

【说明】

protected主要是用在继承中

default权限指：什么都不写时的默认权限

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

6.3 封装扩展之包

6.3.1 包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件下，也可以对某个文件夹下的音乐进行更详细的分类。

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

6.3.2 导入包中的类

Java 中已经提供了很多现成的类供我们使用. 例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date类

public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
 }

但是这种写法比较麻烦一些, 可以使用 import语句导入包

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
 }

注意事项: import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要. import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using.

内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

public class OutClass {
 class InnerClass{
 }
 }
 // OutClass是外部类
// InnerClass是内部类

【注意事项】

1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

 public class A{
    
}
 
class B{
    
}
 
// A 和 B是两个独立的类，彼此之前没有关系

2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

8.1 内部类的分类

先来看下，内部类都可以在一个类的那些位置进行定义

public class OutClass {
    // 成员位置定义：未被static修饰 --->实例内部类
    public class InnerClass1{
    }
 
    // 成员位置定义：被static修饰 ---> 静态内部类
    static class InnerClass2{
 
    }
 
 
    public void method(){
        // 方法中也可以定义内部类 ---> 局部内部类：几乎不用
        class InnerClass5{
 
        }
       }
    }

根据内部类定义的位置不同，一般可以分为以下几种形式：

1. 成员内部类(普通内部类：未被static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)
2. 局部内部类(不谈修饰符)、匿名内部类
   注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中使用最多的是匿名内部类。

9.1 内部类

在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类

9.1.1 实例内部类

即未被static修饰的成员内部类。

public class OutClass {
    private int a;
    static int b;
    int c;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }
 
    public static void methodB(){
        System.out.println(b);
    }
 
    //  实例内部类：未被static修饰
    class InnerClass{
        int c;
        public void methodInner(){
            // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            a = 100;
            b =200;
            methodA();
            methodB();
 
            // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 300;
            System.out.println(c);
 
            // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
            OutClass.this.c = 400;
            System.out.println(OutClass.this.c);
        }
    }
 
    public static void main(String[] args) {
        // 外部类：对象创建 以及 成员访问
        OutClass outClass = new OutClass();
        System.out.println(outClass.a);
        System.out.println(OutClass.b);
        System.out.println(outClass.c);
        outClass.methodA();
        outClass.methodB();
 
        System.out.println("=============实例内部类的访问=============");
        // 要访问实例内部类中成员，必须要创建实例内部类的对象
        // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
 
        // 创建实例内部类对象
        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
 
        // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
        innerClass2.methodInner();
    }
   }

【注意事项】

1. 外部类中的任何成员都可以在实例内部类方法中直接访问
2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问
4. 实例内部类对象必须在先有外部类对象前提下才能创建
5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

8.1.2 静态内部类

被static修饰的内部成员类称为静态内部类。

public class OutClass {
    private int a;
    static int b;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }
 
    public static void methodB(){
        System.out.println(b);
    }
 
    // 静态内部类：被static修饰的成员内部类
    static class InnerClass{
        public void methodInner(){
            // 在内部类中只能访问外部类的静态成员
            // a = 100;      // 编译失败，因为a不是类成员变量
            b =200;
            // methodA();    // 编译失败，因为methodB()不是类成员方法
            methodB();
        }
    }
 
    public static void main(String[] args) {
        // 静态内部类对象创建 & 成员访问
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.methodInner();
    }
 }

【注意事项】

1. 在静态内部类中只能访问外部类中的静态成员

2. 创建静态内部类对象时，不需要先创建外部类对象

8.2 局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法格式。

public class OutClass {
    int a = 10;
    public void method(){
        int b = 10;
 
        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        }
 
        // 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }
 
    public static void main(String[] args) {
        // OutClass.InnerClass innerClass = null; 编译失败
    }
 }

【注意事项】

1. 局部内部类只能在所定义的方法体内部使用
2. 不能被public、static等修饰符修饰
3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class
4. 几乎不会使用

继承和多态

1 继承

1.1 为什么需要继承

Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。

比如：狗和猫，它们都是一个动物

使用Java语言来进行描述，就会设计出：

// Dog.java
 public class Dog{
	 string name;
	 int age;
	 float weight;
 public void eat(){
	 System.out.println(name + "正在吃饭");
 }
 public void sleep(){
	 System.out.println(name + "正在睡觉");
 }
	void Bark(){
System.out.println(name + "汪汪汪~~~");
	 }
 }
 // Cat.Java
 public class Cat{
	 string name;
	 int age;
	 float weight;
 public void eat(){
	 System.out.println(name + "正在吃饭");
 }
 public void sleep()
 {
	 System.out.println(name + "正在睡觉");
 }
 void mew(){
	 System.out.println(name + "喵喵喵~~~");
	 }
 }

通过观察上述代码会发现，猫和狗的类中存在大量重复，那能否将这些共性抽取呢？
面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。

1.2 继承概念

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

例如：狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。

从继承概念中可以看出继承最大的作用就是：实现代码复用，实现多态.

1.3 继承的语法

在Java中如果要表示类之间的继承关系，需要借助extends关键字，具体如下:

修饰符 class 子类 extends 父类 {
 // ...  
}

对1.2中场景使用继承方式重新设计:

// Animal.java
 public class Animal{
	 String name;
	 int age;
	 public void eat(){
		 System.out.println(name + "正在吃饭");
	 }
	 public void sleep(){
		 System.out.println(name + "正在睡觉");
	 }
 }
	 // Dog.java
	 public class Dog extends Animal{    
	void bark(){
		 System.out.println(name + "汪汪汪~~~");
	 }
 }
// Cat.Java
 public class Cat extends Animal{   
	void mew(){
	 System.out.println(name + "喵喵喵~~~");
	 }
 }
 // TestExtend.java
 public class TestExtend {
 	public static void main(String[] args) {
		 Dog dog = new Dog();
 	// dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
	System.out.println(dog.name);
	 System.out.println(dog.age);
 // dog访问的eat()和sleep()方法也是从Animal中继承下来的
	dog.eat();
	 dog.sleep();
	 dog.bark();
	 }
 }

注意：

1. 子类会将父类中的成员变量或者成员方法继承到子类中了
2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

1.4 父类成员访问

在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

1.4.1 子类中访问父类的成员变量

1. 子类和父类不存在同名成员变量

public class Base {
	 int a;
	 int b;
	 }
 public class Derived extends Base{
	 int c;
	 public void method(){
		 a = 10;    // 访问从父类中继承下来的a
		 b = 20;    // 访问从父类中继承下来的b
		 c = 30;    // 访问子类自己的c
 	}
 }

2. 子类和父类成员变量同名

public class Base {
    int a;
    int b;
    int c;
 }
 
/
 public class Derived extends Base{
    int a;              // 与父类中成员a同名，且类型相同
    char b;             // 与父类中成员b同名，但类型不同
 
    public void method(){
        a = 100;        // 访问父类继承的a，还是子类自己新增的a？
        b = 101;        // 访问父类继承的b，还是子类自己新增的b?
        c = 102;        // 子类没有c，访问的肯定是从父类继承下来的c
        // d = 103;     // 编译失败，因为父类和子类都没有定义成员变量b
    }
 }

在子类方法中 或者 通过子类对象访问成员时：

如果访问的成员变量子类中有，优先访问自己的成员变量。

如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。

如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

1.4.2 子类中访问父类的成员方法

1. 成员方法名字不同

 public class Base {
     public void methodA(){
         System.out.println("Base中的methodA()");
     }
 }
 
public class Derived extends Base{
    public void methodB(){
        System.out.println("Derived中的methodB()方法");
    }
    
    public void methodC(){
        methodB();         // 访问子类自己的methodB()
        methodA();         // 访问父类继承的methodA()
        // methodD();      // 编译失败，在整个继承体系中没有发现方法methodD()
    }
 }

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时

再到父类中找，如果父类中也没有则报错。

2. 成员方法名字相同

public class Base {
     public void methodA(){
         System.out.println("Base中的methodA()");
     }
 
     public void methodB(){
         System.out.println("Base中的methodB()");
     }
 }
 
public class Derived extends Base{
    public void methodA(int a) {
        System.out.println("Derived中的method(int)方法");
    }
 
    public void methodB(){
        System.out.println("Derived中的methodB()方法");
    }
 
    public void methodC(){
        methodA();      // 没有传参，访问父类中的methodA()
        methodA(20);    // 传递int参数，访问子类中的methodA(int)
        methodB();      // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
    }
 }

【说明】

通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。

通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

1.5 super关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。

public class Base {
    int a;
    int b;
 public void methodA(){
     System.out.println("Base中的methodA()");
 }
 
 public void methodB(){
     System.out.println("Base中的methodB()");
 }
 }

public class Derived extends Base{
    int a;    // 与父类中成员变量同名且类型相同
    char b;   // 与父类中成员变量同名但类型不同
    // 与父类中methodA()构成重载
    public void methodA(int a) {
        System.out.println("Derived中的method()方法");
    }
 
    // 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
    public void methodB(){
        System.out.println("Derived中的methodB()方法");
    }
 
    public void methodC(){
        // 对于同名的成员变量，直接访问时，访问的都是子类的
        a = 100;   // 等价于： this.a = 100;
        b = 101;   // 等价于： this.b = 101;
        // 注意：this是当前对象的引用
 
        // 访问父类的成员变量时，需要借助super关键字
        // super是获取到子类对象中从基类继承下来的部分
        super.a = 200;
        super.b = 201;
 
 
        // 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
        methodA();      // 没有传参，访问父类中的methodA()
        methodA(20);    // 传递int参数，访问子类中的methodA(int)
 
        // 如果在子类中要访问重写的基类方法，则需要借助super关键字
        methodB();      // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
        super.methodB(); // 访问基类的methodB()
    }
 }

在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。

【注意事项】
1. 只能在非静态方法中使用
2. 在子类方法中，访问父类的成员变量和方法。

1.6 子类构造方法

父子父子，先有父再有子，即：子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。

public class Base {
    public Base(){
        System.out.println("Base()");
 }
 }
  public class Derived extends Base{
 public Derived(){
 // super();   // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
 // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
// 并且只能出现一次
System.out.println("Derived()");
 }
 }
 public class Test {
 public static void main(String[] args) {
 Derived d = new Derived();
 }
 }
结果打印：
Base()
 Derived()

在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 。

注意：

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构
   造方法
2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的
   父类构造方法调用，否则编译失败。
3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现

1.7 super和this

super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

【相同点】

1. 都是Java中的关键字
2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

【不同点】

1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
3. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造
   方法中出现
4. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

1.8 再谈初始化

实例代码块和静态代码块。在没有继承关系时的执行顺序。

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造方法执行");
    }
    {
        System.out.println("实例代码块执行");
    }
    static {
        System.out.println("静态代码块执行");
    }
 }
 
public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person("bit",10);
        System.out.println("============================");
           Person person2 = new Person("wedv",20);
    }
 }

执行结果：

静态代码块执行
实例代码块执行
构造方法执行
============================
实例代码块执行
构造方法执行

1. 静态代码块先执行，并且只执行一次，在类加载阶段执行

2. 当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行

【继承关系上的执行顺序】

class Person {
 public String name;
 public int age;
 public Person(String name, int age) {
 this.name = name;
 this.age = age;
 System.out.println("Person：构造方法执行");
 }
 {
 System.out.println("Person：实例代码块执行");
 }
 static {
 System.out.println("Person：静态代码块执行");
 }
 }
 class Student extends Person{
 public Student(String name,int age) {
 super(name,age);
 System.out.println("Student：构造方法执行");
 }
 {
 }
 System.out.println("Student：实例代码块执行");
 static {
 System.out.println("Student：静态代码块执行");
 }
 }
 public class TestDemo4 {
 public static void main(String[] args) {
 Student student1 = new Student("张三",19);
 System.out.println("===========================");

Student student2 = new Student("wedcbv",20);
}
 public static void main1(String[] args) {
 Person person1 = new Person("bit",10);
 System.out.println("============================");
 Person person2 = new Person("wedcbv",20);
	 }
 }

执行结果：

Person：静态代码块执行
Student：静态代码块执行
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行
===========================
 Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行

通过分析执行结果，得出以下结论：

1、父类静态代码块优先于子类静态代码块执行，且是最早执行

2、父类实例代码块和父类构造方法紧接着执行

3、子类的实例代码块和子类构造方法紧接着再执行

4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

1.10继承方式

在Java中只支持以下几种继承方式：单继承，多层继承，不同类继承同一个类

注意：Java中不支持多继承

时刻牢记, 我们写的类是现实事物的抽象. 而我们真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到一系列复杂的概念, 都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多. 类之间的关系也会

更加复杂.

但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.

如果想从语法上进行限制继承, 就可以使用 final 关键字

1.11final关键字

final关键可以用来修饰变量、成员方法以及类。

1. 修饰变量或字段，表示常量(即不能修改）

 final int a = 10;
 a = 20;  // 编译出错

2. 修饰类：表示此类不能被继承

final public class Animal {
 ...
 }
 public class Bird extends Animal {
 ...
 }
 // 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继

多态

2.1 多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。

2.2 多态实现条件

在java中要实现多态，必须要满足如下几个条件，缺一不可：
1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。

public class Animal {
	 String name;
	 int age;
	 public Animal(String name, int age){
 		this.name = name;
		 this.age = age;
	 }
	 public void eat(){
			System.out.println(name + "吃饭");
	 }
 }
 public class Cat extends Animal{
 	public Cat(String name, int age){
 		super(name, age);
	 }
	 @Override
	 public void eat(){
	 System.out.println(name+"吃鱼~~~");
	 }
 }
 public class Dog extends Animal {
 	public Dog(String name, int age){
		 super(name, age);
	 }
 	@Override
 	public void eat(){
		 System.out.println(name+"吃骨头~~~");
	 }
 }
 ///分割线//
 public class TestAnimal {
 // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
// 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
// 注意：此处的形参类型必须时父类类型才可以

public static void eat(Animal a){
	a.eat();
 }
 public static void main(String[] args) {
 	Cat cat = new Cat("元宝",2);
	 Dog dog = new Dog("小七", 1);
 	eat(cat);
	 eat(dog);
 	}
 }
运行结果：
元宝吃鱼~~~
元宝正在睡觉
小七吃骨头~~~
小七正在睡觉

在上述代码中, 分割线上方的代码是 类的实现者 编写的, 分割线下方的代码是 类的调用者 编写的.

当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例. 此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态.

2.3 重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变 。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定

于自己的行为。 也就是说子类能够根据需要实现父类的方法。

【方法重写的规则】

• 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
• 被重写的方法返回值类型可以不同，但是必须是具有父子关系的
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected
• 父类被static、private修饰的方法、构造方法都不能被重写。
• 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

【重写和重载的区别】

即：方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

【重写的设计原则】

对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，并且添加或者改动新的内容。

静态绑定 ：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

2.4 向上转移和向下转型

2.4.1 向上转型

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。

语法格式：父类类型 对象名 = new 子类类型()

Animal animal = new Cat("元宝",2);

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

【使用场景】

1. 直接赋值
2. 方法传参
3. 方法返回

public class TestAnimal {
    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void eatFood(Animal a){
        a.eat();
    }
 
    // 3. 作返回值：返回任意子类对象
    public static Animal buyAnimal(String var){
        if("狗".equals(var) ){
            return new Dog("狗狗",1);
        }else if("猫" .equals(var)){
            return new Cat("猫猫", 1);
        }else{
            return null;
        }
    }
 
    public static void main(String[] args) {
        Animal cat = new Cat("元宝",2);   // 1. 直接赋值：子类对象赋值给父类对象
        Dog dog = new Dog("小七", 1);
 
        eatFood(cat);
        eatFood(dog);
 
        Animal animal = buyAnimal("狗");
        animal.eat();
 
        animal = buyAnimal("猫");
        animal.eat();
    }
 }

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

2.4.2 向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换.

public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
 
        // 向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();
 
        // 编译失败，编译时编译器将animal当成Animal对象处理
        // 而Animal类中没有bark方法，因此编译失败
        // animal.bark();
 
        // 向上转型
        // 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
        // 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
        cat = (Cat)animal;
        cat.mew();
 
        // animal本来指向的就是狗，因此将animal还原为狗也是安全的   
        dog = (Dog)animal;
        dog.bark();
    }
 }

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了instanceof，如果该表达式为true，则可以安全转换。

public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
 
        // 向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();
 
        if(animal instanceof Cat){
            cat = (Cat)animal;
            cat.mew();
        }
 
        if(animal instanceof Dog){
            dog = (Dog)animal;
            dog.bark();
        }
    }
 }

instanceof 关键词

【使用多态的好处】
1. 能够降低代码的 "圈复杂度", 避免使用大量的 if - else

什么叫 "圈复杂度" ?

圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂.

因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 "圈复杂度".

如果一个方法的圈复杂度太高, 就需要考虑重构.

不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10

如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单

2. 可扩展能力更强

多态缺陷：代码的运行效率降低

1. 属性没有多态性
   当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
2. 构造方法没有多态性

抽象类和接口

1. 抽象类
   1.1 抽象类概念
   在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
   
   像这种没有实际工作的方法, 我们可以把它设计成一个 抽象方法(abstract method), 包含抽象方法的类我们称为 抽象类(abstract class).

1.2 抽象类语法

在Java中，一个类如果被abstract 修饰称为抽象类，抽象类中被abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

// 抽象类：被abstract修饰的类
public abstract class Shape {
 // 抽象方法：被abstract修饰的方法，没有方法体
abstract public void draw();
 abstract void calcArea();
 // 抽象类也是类，也可以增加普通方法和属性
public double getArea(){
 return area;
 }
 protected double area;    // 面积
 }

注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

1.3 抽象类特性

1. 抽象类不能直接实例化对象

Shape shape = new Shape();
 
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化

2. 抽象方法不能是 private 的

abstract class Shape {
    abstract private void draw();
 }
 
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private

3. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写

public abstract class Shape {
    abstract final void methodA();
    abstract public static void methodB();
 }
 
// 编译报错：
// Error:(20, 25) java: 非法的修饰符组合: abstract和final
 // Error:(21, 33) java: 非法的修饰符组合: abstract和static

4. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用abstract修饰

// 矩形类
public class Rect extends Shape {
    private double length;
    private double width;
 
    Rect(double length, double width){
        this.length = length;
        this.width = width;
    }
 
    public void draw(){
        System.out.println("矩形: length= "+length+" width= " + width);
    }
 
    public void calcArea(){
        area = length * width;
    }
 }
 
// 圆类：
public class Circle extends Shape{
 private double r;
 final private static double PI = 3.14;
 public Circle(double r){
 this.r = r;
 }
 public void draw(){
 System.out.println("圆：r = "+r);
 }
 public void calcArea(){
 area = PI * r * r;
 }
 }
 // 三角形类：
public abstract class Triangle extends Shape {
 private double a;
 private double b;
 private double c;
 @Override
 public void draw() {
 System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
 }
 // 三角形：直角三角形、等腰三角形等，还可以继续细化
//@Override
 //double calcArea();   // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类
}

5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

1.4 抽象类的作用

抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法

使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题.

很多语法存在的意义都是为了 "预防出错", 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们.充分利用编译器的校验, 在实际开发中是非常有意义的.

2. 接口

2.1 接口的概念

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等。

通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型

2.2 语法规则

接口的定义格式与定义类的格式基本相同，将class关键字换成interface 关键字，就定义了一个接口。

public interface 接口名称{
 // 抽象方法
public abstract void method1();   // public abstract 是固定搭配，可以不写
public void method2();
 abstract void method3();
 void method4();
 }
 // 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁

提示：

1. 创建接口时, 接口的命名一般以大写字母

   I 开头.

2. 接口的命名一般使用 "形容词" 词性的单词.

3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性

2.3 接口使用

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法.

public  class 类名称 implements 接口名称{
 // ...
 } 

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系.

请实现笔记本电脑使用USB鼠标、USB键盘的例子

1. USB接口：包含打开设备、关闭设备功能
2. 笔记本类：包含开机功能、关机功能、使用USB设备功能
3. 鼠标类：实现USB接口，并具备点击功能
4. 键盘类：实现USB接口，并具备输入功能

// USB接口
public interface USB {
 void openDevice();
 void closeDevice();
 }
 // 鼠标类，实现USB接口
public class Mouse implements USB {
 @Override
 public void openDevice() {
 System.out.println("打开鼠标");
 }
 

```java
  @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }
 
    public void click(){
        System.out.println("鼠标点击");
    }
 }
 
// 键盘类，实现USB接口
public class KeyBoard implements USB {
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }
 
    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }
 
    public void inPut(){
        System.out.println("键盘输入");
    }
 }
 
// 笔记本类：使用USB设备
public class Computer {
    public void powerOn(){
        System.out.println("打开笔记本电脑");
    }
 
    public void powerOff(){
        System.out.println("关闭笔记本电脑");
    }
 
    public void useDevice(USB usb){
        usb.openDevice();
        if(usb instanceof Mouse){
            Mouse mouse = (Mouse)usb;
            mouse.click();
        }else if(usb instanceof KeyBoard){
            KeyBoard keyBoard = (KeyBoard)usb;
            keyBoard.inPut();
        }
        usb.closeDevice();
    }
 }
 
// 测试类：
public class TestUSB {
    public static void main(String[] args) {
       Computer computer = new Computer();
        computer.powerOn();
 
        // 使用鼠标设备
        computer.useDevice(new Mouse());
 
        // 使用键盘设备
        computer.useDevice(new KeyBoard());
 
        computer.powerOff();
    }
 }

2.4 接口特性

1. 接口类型是一种引用类型，但是不能直接new接口的对象

public class TestUSB {
    public static void main(String[] args) {
        USB usb = new USB();
    }
 }
 
// Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化

2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错）

public interface USB {
    // Error:(4, 18) java: 此处不允许使用修饰符private
    private void openDevice();
    void closeDevice();
 }

3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

public interface USB {
    void openDevice();
    
    // 编译失败：因为接口中的方式默认为抽象方法
    // Error:(5, 23) java: 接口抽象方法不能带有主体
    void closeDevice(){
        System.out.println("关闭USB设备");
    }
 }

4. 重写接口中方法时，不能使用默认的访问权限

 public interface USB {
  void openDevice();    // 默认是public的
    void closeDevice();   // 默认是public的
}
 
public class Mouse implements USB {
    @Override
    void openDevice() {
        System.out.println("打开鼠标");
    }
    
    // ...
 }
 
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public
 

5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
6. 接口中不能有静态代码块和构造方法
7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
9. jdk8中：接口中还可以包含default方法。

2.5 实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。下面通过类来表示一组动物.

class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
 }

另外我们再提供一组接口, 分别表示 "会飞的", "会跑的", "会游泳的"

 interface IFlying {
    void fly();
 }
 
interface IRunning {
    void run();
 }
 
interface ISwimming {
    void swim();
 

接下来我们创建几个具体的动物

猫, 是会跑的.

class Cat extends Animal implements IRunning {
    public Cat(String name) {
        super(name);
    }
 
    @Override
    public void run() {
        System.out.println(this.name + "正在用四条腿跑");
    }
 }

鱼, 是会游的

class Fish extends Animal implements ISwimming {
    public Fish(String name) {
        super(name);
    }
 
    @Override
    public void swim() {
        System.out.println(this.name + "正在用尾巴游泳");
    }
 }

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力.

还有一种神奇的动物, 水陆空三栖, 叫做 "鸭子

class Duck extends Animal implements IRunning, ISwimming, IFlying {
    public Duck(String name) {
        super(name);
    }
 
    @Override
    public void fly() {
        System.out.println(this.name + "正在用翅膀飞");
 
    }
 
    @Override
    public void run() {
          System.out.println(this.name + "正在用两条腿跑");
    }
     
    @Override
    public void swim() {
        System.out.println(this.name + "正在用两条腿跑");
    }
  }

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口

2.6 接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

interface IRunning {
    void run();
 }
 
interface ISwimming {
    void swim();
 }
 
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
 
}
 
class Frog implements IAmphibious {
    ...
 }

通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法

接口间的继承相当于把多个接口合并在一起.

2.8Clonable 接口和深拷贝

Java 中内置了一些很有用的接口, Clonable 就是其中之一.

Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常

class Animal implements Cloneable {
    private String name;
 
    @Override
    public Animal clone() {
        Animal o = null;
        try {
            o = (Animal)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
 }
 
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal animal2 = animal.clone();
        System.out.println(animal == animal2);
    }
 }
 
// 输出结果
// false

浅拷贝 VS 深拷贝

Cloneable 拷贝出的对象是一份 "浅拷贝"

观察以下代码:

class Money {
    public double m = 99.99;
 }
 
class Person implements Cloneable{
    public Money money = new Money();
 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
 }
 
public class TestDemo3 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person) person.clone();
        System.out.println("通过person2修改前的结果");
        System.out.println(person1.money.m);
          System.out.println(person2.money.m);
        person2.money.m = 13.6;
        System.out.println("通过person2修改后的结果");
        System.out.println(person1.money.m);
        System.out.println(person2.money.m);
    }
 }
// 执行结果
通过person2修改前的结果
99.99
 99.99
通过person2修改后的结果
13.6
 13.6

如上代码，我们可以看到，通过clone，我们只是拷贝了Person对象。但是Person对象中的Money对象，并没有拷贝。通过person2这个引用修改了m的值后，person1这个引用访问m的时候，值也发生了改变。这里就是发生了浅拷贝。

2.9对象比较equals方法

在Java中，进行比较时：
a.如果左右两侧是基本类型变量，比较的是变量中值是否相同

b.如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同

c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：

// Object类中的equals方法
public boolean equals(Object obj) {
    return (this == obj);   // 使用引用中的地址直接来进行比较
}
 class Person{
    private String name ; 
    private int age ; 
    public Person(String name, int age) {
      this.age = age ; 
        this.name = name ;
    }
 }
 public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("gaobo", 20) ; 
        Person p2 = new Person("gaobo", 20) ; 
        int a = 10;
        int b = 10;
        System.out.println(a == b);             // 输出true
        System.out.println(p1 == p2);           // 输出false
        System.out.println(p1.equals(p2));      // 输出false
    }
 }

Person类重写equals方法后，然后比较：

class Person{
    ...
    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false ; 
        }
        if(this == obj) {
            return true ; 
        }
        // 不是Person类对象
        if (!(obj instanceof Person)) {
            return false ; 
        }
        
        Person person = (Person) obj ; // 向下转型，比较属性值
        return this.name.equals(person.name) && this.age==person.age ; 
    }
   }

结论：比较对象中内容是否相同的时候，一定要重写equals方法。

认识 String 类

1. 创建字符串

常见的构造 String 的方式:

// 方式一
String str = "Hello Bit";
 // 方式二
String str2 = new String("Hello Bit");
 // 方式三
char[] array = {'a', 'b', 'c'};
 String str3 = new String(array);

注意事项:

• "hello" 这样的字符串字面值常量, 类型也是 String. String 也是引用类型.
• String str = "Hello"; 这样的代码内存布局如下

回忆 "引用

引用类似于 C 语言中的指针, 只是在栈上开辟了一小块内存空间保存一个地址. 但是引用和指针又不太相同, 指针能进行各种数字运算(指针+1)之类的, 但是引用不能, 这是一种 "没那么灵活" 的指针.

另外, 也可以把引用想象成一个标签, "贴" 到一个对象上. 一个对象可以贴一个标签, 也可以贴多个. 如果一个对象上面一个标签都没有, 那么这个对象就会被 JVM 当做垃圾对象回收掉.

Java 中数组, String, 以及自定义的类都是引用类型

由于 String 是引用类型, 因此对于以下代码

String str1 = "Hello";
 String str2 = str1;

是不是修改 str1 , str2 也会随之变化呢?

 str1 = "world";
 System.out.println(str2);
 // 执行结果
Hello

我们发现, "修改" str1 之后, str2 也没发生变化, 还是 hello?

事实上, str1 = "world" 这样的代码并不算 "修改" 字符串, 而是让 str1 这个引用指向了一个新的 String 对象

2. 字符串比较相等

如果现在有两个int型变量，判断其相等可以使用== 完成。

int x = 10 ;
 int y = 10 ;
 System.out.println(x == y); 
// 执行结果
true

如果说现在在String类对象上使用 == ？
代码1

 String str1 = "Hello";
 String str2 = "Hello"; 
System.out.println(str1 == str2); 
// 执行结果
true  

看起来貌似没啥问题, 再换个代码试试, 发现情况不太妙
代码2

 String str1 = new String("Hello");
 String str2 = new String("Hello");
 System.out.println(str1 == str2);
 // 执行结果
false

我们发现, str1 和 str2 是指向同一个对象的. 此时如 "Hello" 这样的字符串常量是在 字符串常量池 中

关于字符串常量池

如 "Hello" 这样的字符串字面值常量, 也是需要一定的内存空间来存储的. 这样的常量具有一个特点, 就是不需要修改(常量嘛). 所以如果代码中有多个地方引用都需要使用 "Hello" 的话, 就直接引用到常量池的这个位置就行了, 而没必要把 "Hello" 在内存中存储两次

通过 String str1 = new String("Hello"); 这样的方式创建的 String 对象相当于再堆上另外开辟了空间来存储"Hello" 的内容, 也就是内存中存在两份 "Hello"

String 使用 == 比较并不是在比较字符串内容, 而是比较两个引用是否是指向同一个对象

关于对象的比较

面向对象编程语言中, 涉及到对象的比较, 有三种不同的方式, 比较身份, 比较值, 比较类型.

在大部分编程语言中 == 是用来比较值的. 但是 Java 中的 == 是用来比较身份的.

如何理解比较值和比较身份呢?

可以想象一个场景, 现在取快递, 都有包裹储物柜. 上面有很多的格子. 每个格子里面都放着东西

例如, "第二行, 左数第五列" 这个柜子和 "第二行, 右数第二列" 这个柜子是同一个柜子, 就是 身份相同. 如果身份相同, 那么里面放的东西一定也相同 (值一定也相同).

例如, "第一行, 左数第一列" 这个柜子和 "第一行, 左数第二列" 这两个柜子不是同一个柜子, 但是柜子打开后发现里面放着的是完全一模一样的两双鞋子. 这个时候就是 值相同.

Java 中要想比较字符串的内容, 必须采用String类提供的equals方法

 String str1 = new String("Hello");
 String str2 = new String("Hello");
 System.out.println(str1.equals(str2));
 // System.out.println(str2.equals(str1)); // 或者这样写也行
// 执行结果
true

equals 使用注意事项

现在需要比较 str 和 "Hello" 两个字符串是否相等, 我们该如何来写呢

String str = new String("Hello");
 // 方式一
System.out.println(str.equals("Hello"));
 // 方式二
System.out.println("Hello".equals(str));

在上面的代码中, 哪种方式更好呢?

我们更推荐使用 "方式二". 一旦 str 是 null, 方式一的代码会抛出异常, 而方式二不会

 String str = null;
 // 方式一
System.out.println(str.equals("Hello"));  // 执行结果 抛出 java.lang.NullPointerException 异
常
// 方式二
System.out.println("Hello".equals(str));  // 执行结果 false

注意事项: "Hello" 这样的字面值常量, 本质上也是一个 String 对象, 完全可以使用 equals 等 String 对象的方法.

3. 字符串常量池

在上面的例子中, String类的两种实例化操作, 直接赋值和 new 一个新的 String.
a) 直接赋值

String str1 = "hello" ;
 String str2 = "hello" ; 
String str3 = "hello" ; 
System.out.println(str1 == str2); // true
 System.out.println(str1 == str3); // true
 System.out.println(str2 == str3); // true

在JVM底层实际上会自动维护一个对象池（字符串常量池)

• 如果现在采用了直接赋值的模式进行String类的对象实例化操作，那么该实例化对象（字符串内容）将自动保存 到这个对象池之中.
• 如果下次继续使用直接赋值的模式声明String类对象，此时对象池之中如若有指定内容，将直接进行引用
• 如若没有，则开辟新的字符串对象而后将其保存在对象池之中以供下次使用

理解 "池" (pool)

"池" 是编程中的一种常见的, 重要的提升效率的方式, 我们会在未来的学习中遇到各种 "内存池", "线程池", "数据库连接池" ...

然而池这样的概念不是计算机独有, 也是来自于生活中. 举个栗子:

现实生活中有一种女神, 称为 "绿茶", 在和高富帅谈着对象的同时, 还可能和别的屌丝搞暧昧. 这时候这个屌丝被 称为 "备胎".

那么为啥要有备胎? 因为一旦和高富帅分手了, 就可以立刻找备胎接盘, 这样 效率比较高.

如果这个女神, 同时在和很多个屌丝搞暧昧, 那么这些备胎就称为 备胎池

b) 采用构造方法

类对象使用构造方法实例化是标准做法。分析如下程序

String str = new String("hello") ;

这样的做法有两个缺点:

1. 如果使用String构造方法就会开辟两块堆内存空间，并且其中一块堆内存将成为垃圾空间(字符串常量 "hello" 也是一个匿名对象, 用了一次之后就不再使用了, 就成为垃圾空间, 会被 JVM 自动回收掉).
2. 字符串共享问题. 同一个字符串可能会被存储多次, 比较浪费空间

5. 字符, 字节与字符串

5.1 字符与字符串

字符串内部包含一个字符数组，String 可以和 char[] 相互转换

代码示例: 获取指定位置的字符

String str = "hello" ;  
System.out.println(str.charAt(0));  // 下标从 0 开始 
// 执行结果 
h 
System.out.println(str.charAt(10)); 
// 执行结果 
产生 StringIndexOutOfBoundsException 异常 

5.2 字节与字符串

字节常用于数据传输以及编码转换的处理之中，String 也能方便的和 byte[] 相互转换

代码示例: 实现字符串与字节数组的转换处理

String str = "helloworld" ;  
// String 转 byte[] 
byte[] data = str.getBytes() ;  
for (int i = 0; i < data.length; i++) {  
    System.out.print(data[i]+" "); 
} 
// byte[] 转 String 
System.out.println(new String(data));

6. 字符串常见操作

6.1 字符串比较

代码示例: 不区分大小写比较

String str1 = "hello" ;  
String str2 = "Hello" ;  
System.out.println(str1.equals(str2)); // false 
System.out.println(str1.equalsIgnoreCase(str2)); // true 

在String类中compareTo()方法是一个非常重要的方法，该方法返回一个整型，该数据会根据大小关系返回三类内容：

1. 相等：返回0.

2. 小于：返回内容小于0.

3. 大于：返回内容大于0。

范例：观察compareTo()比较

System.out.println("A".compareTo("a")); // -32 
System.out.println("a".compareTo("A")); // 32 
System.out.println("A".compareTo("A")); // 0 
System.out.println("AB".compareTo("AC")); // -1 
System.out.println("刘".compareTo("杨")); 

compareTo()是一个可以区分大小关系的方法，是String方法里是一个非常重要的方法。

字符串的比较大小规则, 总结成三个字 "字典序" 相当于判定两个字符串在一本词典的前面还是后面. 先比较第一个字符的大小(根据 unicode 的值来判定), 如果不分胜负, 就依次比较后面的内容

6.2 字符串查找

代码示例: 字符串查找，最好用最方便的就是contains()

 String str = "helloworld" ;  
System.out.println(str.contains("world")); // true

代码示例: 使用indexOf()方法进行位置查找

String str = "helloworld" ;  
System.out.println(str.indexOf("world")); // 5,w开始的索引 
System.out.println(str.indexOf("bit")); // -1，没有查到 
if (str.indexOf("hello") != -1) { 
    System.out.println("可以查到指定字符串！"); 
} 

现在基本都是用contains()方法完成。

使用indexOf()需要注意的是，如果内容重复，它只能返回查找的第一个位置

代码示例: 使用indexOf()的注意点

String str = "helloworld" ;  
System.out.println(str.indexOf("l")); // 2 
System.out.println(str.indexOf("l",5)); // 8 
System.out.println(str.lastIndexOf("l")); // 8

在进行查找的时候往往会判断开头或结尾。

代码示例: 判断开头或结尾

String str = "**@@helloworld!!" ;  
System.out.println(str.startsWith("**")); // true 
System.out.println(str.startsWith("@@",2)); // ture 
System.out.println(str.endsWith("!!")); // true

6.3 字符串替换

代码示例: 字符串的替换处理

String str = "helloworld" ;  
System.out.println(str.replaceAll("l", "_")); 
System.out.println(str.replaceFirst("l", "_")); 

注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串.

6.4 字符串拆分

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。

代码示例: 实现字符串的拆分处理

String str = "hello world hello bit" ;  
String[] result = str.split(" ") ; // 按照空格拆分 
for(String s: result) { 
    System.out.println(s); 
}

代码示例: 字符串的部分拆分

String str = "hello world hello bit" ;  
String[] result = str.split(" ",2) ;  
for(String s: result) { 
    System.out.println(s); 
} 

拆分是特别常用的操作. 一定要重点掌握. 另外有些特殊字符作为分割符可能无法正确切分, 需要加上转义.
注意事项:

1. 字符"|","*","+"都得加上转义字符，前面加上"".
2. 而如果是""，那么就得写成"\".
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

6.5 字符串截取

代码示例: 观察字符串截取

String str = "helloworld" ;  
System.out.println(str.substring(5)); 
System.out.println(str.substring(0, 5));

注意事项:

1. 索引从0开始
2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标

6.6 其他操作方法

代码示例: 大小写转换

String str = "   hello%$$%@#$%world 哈哈哈  " ;  
System.out.println(str.toUpperCase()); 
System.out.println(str.toLowerCase());

代码示例: 字符串length（）

 String str = "   hello%$$%@#$%world 哈哈哈  " ;  
System.out.println(str.length()); 

注意：数组长度使用数组名称.length属性，而String中使用的是length()方法

7. StringBuffer 和 StringBuilder

首先来回顾下String类的特点：

任何的字符串常量都是String对象，而且String的常量一旦声明不可改变，如果改变对象内容，改变的是其引用的指向而已。

通常来讲String的操作比较简单，但是由于String的不可更改特性，为了方便字符串的修改，提供StringBuffer和StringBuilder类。

StringBuffer 和 StringBuilder 大部分功能是相同的，我们课件上主要介绍 StringBuffer在String中使用"+"来进行字符串连接，但是这个操作在StringBuffer类中需要更改为append()方法：

范例:观察StringBuffer使用

public class Test{ 
	public static void main(String[] args) { 
		StringBuffer sb = new StringBuffer(); 
		sb.append("Hello").append("World"); 
		fun(sb); 
		System.out.println(sb); 
	} 
	public static void fun(StringBuffer temp) { 
		temp.append("\n").append("www.bit.com.cn"); 
	} 
} 

String和StringBuffer最大的区别在于：String的内容无法修改，而StringBuffer的内容可以修改。频繁修改字符串的情况考虑使用StingBuffer。

注意：String和StringBuffer类不能直接转换。如果要想互相转换，可以采用如下原则:

• String变为StringBuffer:利用StringBuffer的构造方法或append()方法
• StringBuffer变为String:调用toString()方法。

除了append()方法外，StringBuffer也有一些String类没有的方法:

代码示例: 字符串反转

StringBuffer sb = new StringBuffer("helloworld"); 
System.out.println(sb.reverse()); 

代码示例: 观察删除操作

StringBuffer sb = new StringBuffer("helloworld"); 
System.out.println(sb.delete(5, 10)); 

代码示例: 观察插入操作

StringBuffer sb = new StringBuffer("helloworld"); 
System.out.println(sb.delete(5, 10).insert(0, "你好"));

解释String、StringBuffer、StringBuilder的区别：

• String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
• StringBuffer与StringBuilder大部分功能是相似的
• StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作

小结

1. 字符串的比较, ==, equals, compareTo 之间的区别.
2. 了解字符串常量池, 体会 "池" 的思想.
3. 理解字符串不可变
4. split 的应用场景
5. StringBuffer 和 StringBuilder 的功能.

认识异常

1. 异常的背景

初识异常

我们曾经的代码中已经接触了一些 "异常" 了. 例如

除以 0

 System.out.println(10 / 0);
 // 执行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero

数组下标越界

int[] arr = {1, 2, 3};
 System.out.println(arr[100]);
 // 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

访问 null 对象

public class Test {
 public int num = 10;
 public static void main(String[] args) {
 Test t = null;
 System.out.println(t.num);
    }
 }
 // 执行结果
Exception in thread "main" java.lang.NullPointerException

所谓异常指的就是程序在 运行时 出现错误时通知调用者的一种机制.

关键字 "运行时"

有些错误是这样的, 例如将 System.out.println 拼写错了, 写成了 system.out.println. 此时编译过程中就会出错, 这是 "编译期" 出错.

而运行时指的是程序已经编译通过得到 class 文件了, 再由 JVM 执行过程中出现的错误

异常的种类有很多, 不同种类的异常具有不同的含义, 也有不同的处理方式

防御式编程

错误在代码中是客观存在的. 因此我们要让程序出现问题的时候及时通知程序猿. 我们有两种主要的方式.

LBYL: Look Before You Leap. 在操作之前就做充分的检查.

EAFP: It's Easier to Ask Forgiveness than Permission. "事后获取原谅比事前获取许可更容易". 也就是先操作, 遇到问题再处理.

异常的好处

例如, 我们用伪代码演示一下开始一局王者荣耀的过程

EAFP 风格的代码(使用异常)

 try {
登陆游戏();
开始匹配();
游戏确认();
选择英雄();
载入游戏画面();
    ...
 } catch (登陆游戏异常) {
处理登陆游戏异常;
 } catch (开始匹配异常) {
处理开始匹配异常;
 } catch (游戏确认异常) {
处理游戏确认异常;
 } catch (选择英雄异常) {
处理选择英雄异常;
 } catch (载入游戏画面异常) {
处理载入游戏画面异常;
 }
 ......

2. 异常的基本用法

捕获异常
基本语法

try{    
有可能出现异常的语句 ; 
}[catch (异常类型 异常对象) {
 } ... ]
 [finally {
异常的出口
}]

• try 代码块中放的是可能出现异常的代码.
• catch 代码块中放的是出现异常后的处理行为.
• finally 代码块中的代码用于处理善后工作, 会在最后执行.
• 其中 catch 和 finally 都可以根据情况选择加或者不加

代码示例1 不处理异常

int[] arr = {1, 2, 3};
 	System.out.println("before");
	 System.out.println(arr[100]);
 	System.out.println("after");
 // 执行结果
before
 Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

我们发现一旦出现异常, 程序就终止了. after 没有正确输出

代码示例2 使用 try catch 后的程序执行过程

int[] arr = {1, 2, 3};
 try {
 	System.out.println("before");
 	System.out.println(arr[100]);
 	System.out.println("after");
 		} catch (ArrayIndexOutOfBoundsException e) {
 	// 打印出现异常的调用栈
		e.printStackTrace();
	 }
		 System.out.println("after try catch");
	 // 执行结果
before
 java.lang.ArrayIndexOutOfBoundsException: 100
 at demo02.Test.main(Test.java:10)
 after try catch

我们发现, 一旦 try 中出现异常, 那么 try 代码块中的程序就不会继续执行, 而是交给 catch 中的代码来执行. catch 执行完毕会继续往下执行.

关于异常的处理方式

异常的种类有很多, 我们要根据不同的业务场景来决定.

对于比较严重的问题(例如和算钱相关的场景), 应该让程序直接崩溃, 防止造成更严重的后果

对于不太严重的问题(大多数场景), 可以记录错误日志, 并通过监控报警程序及时通知程序猿

对于可能会恢复的问题(和网络相关的场景), 可以尝试进行重试.

在我们当前的代码中采取的是经过简化的第二种方式. 我们记录的错误日志是出现异常的方法调用信息, 能很快速的让我们找到出现异常的位置. 以后在实际工作中我们会采取更完备的方式来记录异常信息

代码示例3 catch 只能处理对应种类的异常

我们修改了代码, 让代码抛出的是空指针异常.

 int[] arr = {1, 2, 3};
 try {
 	System.out.println("before");
 	arr = null;
 	System.out.println(arr[100]);
	 System.out.println("after");
		 } catch (ArrayIndexOutOfBoundsException e) {
		 e.printStackTrace();
	 }
		 System.out.println("after try catch");
 // 执行结果
	before
Exception in thread "main" 	java.lang.NullPointerException
 at demo02.Test.main(Test.java:11)

此时, catch 语句不能捕获到刚才的空指针异常. 因为异常类型不匹配

代码示例4 catch 可以有多个

int[] arr = {1, 2, 3};
 try {
 	System.out.println("before");
 	arr = null;
 	System.out.println(arr[100]);
 	System.out.println("after");
	 } catch (ArrayIndexOutOfBoundsException e) {
		 System.out.println("这是个数组下标越界异常");
		 e.printStackTrace();
	 } catch (NullPointerException e) {
		 System.out.println("这是个空指针异常");
		 e.printStackTrace();
	 }
		 System.out.println("after try catch");
 // 执行结果
	before
这是个空指针异常
java.lang.NullPointerException
 at demo02.Test.main(Test.java:12)
 after try catch

一段代码可能会抛出多种不同的异常, 不同的异常有不同的处理方式. 因此可以搭配多个 catch 代码块.

如果多个异常的处理方式是完全相同, 也可以写成这样

catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
 ...
 }

代码示例6 finally 表示最后的善后工作, 例如释放资源

int[] arr = {1, 2, 3};
 try {
 System.out.println("before");
 arr = null;
 System.out.println(arr[100]);
 System.out.println("after");
 } catch (Exception e) {
 e.printStackTrace();
 } finally {
 System.out.println("finally code");
 }
 // 执行结果
before
 java.lang.NullPointerException
 at demo02.Test.main(Test.java:12)
 finally code

无论是否存在异常, finally 中的代码一定都会执行到. 保证最终一定会执行到 Scanner 的 close 方法

代码示例7 使用 try 负责回收资源

刚才的代码可以有一种等价写法, 将 Scanner 对象在 try 的 ( ) 中创建, 就能保证在 try 执行完毕后自动调用 Scanner的 close 方法.

 try (Scanner sc = new Scanner(System.in)) {
 int num = sc.nextInt();
 System.out.println("num = " + num);
 } catch (Exception e) {
 e.printStackTrace();
 }

异常处理流程

• 程序先执行 try 中的代码
• 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.
• 如果找到匹配的异常类型, 就会执行 catch 中的代码
• 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
• 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).
• 如果上层调用者也没有处理的了异常, 就继续向上传递.
• 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止

抛出异常

除了 Java 内置的类会抛出一些异常之外, 程序猿也可以手动抛出某个异常. 使用 throw 关键字完成这个操作

 public static void main(String[] args) { 
    System.out.println(divide(10, 0)); 
} 
public static int divide(int x, int y) { 
    if (y == 0) { 
        throw new ArithmeticException("抛出除 0 异常"); 
    } 
    return x / y; 
} 
// 执行结果 
Exception in thread "main" java.lang.ArithmeticException: 抛出除 0 异常 
at demo02.Test.divide(Test.java:14) 
at demo02.Test.main(Test.java:9) 

在这个代码中, 我们可以根据实际情况来抛出需要的异常. 在构造异常对象同时可以指定一些描述性信息

异常说明

我们在处理异常的时候, 通常希望知道这段代码中究竟会出现哪些可能的异常.

我们可以使用 throws 关键字, 把可能抛出的异常显式的标注在方法定义的位置. 从而提醒调用者要注意捕获这些异常

 public static int divide(int x, int y) throws ArithmeticException { 
    if (y == 0) { 
        throw new ArithmeticException("抛出除 0 异常"); 
    } 
    return x / y; 
} 

关于 finally 的注意事项

 public static void main(String[] args) { 
    System.out.println(func()); 
} 
public static int func() { 
    try { 
        return 10; 
    } finally { 
        return 20; 
    } 
} 
// 执行结果 
20

注意

• finally 执行的时机是在方法返回之前(try 或者 catch 中如果有 return 会在这个 return 之前执行
  finally). 但是如果
• finally 中也存在 return 语句, 那么就会执行 finally 中的 return, 从而不会执行到 try 中原有的
  return.

自定义异常类

Java 中虽然已经内置了丰富的异常类, 但是我们实际场景中可能还有一些情况需要我们对异常类进行扩展, 创建符合我们实际情况的异常

例如, 我们实现一个用户登陆功能

 public class Test { 
    private static String userName = "admin"; 
    private static String password = "123456"; 
    public static void main(String[] args) { 
        login("admin", "123456"); 
    } 

    public static void login(String userName, String password) { 
        if (!Test.userName.equals(userName)) { 
            // TODO 处理用户名错误 
        } 
        if (!Test.password.equals(password)) { 
            // TODO 处理密码错误 
        } 
        System.out.println("登陆成功"); 
        }
      }
        
    

此时我们在处理用户名密码错误的时候可能就需要抛出两种异常. 我们可以基于已有的异常类进行扩展(继承), 创建和我们业务相关的异常类.

class UserError extends Exception { 
    public UserError(String message) { 
        super(message); 
    } 
} 
class PasswordError extends Exception { 
    public PasswordError(String message) { 
        super(message); 
    } 
} 

此时我们的 login 代码可以改成

public static void main(String[] args) { 
    try { 
        login("admin", "123456"); 
    } catch (UserError userError) { 
        userError.printStackTrace(); 
    } catch (PasswordError passwordError) { 
        passwordError.printStackTrace(); 
    } 
} 
public static void login(String userName, String password) throws UserError,       
PasswordError { 
    if (!Test.userName.equals(userName)) { 
        throw new UserError("用户名错误"); 
    } 
    if (!Test.password.equals(password)) { 
        throw new PasswordError("密码错误"); 
    } 
    System.out.println("登陆成功"); 
}

注意事项

• 自定义异常通常会继承自 Exception 或者 RuntimeException
• 继承自 Exception 的异常默认是受查异常
• 继承自 RuntimeException 的异常默认是非受查异常