1-Java SE基础
Java SE基础知识总结
背景知识
3种技术架构
- Java SE：Java Platform Standard Edition（标准版），完成桌面应用程序的开发，是其它两者的基础
- Java ME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；
- Java EE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；
Java跨平台工作原理
Java代码分为编译和运行两个步骤，编译产生的 .class 字节码文件（结构中立的中间文件格式），可以通过不同平台的JVM虚拟机解释为对应平台的机器语言，从而运行。
跨平台运行的关键是JVM：跨平台的是程序，不是JVM，不同的平台有对应不同的JVM
JDK
Java Development ToolKit 的简称，也就是 Java 开发工具包。
JDK 是整个 Java 的核心，包括 Java 运行环境（Java Runtime Envirnment，简称 JRE），Java 工具（比如 javac、java、javap 等等），以及 Java 基础类库（比如 rt.jar）
JVM
Java虚拟机（Java Virtual Machine，JVM）是Java平台的核心组成部分之一，它是一个在计算机上运行Java字节码的虚拟机。JVM充当了Java应用程序和底层操作系统之间的中间层，提供了跨平台的特性，使得Java程序可以在不同的操作系统和硬件上运行
相互关系
Java发展
Java项目结构
- Project：项目、工程
- module：模块
- package：包
- class：类
Java基础语法
注释
// 单行注释
/*
多行
注释
*/
/**
文档注释
*/
关键字
字面量、变量、常量
int a = 10; //a为变量，10为字面量
final int b = 10; //b为常量，10为字面量
static str = "Hello World"; //str为变量，Hello World为字面量
字面量：由字母、数字等构成的字符串或者数值，只能在等号右边出现
变量：定义的在特定范围内变化的符号。必须被初始化，可以不被赋初始值
常量：被final修饰的变量。必须赋初值，且其类型和值不能再改变
标识符
合理的Java命名
命名规范
- 小驼峰命名，常给变量命名：name、firstName
- 大驼峰命名，常给类命名：Student、GoodStudent
数据类型
基本数据类型
| 关键字 | 数据类型 | 内存占用大小（字节） | 补充 |
|---|---|---|---|
| byte | 整数 | 1 | |
| short | 整数 | 2 | |
| int | 整数 | 4 | 整数默认类型 |
| long | 整数 | 8 | |
| float | 浮点数 | 4 | |
| double | 浮点数 | 8 | 浮点数默认类型 |
| char | 字符 | 2 | 在程序中用单引号表示（String，在程序中是双引号表示） |
| boolean | 布尔 | 1 |
ASCLL码表
程序中字节到字符之间的映射关系
Java中字符可以直接进行大小比较，本质是转为其对应的字节值大小进行比较
引用数据类型
类、接口、数组
运算符
运算符：对字面量或者变量进行操作的符号
表达式：用运算符把字面量或者变量连接起来符合java语法的式子就可以称为表达式
int a = 10;
int b = 20;
int c = a + b;
/*
+：是运算符，并且是算术运算符
a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式
*/
算数运算符
| 符号 | 意义 |
|---|---|
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 取余 |
！同类别算数运算符，从左到右依次参与运算
public class Test {
public static void main(String[] args) {
System.out.println(1 + 23); // 24
System.out.println("年龄为:" + 23); // 年龄为：23
System.out.println(1 + 99 + "年黑马"); // 100年黑马
System.out.println("练习时长" + 1 + 1.5 + '年'); // 练习时长11.5年（当碰到字符串后，+就变成了字符串连接符，而不是算数运算符）
System.out.println("练习时长" + (1 + 1.5) + '年'); // 练习时长2.5年
}
}
自增自减运算符
- 单独使用，在变量前边或后边均不影响结果
- 组合使用：在后，先拿变量值参与运算，再进行变量增减操作；在前，先进行变量增减运算，再拿变量的值参与运算
public class Test {
public static void main(String[] args) {
int a = 10;
a++ // a=11
++a // a=12
int b;
b = ++a; // a=13, b=13
a++; // a=14
b = a++; // a=15,b=14
}
}
// --运算符同理
类型转换
隐形转换
1、【基本隐式转换】取值范围小的数值或者变量，赋值给取值范围大的变量
public class Test {
public static void main(String[] args) {
int a = 10;
double b = a; // b=10.0
}
}
2、【运算隐式转换】取值范围小的数据和取值范围大的数据进行运算，小的提升为大的，再运算
public class Test {
public static void main(String[] args) {
int a = 10;
double b = 12.3;
double c = a + b;
}
}
3、【运算隐式转换】byte、short、char，三者运算时，会先提升为int，再进行运算
public class Test {
public static void main(String[] args) {
int a = 1;
char b = 'a';
int c = a + b;
System.out.println(c); // c=98
}
}
强制转换
1、把一个取值范围大的数值或者变量，赋值给另一个取值范围小的变量，不允许直接赋值，需要强制转换
public class Test {
public static void main(String[] args) {
double b = 12.3;
int a = (int) b; // a=12
}
}
赋值运算符
| 符号 | 意义 |
|---|---|
| = | 赋值 |
| += | 相加后赋值 |
| -= | 相减后赋值 |
| *= | 相乘后赋值 |
| /= | 相除后赋值 |
| %= | 相取余后赋值 |
！隐含着强制类型转换
关系运算符
| 符号 | 意义 |
|---|---|
| == | |
| != | |
| > | |
| >= | |
| < | |
| <= |
！处理结果都是boolean数据类型，结果是true或false
逻辑运算符
| 符号 | 意义 | 补充 |
|---|---|---|
| & | 有false就是false | |
| && | 有false就是false，且不进行后续关系运算的计算 | 常用 |
| | | 有true就是true | |
| || | 有true就是true，且不进行后续关系运算的计算 | 常用 |
| ！ | true即false，false即true | 常用 |
| ^ | 相同为false，不同为true |
三元运算符
public class test {
public static void main(String[] args) {
int a = 2;
int v = a == 1 ? 1 : 10;
System.out.println(v); // v=10
}
}
运算符优先级
方法（函数）
- 方法定义和调用
- 方法调用内存的图解
方法重载
同一个类中，方法名相同，参数不同的方法
- 参数不同：个数不同、类型不同、顺序不同
流程控制语句
顺序结构
默认
分支结构
if、switch
循环结构
for、while、do…while
跳转控制语句
break、continue
数组
一种容器，可以存储同种数据类型的多个值
一维数组
定义
public class Demo1Array {
public static void main(String[] args) {
int[] array1;
int array2[];
System.out.println(array1);
System.out.println(array2);
}
}
静态初始化
// 完整格式：数据类型[] 数组名 = new 数据类型[] { 元素1，元素2，元素3… };
int[] array = new int[]{ 11，22，33 };
// 简化格式：数据类型[] 数组名 = { 元素1，元素2，元素3… };
int[] array = { 11，22，33 };
动态初始化
int[] arr = new int[3];
- 动态初始化：手动指定数组长度，由系统给出默认初始化值
- 静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度
默认值
| 类型 | 初始化 | 默认值 | 补充 |
|---|---|---|---|
| 整数数组 | int[] arr = new int[5]; | 0 | 基本数据类型 |
| 小数数组 | double[] arr = new double[5]; | 0.0 | 基本数据类型 |
| 字符数组 | char[] arr = new char[5]; | ‘\u0000’（空白字符） | 基本数据类型 |
| 布尔数组 | boolean[] arr = new boolean[5]; | false | 基本数据类型 |
| （类、接口、数组）数组 | String[] arr = new String[5]; Array[] arr = new Array[1]; | null | 引用数据类型 |
二维数组
静态初始化
// 完整格式：数据类型[][] 数组名 = new 数据类型[][] {{元素1,元素2},{元素1, 元素2}};
int[][] arr = new int[][]{{11,22},{33,44}};
// 简化格式：数据类型[][] 数组名 = {{元素1,元素2}, {元素1, 元素2}};
int[][] arr = {{11,22},{33,44}};
动态初始化
int[][] arr = new int[2][3];
- 动态初始化：手动指定数组长度，由系统给出默认初始化值
- 静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度
面向对象
基本
类和对象的概念
1、概念
- Java 中想要创建对象，必须先要有类的存在
- 类指的是一组相关属性和行为的集合（我们将其理解为是一张对象的设计图）
2、相互关系
- 根据类创建对象
- 1个类可以创建n个对象
3、类的组成
- 属性：成员变量
- 方法：成员方法
成员变量和局部变量
this关键字
- 当局部变量和成员变量出现了重名的情况，java采用就近原则，即使用局部变量
- 通过this，可以让其使用成员变量【相当于python中的self】
- this：代表当前类对象的引用（地址）
构造方法
1、概念
- 构建、创造对象的时候，所调用的方法
- 在执行的时候，用来给对象中的属性进行初始化
2、格式
public class Student {
String name;
int age;
// 无参构造
public Student() {
}
// 带参构造
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
- 方法名与类名一样
- 没有返回值类型，void也没有
- 没有具体返回值，return也没有
3、执行时机
- 创建对象的时候调用，每创建一次，执行一次构造方法
- 不能手动调用构造方法
4、特点
- 系统默认提供无参构造
- 人工定义了构造方法，系统就不提供无参构造了，需要连带定义出无参构造
- 构造方法支持重载
封装
使用类设计对象时，将需要处理的数据以及处理这些数据的方法，设计到对象中
封装要素
合理隐藏、合理暴露
权限修饰符
public、protected、private
字符串
String类
特点
- 在Java中，双引号字符串，都是String类
- 字符串创建之后，内容不可更改，但是可以共享
字符串常量池
- 字符串的分配，同其他对象一样，极其耗时。作为最基础的数据类型，大量创建影响性能
- 为了提供性能和减少内存开销，引入字符串常量池（jdk7以前，在方法区；jdk7以后，在堆内存）
- 创建字符串时，看看常量池中有没有该实例。无，创建；有，引用（可被共享的原因）
实例
public class Demo1Array {
public static void main(String[] args) {
String s1 = "abc"; // 常量池内没有，创建
String s2 = "abc"; // 常量池内有，引用
System.out.println(s1 == s2); // 两者是一个东西，true
String s1 = "abc"; // 常量池内没有，创建
String s2 = new String("abc"); // 在堆内存中开辟
System.out.println(s1 == s2); // 两者不是一个东西，false
String s1 = "abc"; // 常量池内没有abc，创建
String s2 = "ab"; // 常量池内没有ab，创建
String s3 = s2 + "c"; // 常量池内没有c，创建，StringBuilder内完成相加操作，并在堆内存开辟新的空间存储abc
System.out.println(s1 == s3); // 两者不是一个东西，false
String s1 = "abc"; // 常量池内没有，创建
String s2 = "a" + "b" + "c"; // 常量优化机制，等同于abc。常量池内有，引用
System.out.println(s1 == s2); // 两者是一个东西，true
}
}
- 字符串内容比较（不忽略大小写）：strs1.equals(strs2)
- 字符串内容比较（忽略大小写）：strs1.equalsIgnoreCase(strs2)
基本操作
遍历、截取、替换、切割
StringBuilder类
- 提高字符串操作效率：StringBuilder的拼接速度比单纯的字符串运算拼接速度快上一个量级
- 本质是字符串的缓冲区，可以理解为一个容器，其内存储的内容长度可变
构造方法
StringBuilder() // 无参构造，创建空的字符串缓冲区
StringBuilder(String str) // 有参构造，创建一个字符串缓冲区，按照给定的参数完成初始化
基本操作
添加、反转、长度、转为字符串
集合基础
是一种容器，用来装数据，类似数组，但长度可变
ArrayList长度可变原理
- 当创建的时候，底层存在一个长度为10的空数组
- 添加元素，当容量不够的时候，扩容到原先的1.5倍
- 将原数组数据拷贝到新数组中
- 将新元素添加到新的数组中
基本操作
增、删、改、查、获取大小