JAVAEE基础

编译执行：效率高，不能跨平台

解释执行：效率低，可以跨平台

先编译（将.java源文件编译成.class字节码文件），再解释执行

Java虚拟机，跨平台的关键

Java开发工具包，包含开发环境和运行环境

Java运行环境

javac命令用来将.java文件编译成.class文件

java命令用来运行.class文件

注意：使用java命令运行.class文件时，不能写后缀名，例如：java HelloWorld

编译时需要带包编译，命令为：javac -d . HelloWorld.java

运行时需要带包运行，命令为：java first.HelloWorld

规定

约定俗成的规范

注释

更换盘符： 盘符:

查看目录内容：dir

进入文件夹： cd

进入上一层文件夹：cd ..

清空屏幕：cls

删除文件：del 文件名

删除文件夹：rd 文件夹名

退出：exit

内存是存储数据的空间。

变量是内存中保存数据的一个单位。

三要素

整数

小数

布尔

字符

字符串

数组

其他自定义类型

int n5 = n1 * n2; // 乘法

int n3 = n1 / n2; // 整数除以整数结果还是整数，结果是2

int n4 = n1 % n2; // 求模，即余数，结果是1

m1++; // 自增1

m2--; // 自减1

注意：int m4 = m3++ + 5; // 当++、--在后时，先参与运算，再自操作。当++、--在前时，先自操作，将结果参与运算

n1 = n1 + 3; // 简写为 n1 += 3; 自增3

n2 -= 3; // n2 = n2 -3;

n3 *= 3; // n3 = n3 * 5;

n4 /= 3; // n4 = n4 / 3;

n5 %= 3; // n5 = n5 % 3;

> 大于

<  小于

>= 大于等于

<= 小于等于

==  等于

!= 不等于

&&

||

！

注意

String s = m > 3 ? "成立" : "不成立";

语法

流程

语法

流程

语法

流程

注意：代码自上而下执行，只会执行一个分支

语法

流程

switch(变量或者表达式){
 case 值1:
  // 代码块1
  [break;]
  case 值2:
  // 代码块2
  [break;]
  case 值n:
  // 代码块n
  [break;]
  default:
     // 默认代码块
    [break;]
}

在case时，值不能相同

在if中的条件可以写大于小于等于等多种条件，但是case中只能判断等于

在case时，如果不满足条件，继续向下判断，如果条件满足，会执行里面的内容，如果里面的内容没有break关键字，会继续向下执行，不会判断

switch中变量的类型只能是byte、short、int、char、String[JDK7+]

局部变量需要先赋值后使用

局部变量的作用域范围是在它所对应的大括号里，并且要定义后才能使用

局部变量在有重复的作用范围时，不能重复定义（重名）

while(条件){
 // 代码块
}

先判断条件，如果条件成立，则执行代码块，执行完毕继续判断条件，条件成立时继续执行代码块，直到条件不成立则结束

初始变量

循环条件

循环内容（循环体）

条件的变更

do{
// 代码块
}while(条件);

先执行一次代码块，然后判断条件，如果条件成立则继续执行代码块，直到条件不成立为止

while先判断条件，再执行代码块，可能一次都不执行

do-while先执行一次代码块，再判断条件，至少执行一次

for(初始化变量;条件;迭代变量变更){
// 代码块
}

1、初始化变量（执行一次）
2、判断条件
3、循环内容
4、条件变更
5、再判断条件...(循环2、3、4直到条件不成立)

直接终止当前循环，整个循环结束

跳过当次循环（continue后面的代码不执行），继续进行下一次循环

外层循环执行一次，里层循环全部执行后，外层再执行第二次，里层循环继续全部执行。
简单来说，双重嵌套循环，总循环次数等于外层循环次数乘以里层循环次数。

在嵌套循环时，使用break或continue只对当前循环有效。

实现特定功能的一段代码，可以反复使用

语法

注意

当程序中有重复的代码块，可以放到一个方法中，以方便扩展和维护。
简化流程的理解过程。

public static 返回值类型 m1(){
   return 值;
}

在一个方法中，return后面不应该有代码，因为return就表示方法结束

在一个方法中，不能仅用有条件的方式来返回，必须在所有的情况下都能返回

当返回值类型为void时，在方法中可以没有return，也可以使用return作为方法的结束，用来终止嵌套循环。此时return后面直接加分号。

方法的多级调用是指，在方法中调用方法，通常用来流程简化。

在方法中再次调用当前方法，称为递归调用

循环只需要使用一个方法栈空间，所以消耗空间小，执行速度快，递归需要使用多次方法栈空间，要谨慎使用。

52采用倒除法计算除以2的余数，反向统计为110100

99== 9 * 10 + 9

110100 = 1 * 2的二次方 + 1 * 2的四次方 + 1 * 2的5次方 = 4 + 16 + 32 = 52

在Java中，书写2进制使用0b开头，8进制用0开头，十六进制用0x开头

计算规则：同为1则为1，否则为0

计算规则：只要有一个为1，结果为1

使用~作为取反（非）运算符

^作为异或运算符。

任何数与另外一个数字异或两次得到该数字本身。

小技巧：可以不用第三个变量实现两个整数的交换。

>>向右位移。移动n位相当于除以2的n次方

<<向左位移。移动n位相当于乘以2的n次方。低位补0

注意

如果在逻辑判断中使用&或者|，在判断结果上与&&或者||是一样的，但是&&或者||有短路的特征。而&或者|一定要计算两边的结果。

直接通过10进制转换成二进制之后的编码。

注意

将负数的反码设计为：符号位不变，其他各位取反。对于正数来说，反码与原码一致。

正数原码反码补码一致，负数补码等于反码+1

3.2
----------------------------------------------------------
11.0011001100110011001100110011001100110011

int[] a = new int[5]; // 创建5个元素大小的int型数组

int [] a; // 声明
a = new int[5]; // 再分配空间
a[0] = 10; // 赋值

int [] a1 = new int[10];

int [] a2 = new int[] {3,5,8,9,10};

int [] a3 = {2,56,8,9,10};

1、创建一个超过原来数组大小的新数组

2、将原数组中的元素复制到新数组中

3、将要添加的新元素添加到新数组中

System.arraycopy(src, 0, dest, 0, src.length);

int[] newArr = Arrays.copyOf(arr1, arr1.length + arr2.length);

int [] arr = {12, 35, 9, 55, 34, 4, 11, 8, 38};
  // 外层循环控制循环轮次，特点是每一轮可以将最值交换到数组的最后，应该循环的次数为长度-1
  for (int i = 0; i < arr.length - 1; i++) {
   // 里层循环两两比较，根据条件决定是否交换，循环完毕会将最值交换到最后，
   // 里层循环次数越往后越少，所以第0轮循环长度-1次，第1轮循环长度-2次，所以特点应该:长度-外层轮数-1
   for (int j = 0; j < arr.length - i - 1; j++) {
    if(arr[j] > arr[j+1]) { // 由小到大排序
     arr[j] = arr[j] ^ arr[j + 1];
     arr[j + 1] = arr[j] ^ arr[j + 1];
     arr[j] = arr[j] ^ arr[j + 1];
    }
   }

int [] arr = {12, 35, 9, 55, 34, 4, 11, 8, 38};
  // 外层循环循环轮次，此时应该是长度-1
  for (int i = 0; i < arr.length - 1; i++) {
   // 定义一个变量记住当前下标（轮次）
   int index = i;
   // 里层循环每次选择出最值对应的下标，循环从下标的后一位开始比较，记住该下标
   for (int j = i + 1; j < arr.length; j++) {
    if(arr[j] < arr[index]) {
     index = j;
    }
   }
   // 在里层循环结束后会得到一个下标，判断该下标是否轮次的值，如果不是，则将轮次对应下标元素与最值下标对应的元素交换
   if(index != i) {
    arr[index] = arr[index] ^ arr[i];
    arr[i] = arr[index] ^ arr[i];
    arr[index] = arr[index] ^ arr[i];
   }
  }

int [] arr = {5, 12, 35, 9, 55, 34, 4, 11, 8, 38, 6};
  // 循环轮次，由于每轮解决一个数字，所以一共需要数组长度-1轮
  for (int i = 0; i < arr.length - 1; i++) {
   // 从当前轮次后面一个数字开始判断，定义一个变量记住当前数字的值，定义一个变量记住空出来的位置
   int n = arr[i+1];
   int index = -1;
   // 从该数字之前一个数字开始循环比较，依次向前循环，
   for (int j = i; j >= 0; j--) {
    // 如果发现该数字比记住的数字小（假定由小到大排序），该数字向后移动，并且记住该数字空出来的位置
    if(n < arr[j]) {
     arr[j+1] = arr[j];
     index = j;
    }
   }
   // 里层循环完毕后，检查是否有空位置被记住，如果有，将记住的数字插入到该空位置处
   if(index != -1) {
    arr[index] = n;
   }
  }

int [] arr = {5, 12, 35, 9, 55, 34, 4, 11, 8, 38, 6};
  Arrays.sort(arr);

简称为OOP，面向对象的思想一般指在研究项目时，采用研究相应的业务有哪些对象参与，以及对象有哪些属性和方法，在执行方法时与其他对象之间的关联。面向对象的编程是指用面向对象的思想去思考，并且写对应代码。可以解决复杂的项目业务问题。

是指在研究项目时，考虑项目执行步骤，每一步如何完成，以此写出的代码就是面向过程的编程。一般应用底层开发（系统），以及业务较为简单的项目。

在创建了对象后会有默认值，与前面学习的数组默认值一样

方法的重载是指在类中，可以定义相同名词的方法

1、方法名词相同

2、参数列表不同（类型，个数，顺序）

在方法调用时，只需要传入相应类型的参数即可，无需考虑方法名称上的差异。

在方法调用时，优先考虑传入参数类型相符的方法，如果没有，会考虑自动转换类型能够匹配的方法。

构造方法是通过new关键字调用的方法，用来创建对象。

构造方法与类名相同，没有返回值，不是void，所以构造方法一般以大写字母开头。

当类没有定义构造方法时，会默认有一个无参的构造方法。

在一个类中，可以写多个重载的构造方法。
有参构造方法的作用是用来强制用户在创建对象时必须给关键属性赋值。

注意

this一般指代当前对象

1、在实例方法或构造方法中，如果定义了局部变量名称与属性相同，可以通过this.属性来调用属性。

2、在一个实例方法中，如果想要调用其他的实例方法，可以使用this.方法名()，此处this可以省略。

3、在构造方法中，如果想调用类中定义其他构造方法，可以使用this关键字。

封装分为属性封装和方法封装。

将属性设置为私有，提供公有的访问方法（getter和setter），在访问方法中，对属性的赋值或取值进行限制。

封装的作用是将需要被外部访问的方法暴露（公有），将不需要外部关注和使用的方法私有。

继承在Java中使用extends关键字来描述，表示扩展。

Java中的继承一般指is a关系，例如：狗 is a 动物，所以狗继承自动物，具备用动物的所有的特征和行为，那么动物是父类，狗是子类。

继承只能单继承（继承一个直接父类），但是可以多级继承（父类继承其他父类，那么子类就间接继承）

构造方法， 因为需要与类名相同，所以不可继承。

无法访问的（private，默认的在不同包的子类中）视为不可继承。

                  本类   本包   非本包子类   其他
private         √
默认的          √        √
protected     √        √            √
public           √        √            √            √

概念

原则

注意

经典面试题

概念

使用方式

调用构造方法

当创建子类对象时，会先创建父类的对象。
1、分配相应的空间
2、创建父类的对象
   a、初始化父类的属性
   b、调用父类的构造方法
3、创建子类对象
   a、初始化子类的属性
   b、调用子类的构造方法

由于采用父类的引用去指向子类的对象，所以父类的引用只能调用父类的属性和方法。
如果想要调用子类的特有属性和方法，需要强制转换类型（向下转型，拆箱），如果转换的类型不对，会出现ClassCastException异常（类型转换异常）
此时应该使用instanceof关键字来判断类型。

表示该类不能创建对象。
有一些抽象的概念所对应的类，例如动物类，本不应该创建对象，但是可能会由于失误创建了该对象，
为了限制此问题的出现，那么可以给类加上此关键字，作用是让该类不能被创建对象

表示该方法不能直接实现，需要在子类中重写实现。
因为有些方法在父类中实现没有意义，只有在各个不同的子类中去实现，那么此时可以给该方法添加此关键字

抽象类中可以没有抽象方法，但是抽象方法所在的类必须是抽象类

表示该属性为静态属性（类属性），该属性在类中只有一份，所有的对象共享一份

注意： 由于类属性整个类只有一份，所有的对象共享，所以一般推荐使用类名来直接操作，不需要创建对象。

表示该方法为类方法，应该通过类名直接调用，不需要创建对象。

注意：
1、static方法中可以访问其他的static方法，也可以使用static属性，
但是不能调用实例方法，也不能访问实例属性， 也不可以使用this或super关键字，原因是此时没有创建对象。
2、实例方法中可以访问实例属性，类属性，this或super关键字，也可以调用实例方法，类方法。

static修饰的语句块叫做静态语块，没有static修饰的叫做动态语句块

作用

静态语句块是类加载时执行，动态语句块是创建对象时执行，所以静态语句块中只能操作静态属性和静态方法。

先执行静态的内容：
- 父类静态属性初始化
- 父类的静态代码块
- 子类的静态属性初始化
- 子类的静态代码块

后执行非静态内容，先执行父类的非静态内容，再执行子类。
- 父类实例变量初始化
- 父类的动态代码块
- 父类的构造方法
- 子类的实例变量初始化
- 子类的动态代码块
- 子类的构造方法

该类不可以被继承

表示该方法不能被重写

表示该变量赋值后不能被重新赋值，由变量变成了常量

1、如果同时继承类并实现接口，那么继承类要放在前面
2、实现多个接口使用逗号隔开
3、当继承类并同时实现接口时，如果接口中有一个抽象方法与父类中某个方法声明完全一致，
在子类中可以不实现该方法。

内部类是指在一个类的内部定义的类。

成员内部类[了解]

静态内部类

局部内部类[了解]

匿名内部类

Object类是所有类的父类，是最顶层的父类，所有的类直接或间接继承了Object类

如果类继承了一个类，则间接继承了Object，如果没有继承任何类，则默认直接继承了Object。

所有类都具备有Object中定义的方法。Object类中没有定义属性

getClass方法

hashCode方法

toString方法

finalize方法

equals方法

byte         Byte
short        Short
int            Integer
long         Long
float         Float
double     Double
char         Character
boolean   Boolean

Integer.MAX_VALUE; // 最大值

Integer.toHexString(n4); // 显示十六进制字符串

Double.parseDouble(s);使用对应的包装类的parseXXX方法

对于Integer，系统预先创建了256个对象，范围是-128~127之间，作用是可以共享对象，节约内存。

与整数常量池相同的是，都可以共享使用，以节省空间

与之不同的，整数常量池在IntegerCache类加载后，就创建了256个对象，以共享使用，
而字符串值太多，无法直接一开始就创建，
所以是在第一次使用该字符串的字面量值时在常量池创建，并且提供共享引用。

charAt()

contains()

toCharArray()

indexOf()

length()

trim()

toUpperCase()

toLowerCase()

endsWith()

replace()

split()

substring()

concat()

String类由于不可变，每次对其操作，必须接收返回值，操作需要更多的空间。
如果项目中需要大量操作字符串的，为了节约空间，提升效率，推荐使用可变字符串。
可变字符串是直接在字符数组中操作的。除非需要扩容，否则不会浪费额外的空间。

StringBuilder

StringBuffer

append()

delete()

replace()

insert()

toString()

浮点数精确运算

大数字运算

subtract()

add()

multiply()

divide()

new Date()

getTime()

new Date(1620715603615L)

before()

compareTo()

currentTimeMillis()

getInstance()

add()

new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

format()

parse()

arrayCopy

currentTimeMillis

exit(0)

gc()

System.in

System.out

1、数组长度固定，集合长度不固定。

2、数组可以存储基本数据类型和引用数据类型，集合只能存储引用数据类型。

由于JDK5.0后有自动装箱拆箱，所以向集合中添加基本数据类型也是正确的，本质上是将其自动装箱，变成了包装类的对象。

Collection是一个集合的顶层接口。定义了存储多个对象的集合，具备有基本的增删改查等方法。

add、addAll、clear、remove、contains、size、isEmpty、toArray

Collections类是集合的工具类，提供了集合的一些操作，例如：排序，反序，打乱等。

// 将数组转换成集合
  List list = Arrays.asList(1,2,3,4,5,6,7,8,9);

// 随机打乱元素顺序
  Collections.shuffle(list);

// 排序
  Collections.sort(list);

// 反序
  Collections.reverse(list);

List子接口继承自Collection接口，具备有Collection接口的特点。
而且自身具备有序、有下标、元素可重复等特点。

get(index)、add(index, object)

特点

方法

特点

方法

Vector与ArrayList基本实现方式一致，只是大部分方法前面加上了synchronized关键字，
表示加锁，实现线程安全，性能极低，基本不使用。

特点是无序、无下标，元素不可重复。

底层使用HashMap，HashSet中添加的元素直接放到HashMap的key上，
所以元素不能重复（map的key不能重复），无序，无下标。

方法

使用了链表的HashSet，是有序的

LinkedHashSet底层是继承了HashSet，使用了HashSet中创建了LinkedHashMap的构造方法。
LinkedHashMap相对于HashMap仅仅是多添加了一个链表，用来记录添加元素的顺序。

TreeSet实现了排序功能

Comparable接口

Map接口采用键值对（key-value）的方式存储数据

key不能重复，value可以重复，如果key重复，value会覆盖。

put(key, value); // 设置值

get(key); // 获取值

keySet(); // 获得所有的key

values(); // 获得所有的value

entrySet(); // 遍历时使用的entry（键值对）的集合

Hashtable代码与HashMap基本一样，只是大部分方法前面加上了synchronized关键字，
表示加锁，线程安全，但是性能很低，基本不使用。

继承了Hashtable，添加了对资源文件操作的内容，一般用来在系统初始化时加载资源文件。

方法

特点

Comparable接口

Throwable是所有的异常的顶级父类。

Error

Exception

throws

throw

注意

try

catch

finally

通常是在项目中要抛出一个业务异常时，需要一个异常类来描述该业务。

需继承自Exception即可

一般情况下，一个应用程序在运行的时候会有一个进程。

线程是轻量级的进程，一个进程中可以有多个线程，同一个进程的线程之间可以共享数据。

方法

start方法和run方法的区别

继承Thread类和实现Runnable接口的区别

new（创建）

start（就绪）

running（运行）

terminate（终止）

sleep方法

yield方法

join方法

等待状态：可能都会造成线程的阻塞

sleep：让当前线程进入休眠状态，需要满足休眠时间结束才会继续进入就绪状态。

wait：让当前线程进入等待状态，需要等待被其他线程唤醒才会进入就绪状态。

yield：让当前线程从运行状态进入到就绪状态。

join：让当前线程暂停，让其他线程先行。

阻塞状态：线程同步时，没有抢到锁，被迫进入了阻塞状态。

导致线程不安全的原因

同步锁机制

wait

notify

notifyAll

注意

经典面试题

当多个线程在处理共享资源，使用锁时，如果出现同时都持有一把锁，
并且需要另一把锁才能继续执行，没有另一把锁，绝不会释放当前锁时，
就会出现死锁。

1、创建型模式，用来创建对象的（5种）。
例如：单例模式、原型模式、工厂模式

2、结构型模式，针对于多个对象之间组成一种新的结构（7种）。
例如：桥接模式、门面模式、适配器模式

3、行为型模式，多个对象之间产生行为处理的方式（11种）。
例如：调停者模式、命令模式、监听者模式、迭代模式

stop()[已废弃，不推荐]

Interrupt()

当一个线程一直抢不到时间片来执行，称为线程饿死。

守护线程是一个特殊的线程，当其他的线程都执行完毕后，守护线程也会终止。

创建线程池

submit()

shutdown()

Callable接口的返回值并不是立即就能得到的，需要线程任务执行完毕，
所以会返回一个Future接口的对象，通过该对象的get方法才能获取结果

Callable接口与Runnable接口作用相似，都可以作为线程池的任务，
但是Runnable接口没有返回值，
当需要获取返回值时就需要使用Callable接口。

Lock接口是jdk5添加的功能

对比synchronized

lock()加锁

unlock()解锁

tryLock()尝试获取锁

private static ReentrantLock lock = new ReentrantLock();

当有一个线程在写时，会互斥，当所有的线程都在读时，不互斥，共享读取，以在保障线程安全的前提下提升性能。

用于读多写少的任务

// 使用读写锁
 private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 private ReadLock readLock = lock.readLock();
 private WriteLock writeLock = lock.writeLock();

1、可见性。多线程访问共享变量时，如果一个线程对其进行修改，其他的线程能够立即发现改变后的值。

2、互斥性。多线程访问共享变量时，如果一个线程对其进行操作（读写），其他线程都会等待其操作结束。

private volatile String name1 = "a";

加强版的读写锁实现，可以读写分离。

写有锁，读无锁，每次写的时候都会复制一个副本，写入后替换原来的地址。

底层以CopyOnWriteArrayList实现，就是添加时使用的addIfAbsent()会遍历集合，
如果已经存在该元素，则抛弃该副本，不存在则添加。

JDK1.8之前，默认将其分为16段（segment），对每一段进行加锁，
理论上来说，如果有16个元素，分别放到16段里，那么基本没锁。

JDK1.8之后，采用的CAS机制，即只对当前添加的对象加锁，通过CAS交换算法来修改数据。

队列，先进先出，FIFO原则，First In First Out

性能最好的线程安全的队列。采用CAS交换原则。

增加了两个无限期等待的方法。

主要用来实现生产消费模式。

有界队列，使用数组实现，事先在构造时先确定队列空间大小。

无界队列，使用链表实现。