java基础

byte & Byte

char & Character

short & Short

int & Integer

long & Long

float & Float

double & Double

boolean & Boolean

String

数组

类变量（static修饰）

全局/成员变量

局部/临时变量

注：局部变量优先级最高，其它跟局部同名都以局部的为准，但可以用 this来调全局的

隐式转换：位数小的自动转为位数大的

强制转换

public

protected

private

default

算术

关系

逻辑

位

赋值

条件

if-else

for & break & continue

while/do-while

switch-case

简介：隐藏信息和实现细节

简介：子类继承父类，使其拥有父类的实例域与方法

重写

重载

简介：同一个接口，使用不同的实例而执行不同操作

条件

概念

Serializable & SerializableID

ObjectOutputStream & ObjectInputStream

Transient：阻止序列化该字段

注：序列化不保存静态变量

实现 Cloneable接口并覆盖 clone()方法，对象o1.clone()

程度

两种实现

重写 equals规则

throwable

处理

常见异常

1、子类不可抛出比父类更大的异常（比如父类抛 RuntimeException， 子类不能抛 Exception）

2、子类不能抛出比父类更多不同分类的异常（比如 RuntimeException 和 IOException就属于两大类），但似乎 RuntimeException不受限于这个，就是父类抛 IOException，子类还是可以抛 RuntimeException及下级的，不过父类抛 RuntimeException ，则子类容不得 IOException 及以下的

静态代码块：类中static修饰

构造代码块：类中

普通代码块：方法中

1、执行父类的静态代码块，并初始化父类静态成员变量

2、执行子类的静态代码块，并初始化子类静态成员变量

3、执行父类的构造代码块，执行父类的构造函数，并初始化父类普通成员变量

4、执行子类的构造代码块， 执行子类的构造函数，并初始化子类普通成员变量

注：静态代码块/变量>构造代码块>构造函数>普通成员变量，越顶层父类越快初始化

类型

特点

元注解

标准注解

自定义注解

反射获取注解

位置

类型

该变量值不可变

该方法不可被重写

不可被继承

作用域是类级别的，内存只有一份

同变量，且在方法中不可使用非静态的变量和方法；另外不能用 this和super（因为不是对象的）

不能被new，只能被继承

不需要实现即不需要方法体，等着被重写

构造方法才能 super() 父类的构造方法，且必须放第一行

super.XX() 父类的普通方法/变量

构造方法才能 this() 构造方法，且必须放第一行

this.XX() 其它方法/变量（父类和自己）

重写equals()方法必须重写hashCode()

字节

字符

字节流

字符流

转换流

对象流

打印流

注：缓冲、转换、对象流、打印流 其实都得基于字节/字符流 之上

List

Set

Queue

HashMap

Hashtable

TreeMap

Collection

Map

/** 集合，泛型，List、Set、Map **/
/** List，ArrayList、LinkedList、Vector**/
/** Set，HashSet、TreeSet、LinkHashSet **/
/** Map，HashMap、ConcurrentHashMap、HashTable、TreeMap、LinkHashMap **/
List<Object> arrayList = new ArrayList<>();//数组存储，查快
List<Object> linkedList = new LinkedList<>();//链表，增删快
List<Object> vector = new Vector<>();//同步的（每次只有一个线程能操作），线程安全

Set<Object> hashSet = new HashSet<>();//哈希表，存储顺序不是按存入的顺序，而是按照 hash值，先比较 hashcode然后比较 equals，所以自定义对象需要重写这些才能进行对比，相同hashcode的存同列
Set<Object> treeSet = new TreeSet<>();//二叉树，自动将对象排序，所以自定义对象需要重写 Comparable的 compareTo方法
Set<Object> linkedHashSet = new LinkedHashSet<>();//继承自 HashSet，操作与其相同，底层用的 LinkedHashMap来保存元素

Map<Object, Object> hashMap = new HashMap<>();//根据 hashcode值存储数据，数组存储，相同 hashcode的元素则利用链表存在相同位置，java8中如果相同 hashcode元素超8个，则不用链表而用红黑树
Map<Object, Object> treeMap = new TreeMap<>();//默认按键升序排，也可指定排序器，所以 key必须实现 Comparable接口或者在 new时传入 排序器
Map<Object, Object> linkedHashMap = new LinkedHashMap<>();//继承自 HashMap，按照插入顺序来存储
Map<Object, Object> concurrentHashMap = new ConcurrentHashMap<>();//默认分16段锁，这样可以更好支持安全的并发
Map<Object, Object> hashtable = new Hashtable<>();//同步的，跟 Vector一样，只有一个线程能同时操作，线程安全

a.getClass()

<ClassName>.class

Class.forName("<ClassPath>")

<clazz>.newInstance()：实例化对象

注：它是构造函数、字段、方法获取的句柄

getConstructors()：获取 public的构造器列表

getDeclaredConstructors()：获取所有的构造器列表

getConstructor(Class<?>... parameterTypes)：获取 public的指定构造器，传入参数类型如 String.class

getDeclaredConstructor(Class<?>... parameterTypes)：获取指定构造器（不限制public），传入参数类型如 String.class

<constructor>.newInstance(Object... initargs )：根据某一构造器实例化对象

getFields()：获取 public的字段列表

getDeclaredFields()：获取所有的字段列表

getField(String name)：获取 public的指定字段，传入字段名称如 age

getDeclaredField(String name)：获取指定字段（不限制public），传入字段名称如 age

<field>.setAccessible(true)
<field>.get(Object obj)：前面先设置一下权限，然后获取字段值，需要传入执行的对象
<field>.get(Object obj, Object value)：设置指定对象的属性值

getMethods()：获取 public的方法列表

getDeclaredMethods()：获取所有的方法列表

getMethod(String name, Class<?>... parameterTypes)：获取 public的指定方法，传入方法名、参数类型如 (insert,String.class)

getDeclaredMethod(String name, Class<?>... parameterTypes)：获取指定方法（不限制public），传入方法名、参数类型如 (insert,String.class)

<method>.setAccessible(true)
<method>.invoke(Object obj, Object... args)：前面先设置一下权限，然后执行对应方法，传入执行的对象，参数对应上方法参数(静态方法 obj为null)

new Object()

class.newInstance() / constructor.newInstance()

object.clone()

Serializable 对象(ObjectInputStream)

Socket

ServerSocket

DatagramSocket

DataGramPacket

一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口，@FunctionalInterface

(parameters) ->{ statements; }
需满足函数式接口才可以

.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

new Random().ints().limit(10).forEach(System.out::println);

.stream().map( i -> i*i).distinct().collect(Collectors.toList());

new Random().ints().limit(10).sorted().forEach(System.out::println);

LocalDate date1 = currentTime.toLocalDate();

LocalDateTime currentTime = LocalDateTime.now();

ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");

Optional.ofNullable(value)：允许传递为 null 参数

Optional.of(value)：如果传递的参数是 null，抛出异常 NullPointerException

.isPresent()：判断值是否存在

.orElse(value)：如果值存在，返回它，否则返回默认值

.get()：获取值，值需要存在

抽象类有

接口没有

抽象类可有普通方法和抽象方法

接口只能是抽象方法（java8已经可以有default方法）

抽象类可有普通变量和final变量

接口都是 final变量

抽象类适合所有子类都要做的场景

接口适合部分子类要完成