Java基础学习
1、Java语言概述
Java之父：詹姆斯·高斯林
Java百度百科：Java是一门
Java具有简单性、面向对象、
1.2、认识Linux操作系统
Linux起源于1991年，1995年随着互联⽹的发展⽽流⾏开来；它是⼀个开源的操作系统，是⼀个类Unix操作系统；⽬前，Linux是主流的服务器操作系统，⼴泛应⽤于互联⽹、云计算、智能⼿机（Android）等领域；由于Java主要⽤于服务器端的开发，因此Java应用的部署环境很多为Linux。
2、计算机基础知识
2.1、什么是二进制
计算机中的数据不同于人们生活中的数据，人们生活采用十进制数，而计算机中全部采用⼆进制数表示，它只包含 0、1两个数，逢⼆进一1+1=10。每⼀个0或者每⼀个1，叫做⼀个bit(比特)。
十进制数据转成二进制数据：使用十进制数除以2获得余数
如：
二进制数据转成十进制数据：使用8421编码
如：10001101转为十进制数据
1 0 0 0 1 1 0 1
等于1×20 + 1×22 + 1×23 + 1×27 = 1 + 4 + 8 + 128 = 141
2.2、字节的概念
字节是我们常见的计算机中最小存储单元。计算机存储任何的数据，都是以字节的形式存储，右键点击文件属性， 我们可以查看文件的字节大小。
8个bit（⼆进制位）0000-0000表示为1个字节，写成1 byte或者1 B。
-
8 bit = 1 B
-
1024 B =1 KB
-
1024 KB =1 MB
-
1024 MB =1 GB
-
1024 GB = 1 TB
-
1024 TB = 1 PB
-
1024 PB = 1 EB
2.3、原反补码
符号位：0表示正数，1表示负数。
补码：正数与原码相同，负数的符号位不变，其他位取反并加上1
反码：正数与原码相同，负数的符号位不变，其他位取反
原码：第一位为符号位，其他的为数字本身
-1:
原码：1 000 0001
反码：1 111 1110
补码：1 111 1111
-3:
原码：1 000 0011
反码：1 111 1100
补码：1 111 1101
1字节可以表示的最小值
补码：1 000 0000
反码：1 111 1111（借一位）
原码：1 1 000 0000（还一位）–> -128
3、Java语言开发环境搭建
3.1、JVM、JRE、JDK
-
JVM (Java Virtual Machine)：Java虚拟机，简称 JVM，是运行所有Java程序的假想计算机，是Java程序的运行环境，是Java 最具吸引力的特性之⼀。我们编写的Java代码，都运行在JVM 之上。
-
JDK (Java Development Kit)：是 Java 程序开发工具包，包含 JRE 和开发人员使用的工具。
-
JRE (Java Runtime Environment)：是 Java 程序的运行时环境，包含 JVM 和运行时所需要的核心类库 。
-
跨平台：任何软件的运行，都必须要运行在操作系统之上，而我们用Java编写的软件可以运行在任何的操作系统上，这个特性称为 Java 语言的跨平台特性。该特性是由 JVM 实现的，我们编写的程序运行在JVM上，而JVM 运行在操作系统上。
-
程序员编写的 Java 源文件(.java)⾸先要经过编译，生成所谓字节码文件(.class)，然后运行在JVM上
我们想要运行⼀个已有的 Java 程序，那么只需安装 JRE 即可。
但如果我们想要开发⼀个全新的 Java 程序，那么必须安装 JDK 。
javac命令将java文件（即源文件）编译成class文件（即字节码文件），java命令执行class文件（即字节码文件），其底层会动态的调用JVM。JVM将字节码文件一行一行的解释为当前操作系统可执行的文件，因此java也可以称之为“解释型”语言。实现一次编译到处运行。
3.2、JDK的安装
网上有许多教程，随便找一个即可！
Java基础语法
1、注释(comment)
-
注释是属于备注内容的东西，不会被程序执行。
-
写备注的好处是方便自己回忆和让其他人理解自己的代码。
-
单行注释：
//注释内容 -
多行注释：
/*注释内容*/
2、关键字(keywords)
-
java代码中高亮的就是关键字，全部都是小写字母，每个关键字都具有其特殊含义，变量命名时避免使用。
-
java中常见关键字：（不能死记硬背，学习中用多了就记住了）
-
![]()
3、标识符
标识符是指程序中我们自己定义的内容
Java中的类名、变量名以及方法名都被称为标识符
命名规制（必须遵守）
-
所有的标识符都只能以字母（A-Z或者a-z）、美元符（$）、或者下划线（_）开始。
-
首字符之后可以是字母、美元符、下划线或数字的任何字符组合。
-
不能使用关键字作为变量名或方法名
命名规范（建议使用）
-
遵循驼峰命名规则，尽量使用英文命名，命名区分大小写。
-
标识符是大小写敏感的
-
合法标识符举例：name、$salary、_value、__1_value
-
非法标识符举例：123adc、@salary、#name
-
可以使用中文命名，但是一般不建议这样去使用，也不建议用拼音。
4、数据类型
-
Java是强类型语言
-
要求变量的使用要严格符合规定，所有变量都必须先定义才能生效。（安全性高，但是运行速度缓慢）
-
-
Java的数据类型分为两大类
-
基本类型（primitive type）八大基本数据类型，String不是数据类型，是一个类
-
一个字节（1byte） = 八位（8bit）
-
数据类型 关键字 内存占用 取值范围 使用场景 短整型 short 2个字节 -32768~32767 一般不用（兼容性考虑） 整形 int 4个字节 -231 ~ 231 -1 存储普通整形，最常用 长整型 long 8个字节 -263 ~ 263 -1 存储长整型，常用 单精度浮点型 float 4个字节 3.40E+38 ~ +3.40E+38 存储浮点数（不常用） 双精度浮点型 double 8个字节 -1.7977E+308~1.7977E+308 存储双精度浮点数（常用） 字节型 byte 1个字节 -128～127 存储字节数据 字符型 char 2个字节 0-65535 存储⼀个字符 布尔类型 boolean 1个字节 true，false 存储逻辑变量 -
引用类型（reference type）
-
-
-
字节
-
-
类型拓展
public class Demo3 {
public static void main(String[] args) {
//整数扩展 二进制0b 八进制0 十进制 十六进制0x
int i = 10;
int i1 = 0b10;
int i2 = 010;
int i3 = 0x10;
System.out.println(i); //i=10
System.out.println(i1);//i1=2
System.out.println(i2);//i2=8
System.out.println(i3);//i3=16
//浮点数扩展 银行业务如何表示？钱
//BigDecimal 数学工具类
//float 有限 离散 舍入误差 大约 接近但不等于
//最好完全不使用浮点数进行比较
float a = 0.1f;
double b = 0.1;
System.out.println(a==b);
float c = 1311541848151848f;
float d = c + 1;
System.out.println(c==d);
//字符扩展
char c1 = 'a';
char c2 = '中';
System.out.println(c1);//a
System.out.println((int)(c1));//97
System.out.println(c2);//中
System.out.println((int)c2);
//20013
//所有的字符本质还是数字
//编码 Unicode 表：（97 = a, 65 = A） 2字节 0 - 65536
//U0000 UFFFF
char c3 = '\u0065';
System.out.println(c3);
//转义字符
// \t制表符 \n换行
}
}
5、类型转换
-
由于java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。类型从低到高分别是 byte -> short,char -> int -> long -> float -> double。
-
注意点：
-
不能对布尔值进行转换
-
不能把对象类型转换为不相关的类型
-
在把高容器类型转换到低容器的时候，需要强制转换。
-
转换的时候可能存在内存溢出（在操作比较大的数的时候），或者精度问题。
-
JDK7新特性，数字之间可以用下划线分割。如：10_0000_0000
-
6、变量和常量
6.1、命名规范
6.2、变量
变量就是指代在内存中开辟的存储空间，用于存放运算过程中需要用到的数据，Java中要求⼀个变量每次只能保存⼀个数据，而且必须要明确保存的数据类型。
变量的定义
三要素：数据类型、变量名、数据的值
数据类型 变量名 = 数据值;
long类型：建议数据后加L表示。
float类型:建议数据后加F表示。
变量必须初始化后才能赋值
变量的作用域
-
类变量：全局可用，必须在前面加上static关键字。
-
实例变量：从属于整个对象/类，作用域更大。可以不用初始化，且有默认值。
默认值是0(整数型)，0.0(浮点型)，false(布尔类型)，null(字符型)，除了基本类型，其余的默认都是null
-
局部变量：写在方法里面，作用于这个方法内部。且必须声明和初始化赋值。
-
//类变量 加了static后，就不用像实例变量一样还需要再new了。
static double salary = 2500;
// 实例变量：从属于对象。用的话通过.name即可调用。
String name;
int age;
public static void main(String[] args) {
//局部变量：必须声明和初始化赋值。
int i = 10;
System.out.println(i);
// 实例变量的调用。
// 变量类型 变量名称 = new 自引用类型。
Test test = new Test();
System.out.println(test.name);
System.out.println(test.age);
//类变量 static 可以直接调用并输出结果。
System.out.println(salary);
}
6.3、常量(Constant)
-
初始化后不能再改变值。
-
常量可以理解为一种特殊的变量，只是他的值在设定好，在程序运行过程中不允许被改变。
-
被
fianl修饰的常量名称，一般使用全大写的格式
final关键字：不可改变，可以用于修饰类、方法和变量
注意：引用类型变量被final修饰后，只能指向一个对象，地址不能再更改，但是不影响对象内部的成员变量值的修改
7、运算符
idea快捷键：ctrl+d：复制当前行到下一行。
/*
A = 0011 1100
B = 0000 1101
-------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001 //A与B不一样取1，一样取0
~B = 1111 0010//取反
面试题：2*8如何运算最快
2*8 = 16 2*2*2*2
位运算效率极高！！！
<< 左移 *2
>> 右移 /2
0000 0000 0
0000 0001 1
0000 0010 2
0000 0100 4
0000 1000 8
0001 0000 16
2<<3 = 16
*/
扩展运算符：
a += b //a = a+b
字符串连接符 +
-
+字符在碰到字符串的时候，表示拼接、连接的含义 -
“a” + “b” 结果是”ab“
-
当加号前存在String类型时，会把之后的类型也转换为String。
int a = 10;
int b = 20;
System.out.println(""+a+b); //结果为1020
System.out.println(a+b+""); //结果为30
条件（三元 ）运算符
-
布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
-
布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。
//x ? y : z(关系表达式) ? 表达式1 : 表达式2;
int x = 10;
int y = 5;
int z;
//如果x大于y 则是true，将x赋值给z；
//如果x不大于y 则是false，将y赋值给z；
z = (x > y) ? x : y;
System.out.println("x = " + x);
通过三元运算符比较三个数的大小
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入三个数");
int a = scanner.nextInt();
int b = scanner.nextInt();
int c = scanner.nextInt();
int temp = a>b ? a : b;
int max = temp>c ? temp : c;
System.out.println("最大值为" +max);
}
++a先自加后运算，a++先运算后自加
&& 和 & 的区别：都属于短路操作，短路操作就是只要出现结果就不进行接下来的操作，例如当一个条件为false就不在进行下面条件的运算，可以减小程序运行时间，提高效率。
<<：左移
：右移 正数补0，负数补1
：无符号右移 符号位永远补0，得到个正数
-4>>>1
原码：1 000 0100
反码：1 111 1011
补码：1 111 1100
无符号右移1位
补码：0 111 1110
反码：0 111 1101
原码：0 111 1101
8、包机制
包的本质就是文件夹。防止命名空间重复。
定义包叫package，引入包叫import。
9、JavaDoc
-
javadao命令是用来生成自己API文档的
-
参数信息
-
@author 作者名
-
@version 版本号
-
@since 指明需要最早使用的jdk版本
-
@param 参数名
-
@return 返回值情况
-
@throws 异常抛出情况
-
Java流程控制
1、概述
在⼀个程序执⾏的过程中，各条语句的执⾏顺序对程序的结果是有直接影响的。也就是说，程序的流程对运⾏结果有直接的影响。所以，我们必须清楚每条语句的执⾏流程。⽽且，很多时候我们要通过控制语句的执⾏顺序来实现我们要完成的功能。
任何复杂的程序逻辑都可以通过“顺序”、“分⽀”、“循环”三种基本的程序结构实现。
顺序结构：程序根据编写的顺序，从上到下执行。
2、if多选择结构
注意点：
・if语句里最多有一个else语句，else语句在所有else if语句之后。
・if语句里可以有若干个else if 语句，在else语句之前。
・一旦一个else if语句里检测为true则跳过所有接下来的else if 和else语句。
3、switch多选择结构
-
switch后面跟的是要判断的变量
-
判断的变量必须是要可以自动转换为int的值，如byte short char
-
但在JDK1.7中的判断变量可以使用String
//case穿透，当不写break时，会出现穿透现象，不会再判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束
//switch 匹配一个具体的值
从jdk7开始，switch开始支持string类型的比较。
字符的本质还是数字。
反编译 java---class（字节码文件）---反编译（IDEA）
将字符串转换成对应的hashcode码进操作。
4、循环语句
4.1、while循环结构
while语句里的布尔表达式为true循环便会继续下去。
但是多数情况下是写入指定条件，让表达式失效，直到while循环停下。避免while里的值无法跳出形成死循环，否则会占用计算资源，引起死机等。
4.2、do while循环结构
do while总是能保证循环体被执行一次。⽆条件执⾏⼀次循环体，即使我们将循环条件直接写成false，也依然会循环⼀次。这样的循环具有⼀定的⻛险性
初始化表达式
do {
循环体
步进表达式
} while (布尔表达式);
4.3、for 循环结构
break用于强行退出循环，不执行循环中剩余的语句。
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
if (i==3)
break;
System.out.print(i);
}
System.out.println();
for (int i = 0; i < 5; i++) {
if (i==3)
continue;
System.out.print(i);
}
}
//前一个输出 012
//后一个输出 0124
4.4、for和while的区别
-
控制条件语句的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐用for。因为for循环结束后，该变量就从内存中消失了，能够提高内存的使用效率
-
在已知循环次数的时候推荐使用for，循环次数位置的时候用while
java方法
方法：是语句的集合。在一起执行一个功能
System.out.println() 语句里，System是类，out是对象，println()是方法。调用系统类System里的标准输出对象out里的println方法。
1、方法的定义
修饰符 返回值类型 ⽅法名(参数列表) {
// 代码省略...
return 结果; }
修饰符：public 固定写法
返回值类型：表示方法运行的结果的数据类型，方法执行后将结果返回到调⽤者参数列表：⽅法在运算过程中的未知数据，调⽤者调⽤⽅法时传递
return：将⽅法执⾏后的结果带给调⽤者，⽅法执⾏到 return ，整体⽅法运⾏结束
提示：return 结果; 这⾥的"结果"在开发中，我们正确的叫法称为方法的返回值
一个方法只完成一个功能，这样利于我们后期的扩展。
定义方法的两个明确：
-
明确返回值类型
-
明确参数类型
注意点：
-
定义位置：类中方法外面
-
返回值类型：必须要和return语句返回值类型相同，否则编译失败
-
不能在return后面写代码，return意味着方法结束
2、方法重载
方法重载：指在同⼀个类中，允许存在⼀个以上的同名⽅法，只要它们的参数列表不同即可，与修饰符和返回值类型⽆关。
参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调⽤不同的方法。
3、可变参数
JDK1.5开始，Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号（...）。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
4、递归
递归结构包括两个部分：
-
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
-
递归体：什么时候需要调用自身方法。
数组
1、数组概述
容器：是将多个数据存储到一起，每个数据称为该容器的元素
数组：数组是存储数据长度固定的容器，但是其中的数据的数据类型需保持一致，数组是最基本的一种数据结构
2、数组定义与访问
定义格式：
数据类型[] 数组名 = new 数据类型[数组长度]
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...};
数据类型[] 数组名 = {元素1, 元素2, 元素3...};
数组的访问：
-
索引：每⼀个存储到数组的元素，都会⾃动的拥有⼀个编号，从0开始，这个⾃动编号称为数组索引 (index)，可以通过数组的索引访问到数组中的每个元素。
3、数组内存原理图
内存：内存是计算机中的重要原件，是一个临时存储区域，用来运⾏程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运⾏的，必须放进内存中才能运⾏，运行完毕后会清空内存。
Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。
JVM内存划分：
| 名称 | 作用 |
|---|---|
| 本地方法栈 | JVM在使用操作系统功能的时候使用，和我们开发无关。 |
| 方法区 | 存储可以运行的class文件。 |
| 堆内存 | 存储对象或者数组，new来创建的，都存储在堆内存。 |
| 方法栈 | ⽅法运行时使⽤的内存，比如main⽅法运行，进入方法栈中执行。 |
面向对象
1、面向对象思想
物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向过程思维：是一个线性思维，第一步做什么，第二部做什么，步骤明确。
面向对象思维：分类的思维方式。统筹各个部门做什么。
比如一个人可做事情，其中一个上厕所就属于方法，调用方法就去上厕所，具体怎么上就是面向过程一步步走了。
宏观把握，处理复杂的多人协作事务 →→→ 面向对象
具体到微观操作，具体思路细节的分析 →→→ 面向过程
特点：面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。
2、面向对象编程（OOP）
-
本质：以类的方式组织代码，以对象的组织（封装）数据。
-
类：是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事务的属性特征和行为特征来描述该类事务
-
属性：该事物的状态信息
-
行为：该事物能够做什么
-
对象：是一类事物的具体体现，对象是类的一个实例，必然具备该类事务的属性和行为
-
三大特性
-
分装
-
继承
-
多态
-
static是和类一起加载的，方法是在类实例化后才存在。
类中的构造器也称为构造方法
new一个对象，本质是在调用构造器。
3、封装
-
就像看电视，不需要了解构造和原理，只需要遥控器就可以看电视换台。
-
设计遵循高内聚，低耦合：高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用。
-
封装可以防止该类的代码和数据被其他类随意访问，适当的封装可以让代码更加容易被理解和维护，也加强了代码的安全性
-
原则：将属性隐藏起来，若要访问某个属性，提供公共方法对其访问
-
属性私有：get/set
封装的意义：
-
提高程序的安全性，保护数据
-
隐藏代码的实现细节
-
提供统一接口
-
增加系统可维护性
this的含义：代表所在类的当前对象的引用地址，即对象自己的引用。方法被哪个对象调用，方法中的this就代表哪个对象。
JavaBean：标准代码：JavaBean 是 Java语⾔编写类的⼀种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get 方法。
4、继承extends
-
继承：就是子类继承父类的属性和方法，
-
继承的本质是对一批类的抽象，让代码实现建模。
-
子类继承的是父类的public的，父类的私有的Private类无法被继承，除非父类写get/set取到
-
Java里的所有类都继承Object类
-
提高了代码的复用性，是多态的前提
-
在子父类中出现了同名的成员变量时，在子类需要访问父类中非私有成员变量时，需要使用
super关键字，修饰父类成员变量
4.1、super关键字
-
super调用父类的构造方法，必须在构造方法的第一个
-
super只能出现在子类的方法或者构造方法中！
-
super和this不能同时调用构造方法！
super和this不同点：
-
代表的对象不同：
-
this：代表当前对象的引用
-
super：代表父类对象的引用
-
-
前提
-
this：没有继承也可以使用
-
super：只能在继承条件中才可以使用
-
-
构造方法
-
this（）；本类的构造！
-
super（）；父类的构造！
-
继承的特点：java只支持单继承，不支持多继承；java支持多层继承（继承体系）如：A继承B，B继承C
4.2、方法重写
-
方法名必须相同
-
参数列表必须相同
-
修饰符：范围可以扩大，但不能缩小；
-
抛出的异常：范围，可以被缩小，但不能扩大。
为什么重写：
父类的功能，子类不需要或者不满足。
多态
-
多态是方法的多态
-
父类和子类，有联系。否则会报类型转换异常！ClassCastException！
-
存在条件：继承关系，方法需要重写，父类引用指向子类对象！ father f1 = new son（）；
无法重写的情况
-
static 方法，属于类，它不属于实例
-
final 常量；
-
private 方法，私有类。
-
5、多态
多态：是指同一行为，具有多个不同表现形式。一个对象的实际类型是确定的，但是可以指向的引用类型就不确定了。
前提：
-
继承或者实现
-
方法的重写
-
父类引用指向子类对象
好处：多态可以使程序编写的更简单，可以实现动态编译，使得可扩展性更强
引用类型转换：
-
父类引用指向子类对象
-
把子类转换为父类，向上转型
-
把父类转换为子类，向下转型，强制转换
-
方便方法的调用，减少重复的代码。
向下转型的作用：
-
使用多态时我们无法直接调用子类拥有，而父类没有的方法。如果我们想要调用子类特有的方法，必须做向下转型
-
子类类型 变量名 = （子类类型）父类变量名
如：Person p = new Person（）;
Student s = （Student）p;
Instanceof关键字
在转型的过程中，经常会出现ClassCastException这个异常，为了避免这个异常的发生，Java提供了Instanceof关键字
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。
X instanceof Y取决于x和y是否有父子关系
6、常用API
6.1、概述
API(Application Programming Interface)，应用程序编程接口。Java API是⼀本程序员的“字典”，是JDK提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使⽤它们。
| 包 | 功能 |
|---|---|
| java.lang | Java程序的基础类，如字符串、多线程等，该包中的类使用的频率非常高，不需要import，可以直接使用 |
| java.util | 常⽤⼯具类，如集合、生成随机数、日历、时钟等 |
| java.io | 文件操作，输入输出 |
| java.net | 网络操作 |
| java.math | 数学运算相关操作 |
| java.sql | 数据库操作 |
| java.text | 处理文字、日期、数字的格式 |
6.2、用户交互：Scanner
Scanner对象用来获取用户的输入，采集输入信息。
通过next() 和 nextLine() 获取用户输入的字符串；
通过hasNext() 和 hasNextLine() 判断是否还有输入的数据。
6.3、Object类常用方法
java.lang.Object类是所有Java语言的根类，如果一个类没有特别指定父类，那么默认继承Object类
toString方法：
-
"" + 对象：⾃动调⽤对象的toString⽅法
-
System.out.print（对象）：直接调⽤toString⽅法。我们直接使用输出语句输出对象名时，其实通过该对象调用了其toString（）方法。
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。因为返回的结果是地址值，开发中一般会进行重写。
equals方法：
-
返回一个
boolean，判断两个对象是否时相同的 -
默认进行
==运算符的对象地址比较，只要不是同一个对象，结果就为false。开发中一般也会进行重写，与hashCode方法结合使用
6.4、String类
-
public String trim()：返回⼀个字符串，其值为此字符串，并删除任何前导和尾随空格。 -
public boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始。 -
public boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束。 -
public String toLowerCase()：使用默认语言环境的规则将此字符串中的所有字符都转换为小写。 -
public String toUpperCase()：使用默认语⾔环境的规则将此字符串中的所有字符都转换为大写。 -
public static String valueOf(Object obj)：返回 Object 参数的字符串表示形式。 -
String转换成对应的基本类型，除了Character类外，其他包装类都具有patseXxx静态方法可以将字符串参数转换为对于的基本类型，如Integer.parseInt(“100”);
-
如果字符串参数的内容无法正确转换为对应得基本类型，则会抛出java.lang.NumberFormatException异常
6.5、正则表达式
作用：实际开发中，经常需要对字符串数据进行一些复杂的匹配、查找、替换等操作。正则表达式就是用来描述这些操作规则的工具。
例如：
-
"[a-z]"：表示a到z的任意⼀个字符
-
"[a-z]+"：表示由1个或多个a-z字符组成的字符串
常用API:
-
public boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式 -
public String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串 -
public String replaceAll(String regex, String replacement)：使用给定的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
7、static关键字
-
类里的静态变量可以直接调用，而非静态变量则需要实例化才能调用。
-
类里的静态方法可以以类名的方法直接被调用，而非静态方法也是需要实例化才能调用。
-
是随着类的加载而加载的，且只加载一次
-
存储于一块固定的内存区域（静态区）
8、抽象类
为什么要有抽象类：父类中的方法，被他的子类们重写了，子类各自的实现都不尽相同，那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法，而包含抽象方法的类就是抽象类
-
抽象类的所有方法，继承了它的子类，都必须要实现他的方法，除了子类也是抽象类外。最终，必须有子类实现该父类的抽象方法，否则，抽象类就失去了意义
-
抽象类不能new，只能通过子类实现。
-
抽象类中能写普通方法
-
抽象类不一定包含抽象方法，但是有抽象方法的类必定是抽象类。未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
存在的意义：抽象出来，提高开发效率。
9、接口
实现接口，写方法即可。专业的约束。实现约束和实现分离。
现在项目的开发很多都是【面向接口编程】。别人定义好接口，去实现接口，写里面的方法即可。
接口看完可以去看23种设计模式。里面是大量的面向对象的精髓，有大量的接口的实现，
-
接口的本质是约束。就像法律一样，制定好后大家都要遵守。
-
接口中的所有定义其实都是抽象的 public abstract
-
接口不能被实例化
-
接口中含有抽象方法、默认方法（default修饰，供子类调用或者子类重写）、静态方法（static修饰，供接口直接调用）、私有方法和私有静态方法
实现接口：
-
非抽象子类实现接口，必须重写接口中所有的抽象方法；继承了接口的默认方法，既可以直接调用，也可以重写
-
一个类可以实现多个接口，这叫做接口的多实现
优先级的问题：当一个类，既继承一个父类，又实现了若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法
其他成员特点：
-
接口中无法定义成员变量，只能定义常量，默认用
public static final修饰 -
接口中没有构造方法，不能创建对象
-
接口中没有静态代码块
10、N种内部类
内部类
-
概念：在一个类的内部在定义一个完整的类。将一个类A定义在另一个类B中，类A就称为内部类，B则称为外部类
-
特点：
-
编译之后可生成独立的字节码文件。但是前面会加上外部类和$符号
-
内部类可以直接访问外部类的私有成员，而不破坏封装。
-
可为外部类提供必要的内部功能组件。
-
外部类想要访问内部类的成员，必须要建立内部类的对象。格式：
-
//比如外部类是人，内部类是心脏
Person p = new Person();
Heart heart = p.new Heart();
-
成员内部类：定义在类中方法外的类，
在描述事物时，若⼀个事物内部还包含其他事物，就可以使用内部类这种结构。
匿名内部类：是内部类的简化写法，他的本质是一个带具体实现的父类或者父接口的匿名的子类对象
使用方式：
//定义一个接口
public abstract class People {
public abstract void eat();
}
//创建匿名内部类并使用
public class Demo {
public static void main(String[] args) {
People p = new People() {
public void eat() {
System.out.println("我吃饭了~~~");
}
};
p.eat();
}
}
此外，通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。
public static void main(String[] args) {
People p = new People() {
@Override
public void eat() {
System.out.println("我吃饭了");
}
};
f(p);
}
public static void f(People p){
p.eat();
}
11、异常机制
异常体系结构
异常捕获（快捷键 Ctrl + Alt +T ）
try{try监控区域}
catch（）{想要捕获的异常类型，捕获异常}
finally{可以不写，主要用于资源关闭和提示}
自定义异常
public class MyException extends Exception{
private int detail;
public MyException(int a){
detail = a;
}
@Override
public String toString() {
return "MyException{" +
"detail=" + detail +
'}';
}
}
public class MyTest {
public void ExTest(int a) throws MyException{
System.out.println("异常执行前");
if (a>10){
throw new MyException(a);
}
System.out.println("异常执行后");
}
public static void main(String[] args) {
try {
new MyTest().ExTest(1);
} catch (MyException e) {
System.out.println("MyTest" + e);
}
}
}
总结：
浙公网安备 33010602011771号