学习java中的笔记

学习java中整理的笔记

java基础知识1 Java概述

1.1 Java语言发展史1.2 Java开发环境1.3 JDK的下载和安装

1.3.1 下载1.3.2 安装 2 入门程序HelloWorld

2.1 常用DOS命令2.2 HelloWorld案例

2.2.1 Java程序开发运行流程2.2.2 HelloWorld案例的编写2.2.3 HelloWorld案例的编译和运行 3 IDEA安装使用

3.1 下载3.2 安装3.3 idea常用快捷键 4 Java基础语法

4.1 注释

单行注释多行注释 4.2 数据类型

4.2.1 计算机存储单元4.2.2 变量 4.3 Java中的基本数据类型4.4 关键字、标志符

4.4.1 关键字4.4.1 标志符 4.5 基本命名规定

4.5.1 变量名称4.5.2 类名称 4.6 类型间的转换

4.6.1 自动/隐式类型转换：小类型到大类型4.6.2 强制类型转换：大类型到小类型 4.7 运算符

4.7.1 算术运算符4.7.2 关系运算符4.7.3 逻辑运算符4.7.4 赋值运算符4.7.5 短路逻辑运算符4.7.6 字符的“+”操作4.7.7 字符串的“+”操作4.7.8 三元运算符 4.8 流程控制语句

4.8.1 顺序结构4.8.2 分支结构(if, switch)

1. if语句：2. switch语句： 4.8.3 循环结构(for, while, do…while)

1. for循环语句2. while循环语句3. do…while循环语句4. 三种循环的区别5. 跳转控制语句6. 循环嵌套 5. 数组

5.1 数组定义格式

5.1.1 第一种方式5.1.2 第二种方式 5.2 数组动态初始化5.3静态初始化格式5.4 访问数组元素格式5.5 索引越界异常5.6 空指针异常5.7 数组遍历5.8 数组最值 6 方法

6.1 定义方法：6.2 调用方法：6.3 return：6.4 形参和实参6.5 方法重载 7 类和对象

7.1 对象的使用7.2 成员变量和局部变量的区别7.3 封装思想7.4 构造方法7.5 构造方法的注意事项7.6 private关键字7.7 this关键字 8 继承

8.1 继承概念8.2 继承特点8.3 继承的作用8.4 继承带来的好处与弊端8.5 super关键字8.6 this&super关键字8.7 向上造型8.8 方法的重写 9 多态

9.1 常见形式9.2 多态中成员访问特点9.3 多态的前提9.4 多态的优势9.5 向上造型/自动类型转换：9.6 强制类型转换9.7 可能出现的异常 10 访问控制权限修饰符11 static关键字

11.1 static作用11.2 静态成员变量11.3 静态成员方法11.4 静态代码块 12 final关键字

12.1 static final常量 13 抽象类14 接口

14.1 定义接口14.2 实现接口14.3 接口的特点14.4 接口的成员特点14.5 类和接口的关系14.6抽象类和接口的区别 15 内部类

15.1 成员内部类15.2 匿名内部类 16 内存分配

16.1 内存概述16.2 java中的内存分配16.3 内存管理 17 面向对象三大特征18 String类

18.1 概述18.2 String常用构造方法：18.3 String常用方法18.4 StringBuilder类18.4 常量池 19 正则表达式

String支持与正则表达式相关的方法 20 Object类

20.1 Object类的作用20.2 Object类的常用方法20.3 ==操作符与equals方法 21 包装类

21.1 包装类的作用21.2 包装类的特有功能

java基础知识 1 Java概述 1.1 Java语言发展史

语言：人与人交流沟通的表达方式计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言Java之父：詹姆斯·高斯林（James Gosling）2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可：https://www.oracle.com

1.2 Java开发环境

JVM（Java Virtual Machine），Java虚拟机 加载.class并运行.classJRE（Java Runtime Environment），运行环境，包含了JVM和Java的核心类库（Java
API）JRE=JVM+Java系统类库JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具 JDK = JRE+编译、运行等命令工具编译运行过程：
编译期：.java源文件，经过编译，生成.class字节码文件
运行期：JVM加载.class并运行.class(0和1)

总结：

其特点为跨平台、一次编程到处使用，我们只需安装JDK即可，它包含了java的运行环境JRE和虚拟机JVM。说明：
运行java程序的最小环境为JRE
开发java程序的最小环境为JDK

1.3 JDK的下载和安装 1.3.1 下载

通过官方网站下载JDK，官方网站： http://www.oracle.com

找到下面页面进行选择下载：

注意：有Windows、Linux、macOS系统版本不同的JDK，根据自己使用的操作系统，下载对应版本的JDK。

1.3.2 安装

下载后安装JDK，安装过程中点击下一步即可。但默认的安装路径是在C:Program FilesJavajdkxxx下，为方便统一管理建议修改安装路径，将与开发相关的软件都安装到一个目录下。例如我们选择安装目录为 C:Program Files (x86)Javajdk1.8.0_301。

注意：建议安装路径不要包含中文或者空格等特殊字符（使用纯英文目录）。

下面变量设置参数如下：

变量名：JAVA_HOME变量值：D:Javajdk1.8.0_301 // 要根据自己的实际路径配置变量名：Path变量值：%JAVA_HOME%bin;

注意：如果发现环境变量中某一项已经存在，则说明你安装的JDK版本已经给你配置了，需要配置没有出现的环境变量

安装完成后，需要我们手动配置Java的环境变量，此电脑右键->点击属性->往下滑找到高级系统设置->点击高级->点击环境变量

在系统环境变量下点击**新建(W)…**输入变量名和变量值确定。

在系统环境变量下找到Path选中后点击编辑，在右侧点击新建，输入%JAVA_HOME%bin确定即可。


验证环境变量是否配置成功，win+r输入cmd输入javac和java -version


配置成功。
注意：路径不能出错，建议到对应的安装路径复制。

2 入门程序HelloWorld 2.1 常用DOS命令

在接触集成开发环境之前，我们需要使用命令行窗口对java程序进行编译和运行，所以需要知道一些常用DOS命令。

1、打开命令行窗口的方式：win + r打开运行窗口，输入cmd，回车。

2、常用命令及其作用

操作	说明
盘符名称:	盘符切换。E:回车，表示切换到E盘。
dir	查看当前路径下的内容。
cd 目录	进入单级目录。cd itheima
cd …	回退到上一级目录。
cd 目录1目录2…	进入多级目录。cd itheimaJavaSE
cd	回退到盘符目录。
cls	清屏。
exit	退出命令提示符窗口。

2.2 HelloWorld案例

HelloWorld案例是指在计算机屏幕上输出“HelloWorld”。

2.2.1 Java程序开发运行流程

开发Java程序，需要三个步骤：编写程序，编译程序，运行程序。

2.2.2 HelloWorld案例的编写

1、新建文本文档文件，修改名称为HelloWorld.java。

2、用记事本打开HelloWorld.java文件，输写程序内容。

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

2.2.3 HelloWorld案例的编译和运行

保存文件，打开命令行窗口，将目录切换至java文件所在目录，在这里直接建议打开HelloWorld.java的文件夹，在地址栏输入cmd，编译java文件生成class文件，运行class文件，感受Java的编写程序->编译->运行。

编译：javac 文件名.java
范例：javac HelloWorld.java
执行：java 类名
范例：java HelloWorld

3 IDEA安装使用 3.1 下载

进入 IDEA 官方下载页面，（官网地址为 https://www.jetbrains.com/idea/），点击 DOWNLOAD。

3.2 安装

打开后选择安装路径，首先会显示欢迎界面，next下一步，选择安装路径建议选择其它盘，到配置安装选项在Create Desktop Shortcut中选择64-bit launcher，意思是将64位启动程序添加到桌面，然后一直下一步即可。

安装完成后启动，第一次打开会弹出一个激活框，选中evaluate for free-免费评估，再点击evaluate评估，可以免费试用30天，安装完成。

3.3 idea常用快捷键

记得这些快捷键可以提高敲代码的速度。

快捷键	功能
Alt + Enter	神键，可以根据光标所在问题，提供快速修复大部分问题选择，光标放在的位置不同提示的结果也不同
Ctrl + Z	撤销
Ctrl + Shift + Z	取消撤销
Alt+Shift+上下箭头	移动当前代码行
Ctrl+D	复制光标所在行的内容，插入光标位置下面
Ctrl+Y	删除光标所在行
Ctrl + Alt + L	格式化代码，可以对当前类或者文件和整个包目录使用
Ctrl + Alt + V	自动补全前面的代码或者加.var
Ctrl + F	在当前文件进行文本查找
Ctrl + R	在当前文件进行文本替换
Ctrl + O	选择可重写的方法
Ctrl + /	注释光标所在行代码，会根据当前不同文件类型使用不同的注释符号//
Ctrl + Shift + /	代码块注释
Shift+Enter	光标跳到下一行并回车，在敲代码中不用按end来Enter
Ctrl+Enter	向下回车，光标不动
Ctrl+Shift+Enter	回车并格式化这行代码，并自动补分号；
Alt + Insert	代码自动生成，如生成构造方法对象的 set / get 方法，toString() 等
Ctrl + Alt + O	优化导入的类，可以对当前文件和整个包目录使用
Ctrl + Shift + F	根据输入内容查找整个项目 或 指定目录内文件
Ctrl + Shift + R	根据输入内容替换对应内容，范围为整个项目 或 指定目录内文件
Ctrl + Shift + Enter	自动结束代码，行末自动添加分号

4 Java基础语法

一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

 1. 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
 2. 类：类是一个模板，它描述一类对象的行为和状态。
 3. 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
 4. 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

4.1 注释

提高代码阅读性，解释代码的作用

单行注释

//单行注释

多行注释

4.2 数据类型 4.2.1 计算机存储单元

计算机底层都是一些数字电路(理解成开关)，用开表示0、关表示1，这些01的形式就是二进制。

数据在计算机底层都是采用二进制存储的，l在计算机中认为一个开关表示的0|1称为1位（b），每8位称为一个字节（B）， 所以1B=8b

字节是计算机中数据的最小单位。

我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母”b”表示。而计算机中最基本的存储单元叫“字节（byte）”，

通常用大写字母”B”表示，字节是由连续的8个位组成。

除了字节外还有一些常用的存储单位，其换算单位如下：

1B（字节） = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

4.2.2 变量

变量：在程序运行过程中，其值可以发生改变的量。

从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。

声明格式：

//数据类型 变量名;
int a; //声明了一个整型的变量，名为a
int b,c,d; //声明了三个整型的变量，名为b,c,d
//int a; //编译错误，变量不能同名

初始化/第一次赋值：

int a = 250; //声明整型变量a并赋值为250
int b;   //声明整型变量b
b = 250; //给变量b赋值为250
b = 360; //修改变量b的值为360

使用：

int a = 5;
int b = a + 10; //取出a的值5，加10后，再赋值给变量b
System.out.println(b);   //输出变量b的值15
System.out.println("b"); //输出b，双引号中的原样输出
a = a+10; //在a本身基础之上增10
System.out.println(a); //输出变量a的值15

使用之前必须声明并初始化：

int a = 5;
int b = a + 10; //取出a的值5，加10后，再赋值给变量b
System.out.println(b);   //输出变量b的值15
System.out.println("b"); //输出b，双引号中的原样输出
a = a+10; //在a本身基础之上增10
System.out.println(a); //输出变量a的值15

4.3 Java中的基本数据类型

八种基本数据类型

数据类型	关键字	内存占用（字节）	取值范围
整数	byte	1	负的2的7次方 ~ 2的7次方-1(-128~127)
	short	2	负的2的15次方 ~ 2的15次方-1(-32768~32767)
	int	4	负的2的31次方 ~ 2的31次方-1
	long	8	负的2的63次方 ~ 2的63次方-1
浮点数	float	4	1.401298e-45 ~ 3.402823e+38
	double	8	4.9000000e-324 ~ 1.797693e+308
字符	char	2	0-65535
布尔	boolean	1	true，false

注意： float类型：数据后必须加F或者f表示。

int：整型，4个字节，-21个多亿到21个多亿

整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)运算时若超范围，则发生溢出(溢出不是错误，但是需要避免)

//1)int:整型，4个字节，-21个多亿到21个多亿
int a = 25; //25为整数直接量，默认为int型
//int b = 10000000000; //编译错误，100亿默认为int类型，但超出范围了
//int c = 25.678; //编译错误，整型变量中不能装小数
System.out.println(5/2);   //2
System.out.println(2/5);   //0
System.out.println(5/2.0); //2.5
int d = 2147483647; //int的最大值
d = d+1;
System.out.println(d); //-2147483648(int的最小值)，发生溢出了

long：长整型，8个字节，很大很大很大

长整型直接量需在数字后加L或l运算时若有可能溢出，建议在第1个数字后加L

//2)long:长整型，8个字节，很大很大很大
long a = 25L; //25L为长整型直接量
//long b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
long c = 10000000000L;
//运算时若有可能溢出，建议在第1个数字后加L
long d = 1000000000*2*10L;
System.out.println(d); //200亿
long e = 1000000000*3*10L;
System.out.println(e); //不是300亿
long f = 1000000000L*3*10;
System.out.println(f); //300亿

double：浮点型，8个字节，很大很大很大

浮点数直接量默认为double型，若表示float需在数字后加F或fdouble和float型数据参与运算时，有可能会发生舍入误差，精确场合不能使用

//3)double:浮点型，8个字节，很大很大很大
double a = 3.14; //3.14为浮点型直接量，默认double型
float b = 3.14F; //3.14F为float型直接量
double c = 12340000000000000000000000.0;
System.out.println(c); //1.234E25，科学计数法表示，相当于1.234*(10的25次幂)

double d=3.0,e=2.9;
System.out.println(d-e); //0.10000000000000009，有可能发生舍入误差

boolean：布尔型，1个字节

只能存储true或false

//4)boolean:布尔型，1个字节
boolean b1 = true;  //true为布尔型直接量
boolean b2 = false; //false为布尔型直接量
//boolean b3 = 25; //编译错误，布尔型只能取值为true或false

char：字符型，2个字节

采用Unicode字符集编码格式，一个字符对应一个码，
表现的形式是字符char，但本质上是码int(0到65535之间)
ASCII码：‘a’—97 ‘A’—65 ‘0’—48字符型直接量必须放在单引号中，有且仅有一个字符特殊符号需通过来转义

//5)char:字符型，2个字节
char c1 = '女'; //字符女
char c2 = 'f';  //字符f
char c3 = '6';  //字符6
char c4 = '*';  //字符*
//char c5 = 女; //编译错误，字符型直接量必须放在单引号中
//char c6 = ''; //编译错误，必须有字符
//char c7 = '女性'; //编译错误，只能有1个字符

char c8 = 65; //0到65535之间----一般不这么用
System.out.println(c8); //println()输出时会依据c8的数据类型来显示
//若c8为char型，则显示为字符
//若c8为int型，则显示为数字
char c9 = '\';
System.out.println(c9); //

4.4 关键字、标志符 4.4.1 关键字

Java自己保留的一些单词，作为特殊功能的，例如：public、class、byte、short、int、long、double…我们不能用来作为类名或者是变量名称，否则报错。

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

4.4.1 标志符

标志符就是由一些字符、符号组合起来的名称，用于给类，方法，变量等起名字的规矩。基本要求：由数字、字母、下划线(_)和美元符($)等组成强制要求：不能以数字开头、不能是关键字、区分大小写 4.5 基本命名规定 4.5.1 变量名称

只能包含字母、数字、_和$符，不能以数字开头严格区分大小写不能使用关键字满足标识符规则，建议全英文、有意义、首字母小写，满足“小驼峰命名法”。

4.5.2 类名称

满足标识符规则，建议全英文、有意义、首字母大写，满足“大驼峰命名法”，例如：HelloWorld.java。

class TestOne{
	public static void main(String[] args) throws IOException {
	int a1,a_5$,_3c,$t;
	//int a*b; //编译错误，不能包含*等特殊符号
	//int 1a; //编译错误，不能以数字开头
	int aa = 5;
	//System.out.println(aA); //编译错误，严格区分大小写
	//int class; //编译错误，不能使用关键字

	int 年龄; //允许，但不建议
	int nianLing; //必须杜绝，既不直观也不专业
	int age; //建议---英文的见名知意
	int score,myScore,myJavaScore; //建议"小驼峰命名法"
	}
}

4.6 类型间的转换

基本类型由小到大依次为：

4.6.1 自动/隐式类型转换：小类型到大类型

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可。

int a = 5;
long b = a; //自动/隐式类型转换
int c = (int)b; //强制类型转换

long d = 5; //自动类型转换
double e = 5; //自动类型转换

注意事项：
整数直接量可以直接赋值给byte,short,char，但不能超出范围。
byte,short,char型数据参与运算时，系统一律自动将其转换为int再运算 。

4.6.2 强制类型转换：大类型到小类型

类型范围大的数据或者变量，不能直接赋值给类型范围小的变量，会报错，把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量必须进行强制类型转换。

强制类型转换格式：目标数据类型 变量名 = (目标数据类型)值或者变量;

long f = 10000000000L;
int g = (int)f; //强制类型转换
System.out.println(g); //1410065408，强转有可能发生溢出
double h = 25.987;
int i = (int)h; //强转类型转换
System.out.println(i); //25，强转有可能丢失精度

注意：boolean类型不能与其他基本数据类型相互转换。

4.7 运算符 4.7.1 算术运算符

符号	作用	说明
+	加	加法 - 相加运算符两侧的值
-	减	减法 - 左操作数减去右操作数
*	乘	乘法 - 相乘操作符两侧的值
/	除	除法 - 左操作数除以右操作数
%	取余	获取的是两个数据做除法的余数
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21
–	自减: 操作数的值减少1	B-- 或 --B 等于 19

//%的演示
System.out.println(8%2); //0，商4余0----整除
System.out.println(5%2); //1，商2余1
System.out.println(2%8); //2，商0余2

//++单独使用:
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6

//++被使用:
int a=5,b=5;
int c = a++; //1)保存a++的值5  2)a自增1变为6  3)将第1步保存的值5赋值给c--底层运算过程
//---粗暴记法:a++的值为5，c就是5
int d = ++b; //1)保存++b的值6  2)b自增1变为6  3)将第1步保存的值6赋值给d--底层运算过程
//---粗暴记法:++b的值为6，d就是6
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6

//--单独使用:
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4

//--被使用:
int a=5,b=5;
int c = a--; //a--的值为5，所以c的值为5
int d = --b; //--b的值为4，所以d的值为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4

4.7.2 关系运算符

符号	说明
==	a==b，判断a和b的值是否相等，成立为true，不成立为false
!=	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<	a
<=	a<=b，判断a是否小于等于b，成立为true，不成立为false

int a=5,b=10,c=5;
boolean b1 = a>b;
System.out.println(b1);   //false
System.out.println(c=c); //true
System.out.println(a<=b); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false

System.out.println(a+c>b);  //false
System.out.println(a%2==0); //false
System.out.println(c++>5);  //false-------c自增1变为6
System.out.println(c++>5);  //true--------c自增1变为7

注意事项：

关系运算符的结果都是boolean类型，要么是true，要么是false。

4.7.3 逻辑运算符

符号	作用	说明
&	逻辑与	a&b，a和b都是true，结果为true，否则为false
|	逻辑或	a|b，a和b都是false，结果为false，否则为true
^	逻辑异或	a^b，a和b结果不同为true，相同为false
!	逻辑非	!a，结果和a的结果正好相反

//定义变量
int i = 10;
int j = 20;
int k = 30;

//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
System.out.println("--------");

//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
System.out.println("--------");

//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
System.out.println("--------");

//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true

4.7.4 赋值运算符

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a*=b，将a×b的值给a
/=	除后赋值	a/=b，将a÷b的商给a
%=	取余后赋值	a%=b，将a÷b的余数给a

注意：扩展的赋值运算符隐含了强制类型转换。

short s = 10;
s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度

s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

4.7.5 短路逻辑运算符

符号	作用	说明
&&	短路与	作用和&相同，但是有短路效果
||	短路或	作用和|相同，但是有短路效果

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

逻辑与&，无论左边真假，右边都要执行。

短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。

逻辑或|，无论左边真假，右边都要执行。

短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
System.out.println(x); // 4
System.out.println(y); // 5

System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算
System.out.println(x); // 4
System.out.println(y); // 4

4.7.6 字符的“+”操作

char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值：

‘a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加

‘A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加

‘0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加

// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
char ch1 = 'a';
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98

char ch2 = 'A';
System.out.println(ch2 + 1); // 输出66，65 + 1 = 66

char ch3 = '0';
System.out.println(ch3 + 1); // 输出49，48 + 1 = 49

4.7.7 字符串的“+”操作

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。

System.out.println("a"+ 666); // 输出：a666

在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。

System.out.println(1 + 99 + "年s"); // 输出：100年s
System.out.println(1 + 2 + "ssss" + 3 + 4); // 输出：3ssss34
// 可以使用小括号改变运算的优先级 
System.out.println(1 + 2 + "ssss" + (3 + 4)); // 输出：3ssss7

4.7.8 三元运算符

三元运算符语法格式：

关系表达式 ? 表达式1 : 表达式2;

解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

int a = 10;
int b = 20;
int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

4.8 流程控制语句

​ 顺序结构​ 分支结构(if, switch)​ 循环结构(for, while, do…while) 4.8.1 顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

4.8.2 分支结构(if, switch) 1. if语句：

格式：
if (条件表达式1) {
语句体1;
} else if (条件表达式2) {
语句体2;
} else if (条件表达式3) {
语句体3;
}
. . .
else {
语句体n+1;
}

public class IfDemo {
	public static void main(String[] args) {
		System.out.println("开始");	
		//定义两个变量
		int a = 10;
		int b = 20;	
		//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
		if(a == b) {
			System.out.println("a等于b");
		}		
		//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
		int c = 10;
		if(a == c) {
			System.out.println("a等于c");
		}		
		System.out.println("结束");
	}
}

2. switch语句：

switch…case结构：多条路
优点：效率高、结构清晰
缺点：只能对整数判断相等
break：跳出switch

注意：如果switch中得case，没有对应break的话，则会出现case穿透的现象。

格式：
switch (表达式) {
case 1:
语句体1;
break;
case 2:
语句体2;
break;
…
default:
语句体n+1;
break;
}

public class SwitchDemo {
    public static void main(String[] args) {
        //键盘录入月份数据，使用变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个月份：");
        int month = sc.nextInt();
        //case穿透
        switch(month) {
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("你输入的月份有误");
        }
    }
}

4.8.3 循环结构(for, while, do…while) 1. for循环语句

for循环格式：
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}
示例1：

//输出3次Hello World
for (int i = 0; i < 3; i++) {
System.out.println("Hello World");
}

示例2：

//需求：求1-5之间的数据和，并把求和结果在控制台输出  
public class ForTest02 {
    public static void main(String[] args) {
		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
		int sum = 0;
		//从1开始到5结束的数据，使用循环结构完成
		for(int i=1; i<=5; i++) {
			//将反复进行的事情写入循环结构内部
             // 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
			sum += i;
			
		}
		//当循环执行完毕时，将最终数据打印出来
		System.out.println("1-5之间的数据和是：" + sum);
    }
}

示例3：

//需求：求1-100之间的偶数和，并把求和结果在控制台输出
public class ForTest03 {
    public static void main(String[] args) {
		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
		int sum = 0;
		//对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
		for(int i=1; i<=100; i++) {
			//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
			if(i%2 == 0) {
				sum += i;
			}
		}
		//当循环执行完毕时，将最终数据打印出来
		System.out.println("1-100之间的偶数和是：" + sum);
    }
}

示例4：

public class ForTest04 {
    public static void main(String[] args) {
		//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
		for(int i=100; i<1000; i++) {
			//在计算之前获取三位数中每个位上的值
			int ge = i%10;
			int shi = i/10%10;
			int bai = i/10/10%10;
			
			//判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等
			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
				//输出满足条件的数字就是水仙花数
				System.out.println(i);
			}
		}
    }
}

2. while循环语句

while循环完整格式：

初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}
示例1：

public class WhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
		//for循环实现
		for(int i=1; i<=5; i++) {
			System.out.println("HelloWorld");
		}
		System.out.println("--------");
		//while循环实现
		int j = 1;
		while(j<=5) {
			System.out.println("HelloWorld");
			j++;
		}
    }
}

示例2：

//猜字小游戏
public class Guessing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
        System.out.println(num); //作弊

        //300(大),200(小),250(对)
        System.out.println("猜吧!");
        int guess = scan.nextInt(); //1.
        while(guess!=num){ //2.
            if(guess>num){
                System.out.println("太大了");
            }else{
                System.out.println("太小了");
            }
            System.out.println("猜吧!");
            guess = scan.nextInt(); //3.
        }
        System.out.println("恭喜你猜对了!");
    }
}

3. do…while循环语句

格式：
初始化语句;
do {
循环体语句;
条件控制语句;
}while(条件判断语句);

public class DoWhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
		//for循环实现
		for(int i=1; i<=5; i++) {
			System.out.println("HelloWorld");
		}
		System.out.println("--------");
		//do...while循环实现
		int j = 1;
		do {
			System.out.println("HelloWorld");
			j++;
		}while(j<=5);
    }
}

4. 三种循环的区别

三种循环的区别

for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断） for循环和while的区别

条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用 死循环（无限循环）的三种格式

for( ; ; ){}while(true){}do {} while(true);

5. 跳转控制语句

跳转控制语句（break）

跳出循环，结束循环 跳转控制语句（continue）

跳过本次循环，继续下次循环

for(int i=1;i<=9;i++){
    if(i==4){ //在某种特定条件下，提前结束循环
        break;
    }
    System.out.println(i+"*9="+i*9);
}

for(int i=1;i<=9;i++){
            if(i%3==0){
                continue; //跳过循环体中剩余语句而进入下一次循环
            }
            System.out.println(i+"*9="+i*9);
        }

注意： continue只能在循环中进行使用！

6. 循环嵌套

循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列执行过程：外层循环走一次，内层循环走所有次建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层break只能跳出当前一层循环

public static void main(String[] args) {
        //外循环控制小时的范围，内循环控制分钟的范围
        for (int hour = 0; hour < 24; hour++) {
            for (int minute = 0; minute < 60; minute++) {
                System.out.println(hour + "时" + minute + "分");
            }
            System.out.println("--------");
        }
    }

结论：
外循环执行一次，内循环执行一圈

5. 数组

数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致是一种数据类型(引用类型)相同数据类型元素的集合 5.1 数组定义格式 5.1.1 第一种方式

数据类型[] 数组名

int[] arr;        
double[] arr;      
char[] arr;

5.1.2 第二种方式

数据类型 数组名[]

int arr[];
double arr[];
char arr[];

5.2 数组动态初始化

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值。
动态初始化格式:
数据类型[] 数组名 = new 数据类型[数组长度];

int[] arr = new int[3];

5.3静态初始化格式

完整格式：

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};

简化版格式：

数据类型[] 数组名 = {元素1,元素2,...};

5.4 访问数组元素格式

数组名[索引];

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];

        //输出数组名
        System.out.println(arr); //[I@880ec60

        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

5.5 索引越界异常

出现原因

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[3]);
    }
}

数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。

程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

解决方案：将错误的索引修改为正确的索引范围即可！

5.6 空指针异常

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];

        //把null赋值给数组
        arr = null;
        System.out.println(arr[0]);
    }
}

arr = null 这行代码，意味着变量arr将不会再保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

解决方案：给数组一个真正的堆内存空间引用即可！

5.7 数组遍历

数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

public class ArrayTest01 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33, 44, 55};

        //使用通用的遍历格式
        for(int x = 0; x < arr.length; x++) {
            System.out.println(arr[x]);
        }
    }
}

5.8 数组最值

最大值获取：从数组的所有元素中找出最大值，最小值同理。

public class ArrayTest02 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {12, 45, 98, 73, 60};
        //定义一个变量，用于保存最大值
        //取数组中第一个数据作为变量的初始值
        int max = arr[0];
        //与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
        for(int x=1; x max) {
                max = arr[x];
            }
        }
        //循环结束后打印变量的值
        System.out.println("max:" + max);
    }
}

6 方法

方法：函数、过程

封装一段特定的业务逻辑功能尽可能的独立，一个方法只干一件事方法可以被反复多次调用减少代码重复，有利于代码复用，有利于代码维护

6.1 定义方法：

格式：
​ 修饰词 返回值类型 方法名(参数列表) {
​ 方法体--------------具体的业务逻辑功能实现
​ }

//无参无返回值
public static void say(){
    System.out.println("大家好，我叫WKJ，今年38岁了");
}
//有参无返回值
public static void sayHi(String name){ //---------形参
    System.out.println("大家好，我叫"+name+"，今年38岁了");
}
//有参无返回值
public static void sayHello(String name,int age){
    if(age>=35){ //在某种特定条件下，提前结束方法
        return; //结束方法
    }
    System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
}

//无参有返回值
public static double getNum(){
    //在有返回值的方法中:
    //--必须得通过return来返回一个值，并且这个值的类型必须与返回值类型匹配
    //return "abc"; //编译错误，返回的值必须与返回值类型匹配
    return 8.88; //1)结束方法的执行  2)返回一个结果给调用方
}

//有参有返回值
public static int plus(int num1,int num2){
    int num = num1+num2;
    return num; //返回的是num里面的那个数
    //return num1+num2; //返回的是num1与num2的和
}

//无参有返回值
 public static int[] testArray(){
     int[] arr = new int[10];
     for(int i=0;i 
6.2 调用方法： 
无返回值：方法名(有参传参);有返回值：数据类型 变量 = 方法名(有参传参);
 
//say();

//sayHi(); //编译错误，有参则必须传参
//sayHi(250); //编译错误，参数类型必须匹配
sayHi("zhangsan"); //String name="zhangsan" //-------实参
sayHi("lisi"); //String name="lisi" //---------------实参
sayHi("wangwu"); //String name="wangwu" //-----------实参

sayHello("zhangsan",25); //实参
sayHello("WKJ",38); //实参

double a = getNum(); //getNum()的值就是8.88
System.out.println(a); //8.88----模拟对返回值的后续操作

int b = plus(5,6);
System.out.println(b); //11----模拟对返回值的后续操作

int m=5,n=6;
int c = plus(m,n); //传递的是m和n里面的那个数
System.out.println(c); //11----模拟对返回值的后续操作

int[] d = testArray();
System.out.println(d.length); //10---模拟对返回值的后续操作
for(int i=0;i 
6.3 return： 
 
return 值;
 1)结束方法的执行
 2)返回结果给调用方
 ​ ----------用在有返回值方法中
  
return; 结束方法的执行
 -----------------用在无返回值的方法中
 
 
6.4 形参和实参 
形参：方法定义中的参数
 
​ 等同于变量定义格式，例如：int number
 
实参：方法调用中的参数
 
​ 等同于使用变量或常量，例如： 10 number
 
6.5 方法重载 
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
 
 
 
多个方法在同一个类中多个方法具有相同的方法名多个方法的参数不相同，类型不同或者数量不同 
 
public class MethodTest {
    public static void main(String[] args) {
        //调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }

    //int
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    //byte
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    //short
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    //long
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }

}
 
7 类和对象 
类：对现实事物的一种描述
 
对象：对象是某类事物的一个个体
 
 
 
类中可以包含：
 对象的属性/特征-----------------------在类中通过成员变量来体现
 对象的行为/动作-----------------------在类中通过成员方法来体现
 一个类可以创建多个对象
 
 
类和对象的关系
 
类：类是对现实生活中一类具有共同属性和行为的事物的抽象对象：是能够看得到摸的着的真实存在的实体简单理解：类是对事物的一种描述，对象则为具体存在的事物 
public class 类名 {
	// 成员变量
	变量1的数据类型 变量1；
	变量2的数据类型 变量2;
	…
	// 成员方法
	方法1;
	方法2;	
}
 
7.1 对象的使用 
创建对象的格式： 
  
类名 对象名 = new 类名(); 调用成员的格式： 
  
对象名.成员变量对象名.成员方法();  
public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}
 
学生对象练习：
 
//成员变量
    String name;
    int age;

    //成员方法
    public void study() {
        System.out.println("好好学习，天天向上");
    }

    public void doHomework() {
        System.out.println("键盘敲烂，月薪过万");
    }
}

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用对象
        System.out.println(s.name + "," + s.age);

        s.name = "林青霞";
        s.age = 30;

        System.out.println(s.name + "," + s.age);

        s.study();
        s.doHomework();
    }
}
 
7.2 成员变量和局部变量的区别 
类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）内存中位置不同：成员变量（堆内存）局部变量（栈内存）生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用） 
7.3 封装思想 
 
封装概述
 
是面向对象三大特征之一（封装，继承，多态）
 
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
  
封装原则
 
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
 
成员变量private，提供对应的getXxx()/setXxx()方法
  
封装好处
 
通过方法来控制成员变量的操作，提高了代码的安全性
 
把代码用方法进行封装，提高了代码的复用性
 
 
7.4 构造方法 
构造方法是一种特殊的方法
 
 
作用：创建对象 Student stu = new Student();
  
格式：
 
public class 类名{
 
​ 修饰符 类名( 参数 ) {
 
​ }
 
}
  
功能：主要是完成对象数据的初始化
  
class Student {
    private String name;
    private int age;

    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
    }
}
 
7.5 构造方法的注意事项 
构造方法的创建 
如果没有定义构造方法，系统将给出一个默认的无参数构造方法
 如果定义了构造方法，系统将不再提供默认的构造方法
 
构造方法的重载 
如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
 
推荐的使用方式 
无论是否使用，都手工书写无参数构造方法
 
重要功能！ 
可以使用带参构造，为成员变量进行初始化
 
class Student {
    private String name;
    private int age;

    public Student() {}

    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();

        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();

        //public Student(int age)
        Student s3 = new Student(30);
        s3.show();

        //public Student(String name,int age)
        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}
 
7.6 private关键字 
private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
 
被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
 
提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰 
class Student {
    //成员变量
    String name;
    private int age;

    //提供get/set方法
    public void setAge(int a) {
        if(a<0 || a>120) {
            System.out.println("你给的年龄有误");
        } else {
            age = a;
        }
    }

    public int getAge() {
        return age;
    }

    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //给成员变量赋值
        s.name = "林青霞";
        s.setAge(30);
        //调用show方法
        s.show();
    }
}
 
7.7 this关键字 
this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象。
 this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
 
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量 
public class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
 
8 继承 
8.1 继承概念 
继承可以理解为就是让两个类（事物）产生从属关系，有了从属关系子类就肯定会具有父类的特征（父类中的非私有成员），这样我们用类去描述一些事物的时候就可以更方便
 
 
 
超类/父类：共有的属性和行为
 派生类/子类：特有的属性和行为
 
 
实现继承的格式 继承通过extends实现
 格式：
 
class 子类 extends 父类 { }
 
public class Fu {     
		public void show() {         
			System.out.println("show方法被调用");     
		} 
		
	} 
	public class Zi extends Fu {     
		public void method() {         
			System.out.println("method方法被调用");     
		} 
	} 
	
	public class Demo {     
		public static void main(String[] args) {
			//创建对象，调用方法         
			Fu f = new Fu();         
				f.show();          
				Zi z = new Zi();         
				z.method();         
				z.show();     
		} 

	}
 
8.2 继承特点 
继承鼓励类的重用
继承可以多层继承
Java中类只支持单继承，不支持多继承(接口支持多继承)
父类中private，default修饰的不能被继承
构造方法不能被继承，只能调用
具有传递性
 
8.3 继承的作用 
 
 
继承的出现减少了代码冗余，提高了代码的复用性。继承的出现，更有利于功能的扩展。继承的出现让类与类之间产生了关系，提供了多态的前提。 
 
8.4 继承带来的好处与弊端 
继承的好处
继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

继承好处 提高了代码的复用性(多个类相同的成员可以放到同一个类中) 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

继承弊端
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削 弱了子类的独立性,违背了`高内聚，低耦合`原则

继承的应用场景： 使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承 is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，
那人就是父类，学生和老师就是子类
 
8.5 super关键字 
super：指代当前对象的超类对象
 super的用法:
 super.成员变量名---------------------访问超类的成员变量
 super.方法名()-------------------------调用超类的方法
 super()-----------------------------------调用超类的构造方法
 
 //super的演示
 public class SuperDemo {
     public static void main(String[] args) {
         Boo o = new Boo();
     }
 }
 class Coo{
     Coo(int a){
     }
 }
 class Doo extends Coo{
     Doo(){
         super(5); //调用超类的有参构造
     }
     
 }
 
 class Aoo{
     Aoo(){
         System.out.println("超类构造");
     }
 }
 class Boo extends Aoo{
     Boo(){
         //super(); //默认的，调用超类的无参构造
         System.out.println("派生类构造");
     }
 }
 
8.6 this&super关键字 
this：代表本类对象的引用 
super：代表父类存储空间的标识(可以理解为父类对象引用) 

this和super的使用分别
成员变量： 
this.成员变量    -   访问本类成员变量
super.成员变量 -   访问父类成员变量

成员方法： 
this.成员方法  - 访问本类成员方法
super.成员方法 - 访问父类成员方法

构造方法：
 this(…)  -  访问本类构造方法 
super(…)  -  访问父类构造方法
 
8.7 向上造型 
超类型的引用指向派生类的对象规定：能点出来什么，看引用的类型 
public class UploadDemo {
    public static void main(String[] args) {
        Aoo o1 = new Aoo();
        o1.a = 1;
        o1.show();
        //o1.b = 2;  //编译错误
        //o1.test(); //编译错误，超类不能访问派生类的

        Boo o2 = new Boo();
        o2.b = 1;
        o2.test();
        o2.a = 2;  //正确
        o2.show(); //正确，派生类可以访问超类的

        Aoo o3 = new Boo(); //向上造型
        o3.a = 1;
        o3.show();
        //o3.b = 2;  //编译错误
        //o3.test(); //编译错误，能点出来什么，看引用的类型
    }
}

class Aoo{
    int a;
    void show(){
    }
}
class Boo extends Aoo{
    int b;
    void test(){
    }
}
 
8.8 方法的重写 
1. 发生在父子类中，方法名相同，参数列表相同
2. 重写方法被调用时，看对象的类型-------这是规定，记住就行了
3. 重写遵循"两同两小一大"原则：-----------了解，一般都是一模一样的
		1. 两同：
			方法名相同
			参数列表相同
		2. 两小：
			1. 派生类方法的返回值类型小于或等于超类方法的
				1) void和基本类型时，必须相等
				2) 引用类型时，小于或等于
			2. 派生类方法抛出的异常小于或等于超类方法的
		3. 一大：
			派生类方法的访问权限大于或等于超类方法的
 
重写与重载的区别：-----------常见面试题
 
 
 
重写(override)：发生在父子类中，方法名相同，参数列表相同重载(overload)：发生在同一类中，方法名相同，参数列表不同 
 
9 多态 
同类型的对象，执行同一个行为，会表现出不同的行为特征。
 
9.1 常见形式 
父类类型 对象名称 = new 子类构造器;

接口   对象名称 = new 实现类构造器; 
 
9.2 多态中成员访问特点 
方法调用：编译看左边，运行看右边。

变量调用：编译看左边，运行也看左边。（**多态侧重行为多态**）
 
9.3 多态的前提 
要有继承或实现关系 要有方法的重写 要有父类引用指向子类对象
 
9.4 多态的优势 
在多态形式下，右边对象可以实现解耦合，便于扩展和维护。定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性与便利。
 
9.5 向上造型/自动类型转换： 
超类型的引用指向派生类的对象能点出来什么，看引用的类型能造型成为的数据类型有：超类+所实现的接口
 
9.6 强制类型转换 
成功的条件只有如下两种：
 
引用所指向的对象，就是该类型引用所指向的对象，实现了该接口或继承了该类
 
9.7 可能出现的异常 
强转时若不符合如上条件，则发生ClassCastException类型转换异常
 建议在强转之前先通过instanceof判断引用的对象是否是该类型
 
public class MultiTypeDemo {
    public static void main(String[] args) {
        Aoo o = new Boo(); //向上造型
        Boo o1 = (Boo)o; //引用o指向的对象就是Boo
        Inter o2 = (Inter)o; //引用o指向的对象实现了Inter接口
        //Coo o3 = (Coo)o; //运行时发生ClassCastException类型转换异常
        if(o instanceof Coo){ //false
            Coo o4 = (Coo)o;
        }else{
            System.out.println("o不是Coo类型");
        }
    }
}

interface Inter{
}
class Aoo{
}
class Boo extends Aoo implements Inter{
}
class Coo extends Aoo{
}
 
10 访问控制权限修饰符 
修饰符
同一个类中
同一个包中子类无关类
不同包的子类
不同包的无关类
private
√
默认
√
√
protected
√
√
√
public
√
√
√
√
 
 
说明：
 
 
类的访问权限只能是public或默认的类中成员的访问权限如上4种都可以 
 
package ooday05;
//访问控制修饰符的演示
public class Aoo {
    public int a;    //任何类
    protected int b; //本类、派生类、同包类
    int c;           //本类、同包类
    private int d;   //本类

    void show(){
        a = 1;
        b = 2;
        c = 3;
        d = 4;
    }
}
class Boo{ //--------------------演示private
    void show(){
        Aoo o = new Aoo();
        o.a = 1;
        o.b = 2;
        o.c = 3;
        //o.d = 4; //编译错误
    }
}

package ooday05_vis;
import ooday05.Aoo;
public class Coo { //----------------演示同包的
    void show(){
        Aoo o = new Aoo();
        o.a = 1;
        //o.b = 2; //编译错误
        //o.c = 3; //编译错误
        //o.d = 4; //编译错误
    }
}
class Doo extends Aoo{ //跨包继承----------演示protected
    void show(){
        a = 1;
        b = 2;
        //c = 3; //编译错误
        //d = 4; //编译错误
    }
}
 
11 static关键字 
11.1 static作用 
static是静态的意思，可以修饰成员变量和成员方法。static修饰成员变量表示该成员变量只在内存中只存储一份，可以被共享访问、修改。 
11.2 静态成员变量 
静态成员变量（有static修饰，属于类、加载一次，可以被共享访问）
 
访问格式：
 
类名.静态成员变量(推荐)对象.静态成员变量(不推荐)。 
public class StaticDemo {
    public static void main(String[] args) {
        Loo o1 = new Loo();
        o1.show();
        Loo o2 = new Loo();
        o2.show();
        Loo o3 = new Loo();
        o3.show();
        System.out.println(Loo.b); //常常通过类名点来访问
    }
}
//演示静态变量
class Loo{
    int a;
    static int b;
    Loo(){
        a++;
        b++;
    }
    void show(){
        System.out.println("a="+a+"，b="+b);
    }
}
 
11.3 静态成员方法 
静态成员方法（有static修饰，属于类），建议用类名访问，也可以用对象访问
 
访问格式：
 
类名.静态成员方法
 
访问特点：
 
静态成员方法只能访问静态成员
 
 
 
注意事项
 
 
静态方法中不能直接使用非静态的成员静态方法中不能使用this 
 
 
 
使用场景：
 
 
表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。如果该方法是以执行一个共用功能为目的，则可以申明成静态方法。 
 
public class StaticDemo {
    public static void main(String[] args) {
        Moo.test();
    }
}

//演示静态方法
class Moo{
    int a; //实例变量(对象点来访问)
    static int b; //静态变量(类名点来访问)

    void show(){ //有隐式this
        System.out.println(this.a);
        System.out.println(Moo.b);
    }
    static void test(){ //没有隐式this
        //静态方法中没有隐式this传递
        //没有this就意味着没有对象
        //而实例变量a必须通过对象点来访问
        //所以如下代码发生编译错误
        //System.out.println(a); //编译错误
        System.out.println(Moo.b);
    }
}

//演示静态方法在何时用
class Noo{
    int a; //对象的属性a

    //在show()中用到了对象的属性a，意味着show()方法与对象有关，所以不能设计为静态方法
    void show(){
        System.out.println(a);
    }
    //在plus()中没有用到对象的属性，意味着plus()方法与对象无关，所以可以设计为静态方法
    static int plus(int num1,int num2){
        int num = num1+num2;
        return num;
    }
}
 
11.4 静态代码块 
格式：static{}
 
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
 
使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。
 
作用：
 
如果要在启动系统时对数据进行初始化。建议使用静态代码块完成数据的初始化操作，代码优雅。
 
public class StaticDemo {
    public static void main(String[] args) {
        Poo o4 = new Poo();
        Poo o5 = new Poo();
    }
}

//演示静态块
class Poo{
    static{
        System.out.println("静态块");
    }
    Poo(){
        System.out.println("构造方法");
    }
}
 
12 final关键字 
fianl关键字的作用 final代表最终的意思，可以修饰成员方法，成员变量，类 final修饰类、方法、变量的效果
 
final修饰变量：表明该变量是一个常量，不能再次赋值final修饰方法：该方法不能被重写fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
 
 
 
注意：
 
 
final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。
 
 
package ooday05_vis;
//演示final修饰变量
class Eoo{
    final int a = 5;
    void test(){
        //a = 55; //编译错误，final的变量不能被改变
    }
}

//演示final修饰方法
class Foo{
    final void show(){}
}
class Goo extends Foo{
    //void show(){} //编译错误，final的方法不能被重写
}

//演示final修饰类
final class Hoo{}
//class Ioo extends Hoo{} //编译错误，final的类不能被继承
class Joo{}
final class Koo extends Joo{} //正确，不能当老爸，但能当儿子
 
12.1 static final常量 
必须声明同时初始化类名点来访问，不能被改变建议：常量名所有字母都大写，多个单词用_分隔编译器在编译时会将常量直接替换为具体的数，效率高何时用：数据永远不变，并且经常使用
 
public class StaticFinalDemo {
    public static void main(String[] args) {
        System.out.println(Aoo.PI); //常常通过类名点来访问
        //Aoo.PI = 3.1415926; //编译错误，常量不能被改变

        //1)加载Boo.class到方法区中
        //2)静态变量num一并存储到方法区中
        //3)到方法区中获取num的值并输出
        System.out.println(Boo.num);

        //编译器在编译时会将常量直接替换为具体的值，效率高
        //相当于System.out.println(5);
        System.out.println(Boo.COUNT);
    }
}

class Boo{
    public static int num = 5; //静态变量
    public static final int COUNT = 5; //常量
}

class Aoo{
    public static final double PI = 3.14159;
    //public static final int NUM; //编译错误，常量必须声明同时初始化
}
 
13 抽象类 
在Java中abstract是抽象的意思，如果一个类中的某个方法的具体实现不能确定，就可以申明成abstract修饰的抽象方法（不能写方法体了），这个类必须用abstract修饰，被称为抽象类。
 
 
 
一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
 
 
抽象类的意义：
 
 1. 封装共有的属性和行为---------------代码复用
 2. 为所有派生类提供统一的类型------向上造型
 3. 可以包含抽象方法，为所有派生类提供统一的入口(能点出来)，
 4. 派生类的行为不同，但入口是一致的，同时相当于定义了一个标准(强制重写)
 
抽象方法：
 
 
 
由abstract修饰只有方法的定义，没有具体的实现(连{}都没有) 
 
14 接口 
14.1 定义接口 
格式：
 
public interface 接口名{
    //定义抽象方法
    void method();
}
 
14.2 实现接口 
在要实现接口的类名后面加上implements 接口名。
 
public class 类名 implements 接口名{}
 
14.3 接口的特点 
是一种引用数据类型由interface定义只能包含常量和抽象方法接口不能被实例化(new对象)接口是需要被实现/继承的，实现类/派生类：----必须重写所有抽象方法一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现接口可以继承接口
 
//接口的演示
public class InterfaceDemo {
    public static void main(String[] args) {
        //Inter5 o1 = new Inter5(); //编译错误，接口不能被实例化
        Inter5 o2 = new Doo(); //向上造型(可以造型为它所实现的接口)
        Inter4 o3 = new Doo(); //向上造型
    }
}

//演示接口继承接口
interface Inter4{
    void show();
}
interface Inter5 extends Inter4{
    void test();
}
class Doo implements Inter5{
    public void test(){}
    public void show(){}
}

//演示接口多实现
interface Inter2{
    void show();
}
interface Inter3{
    void test();
}
abstract class Boo{
    abstract void say();
}
class Coo extends Boo implements Inter2,Inter3{
    public void show(){}
    public void test(){}
    public void say(){}
}

//演示接口的实现
interface Inter1{
    void show(); //访问权限默认是public
    void test();
}
class Aoo implements Inter1{
    public void show(){} //重写接口中的抽象方法，访问权限必须是public
    public void test(){}
}

//演示接口的语法
interface Inter{
    public static final int NUM = 5; //接口中成员的访问权限只能是public的
    public abstract void show();
    int COUNT = 6; //默认public static final
    void say(); //默认public abstract
    //int number; //编译错误，常量必须声明同时初始化
    //void test(){} //编译错误，抽象方法不能有方法体
}
 
14.4 接口的成员特点 
成员变量
  只能是常量   默认修饰符：public static final
  
构造方法
  没有，因为接口主要是扩展功能的，而没有具体存在
  
成员方法
  只能是抽象方法
  默认修饰符：public abstract
 
14.5 类和接口的关系 
类与类的关系
  继承关系，只能单继承，但是可以多层继承
  
类与接口的关系
  实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
  
接口与接口的关系
  继承关系，可以单继承，也可以多继承
 
14.6抽象类和接口的区别 
成员区别
抽象类
变量,常量；有构造方法；有抽象方法,也有非抽象方法
接口
常量；无构造方法，抽象方法

关系区别
类与类
继承，单继承
类与接口
实现，可以单实现，也可以多实现
接口与接口
继承，单继承，多继承

设计理念区别
抽象类
对类抽象，包括属性、行为
接口
对行为抽象，主要是行为
 
15 内部类 
15.1 成员内部类 
成员内部类：应用率低类中套类，外面的称为外部类，里面的称为内部类内部类通常只服务于外部类，对外不具备可见性内部类对象通常在外部类中创建内部类中可以直接访问外部类的成员(包括私有的)内部类中有个隐式的引用指向了创建它的外部类对象：外部类名.this----API时会用
 
public class InnerClassDemo {
    public static void main(String[] args) {
        Mama m = new Mama();
        //Baby b = new Baby(); //编译错误，内部类对外不具备可见性
    }
}

class Mama{ //外部类
    private String name;
    void create(){
        Baby b = new Baby(); //正确，内部类对象通常在外部类中创建
    }
    class Baby{ //内部类
        void showName(){
            System.out.println(name); //省略写法
            System.out.println(Mama.this.name); //完整写法
            //System.out.println(this.name); //编译错误，this指代当前Baby对象
        }
    }
}
 
15.2 匿名内部类 
匿名内部类本质是一个对象，它是某个（接口）的子类（实现类对象）
 
本质：是一个继承了该类或者实现了该接口的子类匿名对象
 
匿名内部类的特点
 
匿名内部类必须继承父类或实现接口匿名内部类只能有一个对象匿名内部类对象只能使用多态形式引用
 
面试题：问：内部类有独立的.class吗？ 答：有
 
interface Inter{     
			void method(); 
		}   
		class Test{     
			public static void main(String[] args){         
				new Inter(){             
					@Override             
						public void method(){                 
						System.out.println("我是匿名内部类");             
					}         
				}.method(); // 直接调用方法       
			} 
		}
 
16 内存分配 
16.1 内存概述 
​ 内存是计算机中的重要原件，临时存储区域，作用是运行程序。
 
​ 我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。
 
​ 必须放进内存中才能运行，运行完毕后会清空内存。
 
​ Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。
 
16.2 java中的内存分配 
区域名称
作用
寄存器
给CPU使用，和我们开发无关。
本地方法栈
JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区
存储可以运行的class文件。
堆内存
存储对象或者数组，new来创建的，都存储在堆内存。
方法栈
方法运行时使用的内存，比如main方法运行，进入方法栈中执行。
16.3 内存管理 
由JVM来管理的
 
堆：
 
存储new出来的对象(包括实例变量)垃圾：没有任何引用所指向的对象
 垃圾回收器(GC)不定时到内存中清扫垃圾，回收过程是透明的(看不到的)，不一定一发现垃圾就立刻回收，通过调用System.gc()可以建议JVM尽快调度GC回收实例变量的生命周期： ​ 创建(new)对象时存储在堆中，对象被回收时一并被回收内存泄漏：不再使用的对象没有被及时的回收，严重的泄漏会导致系统的崩溃
 
建议：不再使用的对象应及时将引用设置为null
 
栈：
 
存储正在调用的方法中的局部变量(包括方法的参数)调用方法时，会在栈中为该方法分配一块对应的栈帧，栈帧中存储局部变量(包括方法的参数)，方法调用结束时，栈帧被自动清除，局部变量一并被清除局部变量的生命周期： ​调用方法时存储在栈中，方法调用结束时与栈帧一并被清除
 
方法区：
 
存储.class字节码文件(包括静态变量、所有方法)方法只有一份，通过this来区分具体的访问对象
 
17 面向对象三大特征 
封装：
 
类：封装的是对象的属性和行为方法：封装的是具体的业务逻辑功能实现访问控制修饰符：封装的是具体的访问权限，以保护数据的安全
 
继承：
 
作用：代码复用超类：所有派生类所共有的属性和行为
 接口：部分派生类所共有的属性和行为
 派生类：派生类所特有的属性和行为单一继承、多接口实现，具有传递性
 
多态：
 
行为多态：所有抽象方法都是多态的(通过方法的重写实现的)
 对象多态：所有对象都是多态的(通过向上造型来实现)向上造型、强制类型转换、instanceof判断
 
18 String类 
18.1 概述 
java.lang.String使用final修饰，不能被继承java中的String在内存中采用Unicode编码方式，任何一个字符占用两个字节的编码字符串底层封装的是一个字符数组字符串一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值------不变对象
 
18.2 String常用构造方法： 
方法名
说明
public String()
创建一个空白字符串对象，不含有任何内容
public String(char[] chs)
创建一个空白字符串对象，不含有任何内容
public String(byte[] bys)
创建一个空白字符串对象，不含有任何内容
String s=“abc”
创建一个空白字符串对象，不含有任何内容
 
方法名
说明
public boolean equals(Object anObject)
比较字符串的内容，严格区分大小写（用户名和密码）
public char charAt(int index)
返回指定索引处的char值
public int length()
返回此字符串的长度


String s1 = "123abc"; //堆中创建一个123abc对象，常量池中存储这个对象的引用
//编译器在编译时，若发现是两个字面量连接，
//则直接运算好并将结果保存起来，如下代码相当于String s2="123abc";
String s2 = "123"+"abc"; //复用常量池中的123abc对象
System.out.println(s1==s2); //true

String s3 = "123";
//因为s3不是字面量，所以并不会直接运算结果
String s4 = s3+"abc"; //会在堆中创建新的123abc对象，而不会重用常量池中的对象
System.out.println(s1==s4); //false
 
String面试题
 
String s = new String("hello");
String s1 = "hello";
System.out.println("s:"+s);   //hello
System.out.println("s1:"+s1); //hello
System.out.println(s==s1); //false，==比较的是地址是否相同

//字符串实际开发中比较相等一般都是比较字符串的内容
//因此我们需要使用equals()方法来比较两个字符串的内容
System.out.println(s.equals(s1)); //equals()比较的是内容是否相同
 
18.3 String常用方法 
length()：获取字符串的长度(字符个数)
 
String str = "我爱Java!";
 int len = str.length(); //获取str的长度
 System.out.println(len); //7
 
trim()：去除当前字符串两边的空白字符
 
String str = "  hello world            ";
 System.out.println(str); //  hello world
 str = str.trim(); //去除当前字符串两边的空白字符
 System.out.println(str); //hello world
 
toUpperCase()和toLowerCase()：将当前字符串中的英文部分转为全大写/全小写
 
 String str = "我爱Java!";
 String upper = str.toUpperCase(); //将str中英文部分转为全大写
 System.out.println(upper); //我爱JAVA!
 
 String lower = str.toLowerCase(); //将str中英文部分转为全小写
 System.out.println(lower); //我爱java!
 
startsWith(String str)和endsWith(String str)：判断当前字符串是否是以给定的字符串开始/结尾的
 
String str = "thinking in java";
 boolean starts = str.startsWith("think"); //判断str是否是以think开头的
 System.out.println("starts:"+starts); //true

 boolean ends = str.endsWith(".png"); //判断str是否是以.png结尾的
 System.out.println("ends:"+ends); //false
 
charAt()：返回当前字符串指定位置上的字符
 
 //            0123456789012345
 String str = "thinking in java";
 char c = str.charAt(9); //获取位置9所对应的字符
 System.out.println(c); //i
 
indexOf()和lastIndexOf()：检索给定字符串在当前字符串中的开始位置
 
//                      111111
//            0123456789012345
String str = "thinking in java";
int index = str.indexOf("in"); //检索in在字符串str中的开始位置
System.out.println(index); //2

index = str.indexOf("in",3); //从下标为3的位置开始找in第一次出现的位置
System.out.println(index); //5

index = str.indexOf("IN"); //当前字符串不包含IN，所以返回-1
System.out.println(index); //-1

index = str.lastIndexOf("in"); //找in最后一次出现的位置
System.out.println(index); //9
 
substring()：截取当前字符串中指定范围内的字符串
 
 //                      1
//            01234567890
String str = "www.tedu.cn";
String name = str.substring(4,8); //截到下标4到7范围的字符串
System.out.println(name); //tedu

name = str.substring(4); //从下标4开始一直截到末尾
System.out.println(name); //tedu.cn
 
String的静态方法valueOf()：将其它数据类型转换为String
 
int a = 123;
String s1 = String.valueOf(a); //将int型变量a转换为String类型并赋值给s1
System.out.println(s1); //123---字符串类型

double d = 123.456;
String s2 = String.valueOf(d); //将double型变量d转换为String类型并赋值给s2
System.out.println(s2); //123.456----字符串类型

String s3 = a+""; //任何内容和字符串连接的结果都是字符串，效率低(下节课讲)
System.out.println(s3); //123---字符串类型
 
18.4 StringBuilder类 
StringBuilder构造器
 
名称
说明
public StringBuilder()
创建一个空白的可变的字符串对象，不包含任何内容
public StringBuilder(String str)
创建一个指定字符串内容的可变字符串对象
常用方法：
 
名称
说明
public StringBuilder append(任意类型)
添加数据并返回StringBuilder对象本身
public StringBuilder reverse()
将对象的内容反转
public int length()
返回对象内容长度
public String toString()
通过toString()就可以实现把StringBuilder转换为String
replace()
替换部分内容
delete()
删除部分内容
insert()
插入内容
String str = "好好学习java";
//复制str中的内容到builder中-----好好学习java
StringBuilder builder = new StringBuilder(str);

//append():追加内容
builder.append("，为了找个好工作!");
System.out.println(builder); //好好学习java，为了找个好工作!

//replace():替换部分内容
builder.replace(9,16,"就是为了改变世界"); //替换下标9到15的
System.out.println(builder); //好好学习java，就是为了改变世界!

//delete():删除部分内容
builder.delete(0,8); //删除下标0到7的
System.out.println(builder); //，就是为了改变世界!

//insert():插入操作
builder.insert(0,"活着"); //从下标0的位置插入
System.out.println(builder); //活着，就是为了改变世界!

//reverse():翻转
builder.reverse(); //翻转内容
System.out.println(builder); //!界世变改了为是就，着活
 
import java.util.ArrayList;
import java.util.List;

public class ArrayList01 {


    public static void main(String[] args) {

        StringBuilder sb=new StringBuilder("hello");
        System.out.println(sb);//hellow
        StringBuilder sb1= sb.append("world");
        System.out.println(sb1==sb);//true append返回对象本身
        sb.reverse();//反转
        System.out.println(sb);//dlrowwolleh
    }

}
 
 
 
补充：
 StringBuilder和StringBuffer：
 
 
StringBuffer：是线程安全的，同步处理的，性能稍慢StringBuilder：非线程安全的，并发处理的，性能稍快 
 
18.4 常量池 
java对字符串有一个优化措施：字符串常量池(堆中)java推荐我们使用字面量/直接量的方式来创建字符串，并且会缓存所有以字面量形式创建的字符串对象到常量池中，当使用相同字面量再创建对象时将复用常量池中的对象以减少内存开销，从而避免内存中堆积大量内容相同的字符串对象
 
19 正则表达式 
正则表达式是用来描述字符串内容格式，使用它通常用来匹配一个字符串的内容是否符合要求
 
正则表达式的语法：
 
[]:表示一个字符,该字符可以是[]中指定的内容
例如:
[abc]:这个字符可以是a或b或c
[a-z]:表示任意一个小写字母
[a-zA-Z]:表示任意一个字母
[a-zA-Z0-9_]:表示任意一个数字字母下划线
[^abc]:该字符只要不是a或b或c

预定义字符:
.:表示任意一个字符,没有范围限制
d:表示任意一个数字,等同于[0-9]
w:表示任意一个单词字符,等同于[a-zA-Z0-9_]
s:表示任意一个空白字符
D:表示不是数字
W:不是单词字符
S:不是空白字符

量词:
?:表示前面的内容出现0-1次
  例如: [abc]? 可以匹配:a 或 b 或 c 或什么也不写
+:表示前面的内容最少出现1次
  例如: [abc]+ 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcbabcbabbabab....
        但是不能匹配:什么都不写 或 abcfdfsbbaqbb34bbwer...
*:表示前面的内容出现任意次(0-多次)---匹配内容与+一致，只是可以一次都不写
  例如: [abc]* 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcbabcbabbabab....或什么也不写
        但是不能匹配:abcfdfsbbaqbb34bbwer...
{n}:表示前面的内容出现n次
  例如: [abc]{3} 可以匹配:aaa 或 bbb 或 aab 或abc 或bbc
        但是不能匹配: aaaa 或 aad
{n,m}:表示前面的内容出现最少n次最多m次
  例如: [abc]{3,5} 可以匹配:aaa 或  abcab 或者 abcc
        但是不能匹配:aaaaaa 或 aabbd
{n,}:表示前面的内容出现n次以上(含n次)
  例如: [abc]{3,} 可以匹配:aaa 或 aaaaa.... 或 abcbabbcbabcbabcba....
        但是不能匹配:aa 或 abbdaw...
()用于分组,是将括号内的内容看做是一个整体
  例如: (abc){3} 表示abc整体出现3次. 可以匹配abcabcabc
        但是不能匹配aaa 或abcabc
        (abc|def){3}表示abc或def整体出现3次.
        可以匹配: abcabcabc 或 defdefdef 或 abcdefabc
        但是不能匹配abcdef 或abcdfbdef
 
String支持与正则表达式相关的方法 
方法1: matches()：使用给定的正则表达式验证当前字符串的格式是否符合要求
 
String email = "wangkj@tedu.cn";
String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\.[a-zA-Z]+)+";
boolean match = email.matches(regex);
if(match){
   System.out.println("是正确的邮箱");
}else{
   System.out.println("不是正确的邮箱");
}
 
方法2: split()：将当前字符串按照满足正则表达式的部分进行拆分
 
String line = "abc123def456ghi";
String[] data = line.split("[0-9]+"); //按数字拆分
System.out.println(Arrays.toString(data)); //将data数组按照字符串的格式输出

line = "123,456,789,482";
data = line.split(","); //按逗号拆分
System.out.println(Arrays.toString(data));

line = "123.456.789.482";   //练习+下课--------11:35继续
data = line.split("\."); //按点拆分
System.out.println(Arrays.toString(data));

//最开始就是可拆分项(.)，那么数组中的第1个元素为一个空字符串------""
//如果连续两个(两个以上)可拆分项，它们中间也会拆出一个空字符串-----""
//如果末尾连续多个可拆分项，那么拆出的空字符串被忽略
line = ".123.456..789.482.......";
data = line.split("\.");
System.out.println(Arrays.toString(data));
 
方法3: replaceAll()：将当前字符串中满足正则表达式的部分替换为给定的字符串
 
String line = "abc123def456ghi";
line = line.replaceAll("[0-9]+","#NUMBER#"); //将数字部分替换为#NUMBER#
System.out.println(line);
 
20 Object类 
20.1 Object类的作用 
是所有类的鼻祖，所有类都直接或间接继承了Object，万物皆对象，为了多态 
20.2 Object类的常用方法 
方法名称
类型
描述
public Object()
构造
构造器
public boolean equals(Object obj)
普通
对象比较
public String toString()
普通
对象打印时调用
Object的oString方法存在的意义:
 
 父类toString()方法存在的意义就是为了被子类重写，以便返回对象的内容信息，而不是地址信息
 
Object的oString方法作用：
 
 
 
让子类重写，以便返回子类对象的内容。
 
 
Object的equals方法存在的意义：
 
父类equals方法存在的意义就是为了被子类重写，以便子类自己来定制比较规则。
 
Object的equals方法作用：
 
默认是与另一个对象比较地址是否一样让子类重写，以便比较2个子类对象的内容是否相同
 
import java.util.Objects;

public class Point {
    private int x;
    private int y;

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }
    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
}

public class ObjectDemo {
    public static void main(String[] args) {
        //演示重写toString()
        Point p = new Point(1,2);
        //输出引用对象时默认调用toString()
        //相当于System.out.println(p.toString());
        System.out.println(p);

        //字符串连接时将默认调用对象的toString()
        //相当于String str = "这是个点:"+p.toString();
        String str = "这是个点:"+p;
        System.out.println(str);

        //演示重写equals()
        //Object类另一个常常被派生类重写的方法:equals()
        Point p1 = new Point(1,2);
        Point p2 = new Point(1,2);

        System.out.println(p1==p2); //false,==比较的地址
        System.out.println(p1.equals(p2)); //true，因为重写equals()中比较的是x和y
    }
}
 
20.3 ==操作符与equals方法 
面试题
1. ==
基本类型比较值:只要两个变量的值相等，即为true。

引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true

用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错

2. equals
所有类都继承了Object，也就获得了equals()方法。还可以重写
只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象

特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；（原因：在这些类中重写了Object类的equals()方法。）
 
21 包装类 
21.1 包装类的作用 
Java为了实现一切皆对象，为8种基本类型提供了对应的引用类型。后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型。java定义了8个包装类，目的是为了解决基本类型不能直接参与面向对象开发的问题，使得基本类型可以通过包装类的实例以对象的方式存在
 
自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量。
 
自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量。
 
基本数据类型
引用数据类型
byte
Byte
short
Short
int
Integer
long
Long
char
Character
float
Float
double
Double
boolean
Boolean
//演示自动拆装箱
//触发了自动装箱特性
Integer i1 = 5; //会被编译为: Integer i1 = Integer.valueOf(5);
//触发了自动拆箱特性
int ii = i1; //会被编译为: int ii = i1.intValue();

//演示包装类的实际操作:
//1)可以通过包装类来得到基本类型的取值范围:
int max = Integer.MAX_VALUE; //获取int的最大值
int min = Integer.MIN_VALUE; //获取int的最小值
System.out.println("int的最大值为:"+max);
System.out.println("int的最小值为:"+min);

long lMax = Long.MAX_VALUE; //获取long的最大值
long lMin = Long.MIN_VALUE; //获取long的最小值
System.out.println("long的最大值为:"+lMax);
System.out.println("long的最小值为:"+lMin);

//2)包装类可以将字符串转换为对应的基本类型
//  前提是该字符串正确表达了基本类型的值
//  若不能正确表达，则发生NumberFormatException数字转换异常
String str = "123";
int num = Integer.parseInt(str); //将字符串str转换为int类型
System.out.println(num); //123

str = "123.456";
double dou = Double.parseDouble(str); //将字符串str转换为double类型
System.out.println(dou); //123.456
 
21.2 包装类的特有功能 
可以把基本类型的数据转换成字符串类型(用处不大)
 
//1)可以把基本类型的数据转换成字符串类型
public class Test1 {
    public static void main(String[] args) {
         int a=1;
        double b=2.0;
        System.out.println(Integer.toString(a));
        System.out.println(Double.toString(b));
    }
}
 
可以把字符串类型的数值转换成真实的数据类型（真的很有用）
 
//2)包装类可以将字符串转换为对应的基本类型
//  前提是该字符串正确表达了基本类型的值
//  若不能正确表达，则发生NumberFormatException数字转换异常
String str = "123";
int num = Integer.parseInt(str); //将字符串str转换为int类型
System.out.println(num); //123

str = "123.456";
double dou = Double.parseDouble(str); //将字符串str转换为double类型
System.out.println(dou); //123.456