首页  思维导图  详情

java基础

2022-03-28 18:55:13   4  举报





AI智能生成

java基础

java

基础

知识

开发

作者其他创作

大纲/内容

基本

java分类

J2ME：mobile

J2SE：swing，桌面

J2EE：web

面向对象三大特性

继承

封装

多态

变量 & 访问

基本数据类型 & 包装

byte & Byte

char & Character

short & Short

int & Integer

long & Long

float & Float

double & Double

boolean & Boolean

引用类型

String

数组

一维

二维

作用域

类变量（static修饰）

全局/成员变量

局部/临时变量

非形参局部变量必须自己初始化

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

数据类型转换

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

强制转换

访问权限

public

protected

private

default

运算

运算符

算术

+、-、*、/、%、++、--

关系

==、!=、>、<

逻辑

&&、| |、！

位

＆、|、^、~、<<、>>、>>>

赋值

=、+=、-=、/=、(%)=、<<=、>>=、&=、^=、|=

条件

? : 、instanceof

流程控制

if-else

for & break & continue

while/do-while

switch-case

位运算

关键思想

封装

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

继承 & 接口

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

重写 & 重载

重写

简介：子类重写父类的方法（需子类有权限访问）

规则：方法名、返回值、形参个数/类型/顺序都不能变，抛出异常也不能比父类大，但访问权限却不能比父类小

重载

简介：同个类相同方法名但参数列表不同

规则：跟返回值无关，形参个数/类型/顺序不同

多态

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

条件

继承

重写

父类指向子类对象

依托 Object

序列化 & 反序列化 Serializable

概念

序列化：对象转成字节序列的过程

反序列化：字节序列转成对象的过程

Serializable & SerializableID

ObjectOutputStream & ObjectInputStream

Transient：阻止序列化该字段

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

克隆 Clone

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

程度

浅拷贝

只克隆第一层

深拷贝

手动复制所有层

序列化实现

fastjson转换

比较/排序

两种实现

1、比较的对象实现Comparable接口，重写 compareTo(T o) 方法，这是对象自己调用别人进行比较

2、比较器类实现Comparator接口，重写 compare(T o1, T o2) 方法，这是比较器传入两个对象进行比较

相等

重写 equals规则

自反

对称

传递

一致

异常 & 日志 & 断言 & 调试

异常

throwable

Exception

RuntimeException

NullPointException

ArrayIndexOutOfBoundsException

CheckedException

IOException

SQLException

ClassNotFoundException

......

Error

处理

try & catch & finally

代码中捕获

throw

代码中手动丢出异常

throws

用在方法上，声明将抛出异常

常见异常

ArithmeticException（算术异常）

ClassCastException （类转换异常）

IllegalArgumentException （非法参数异常）

IndexOutOfBoundsException （下标越界异常）

NullPointerException （空指针异常）

注：

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

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

结构 & 特殊类 & 注解

构造器

代码块

静态代码块：类中static修饰

构造代码块：类中

普通代码块：方法中

初始化顺序

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

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

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

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

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

枚举类 Enum

内部类

类型

静态内部类

成员内部类

局部内部类（方法中）

匿名内部类：new 了一个匿名类的对象,因为这是一个接口，所以要实现抽象方法，其实相当于这个类实现了这个接口，这个类没有名字，所以只能在这使用一次

特点

非静态内部类可以访问外部所有成员变量（包括private）

外部访问内部则需要通过内部类对象（静态属性除外）

局部内部类访问外部的局部变量，则变量得是 final

注解

元注解

@Target：注解修饰的范围，从包到方法到参数

@Retention：保留时间，SOURCE、CLASS、RUNTIME

@Documented

@Inherited：表示注解对被标注的类的子类起效

标准注解

@Override

@Deprecated

@SuppressWarnings

自定义注解

反射获取注解

<target>.getAnnotation(Class<T> annotationClass) ：返回指定类型的注解，基于反射中的句柄(如 field.getAnnotation(Excel.class))

<target>.getDeclaredAnnotations() ：返回元素上的所有注解

<target>.isAnnotationPresent(Class<? extends Annotation> annotationClass)：判断是否存在注解

？？？？？？泛型

位置

泛型类

泛型方法

类型

<E>

<T>

<?>

<? extends T>：表示它是 T的子类

<? super T>：表示它是 T的父类

关键字

final

变量

该变量值不可变

方法

该方法不可被重写

类

不可被继承

static

变量

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

方法

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

内部类

代码块

注：内部类的方法则不行

abstract

类

不能被new，只能被继承

方法

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

注：抽象方法需要在抽象类中，但抽象类可以有普通方法；与 final & static & private 都不能共用

interface

super

构造方法

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

其它方法/变量

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

this

构造方法

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

其它方法/变量

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

switch

String（java7）

volatile

synchronized

Object

toString()

equal()

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

hashCode()

clone()

getClass()

package & import

实践

子主题

进阶

File

字节

FileInputStream

FileOutputStream

字符

FileReader

FileWriter

IO流

字节流

普通

InputStream

OutputStream

缓冲

BufferedInputStream

BufferedOutputStream

字符流

普通

Reader

Writer

缓冲

BufferedReader

BufferedWriter

转换流

InputStreamReader

OutputStreamWriter

对象流

ObjectInputStream

ObjectOutputStream

打印流

PrintWriter

PrintStream

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

集合

Collection

List

ArrayList

底层用数组，有序、可重复

查快，增删慢

线程不安全

LinkedList

底层用双向链表，有序、可重复

查慢，增删快

线程不安全

Vector

底层用数组，有序、可重复

查快，增删慢

线程安全，效率低

Set

HashSet

底层用hash表，其实是 HashMap，无序、不可重复

存取都快

线程不安全

TreeSet

底层用二叉树/红黑树，按比较器规则排序、不可重复

排序存储

线程不安全

LinkedHashSet

链表，按插入顺序排序

Queue

Map

HashMap

底层是 hash表，key不可重复

线程不安全

key、value都可为null

Hashtable

底层 hash表，key不可重复

线程安全，效率低，因为方法都有 synchronized

key、value都不可为null

TreeMap

底层二叉树，key可重复

concurrent

Collection

List

CopyOnWriteArrayList

Set

CopyOnWriteArraySet

Queue

BlockingQueue

LinkedBlockingQueue

ArrayBlockingQueue

ConcurrentLinkedQueue

Map

ConcurrentHashMap

备

/** 集合，泛型，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一样，只有一个线程能同时操作，线程安全

反射

简介：在运行期获取类的所有构造器、属性和方法，并能对其进行操作

获取Class

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)

多线程 & 并发

看并发编程栏目

网络编程

TCP

Socket

ServerSocket

UDP

DatagramSocket

DataGramPacket

正则表达式

静态/动态代理

切面

API & SPI

Java 8 新特性

函数式接口

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

Lambda 表达式

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

Stream API

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

filter 方法用于通过设置的条件过滤出元素

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

limit 方法用于获取指定数量的流，'forEach' 来迭代流中的每个数据

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

map 方法用于映射每个元素到对应的结果

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

sorted 方法用于对流进行排序

方法引用

接口默认方法

新日期时间 API

LocalDate date1 = currentTime.toLocalDate();

LocalDateTime currentTime = LocalDateTime.now();

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

Optional 类

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

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

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

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

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

Java 9 新特性

常用类

Number & Math

String & StringBuffer & StringBuilder

Date & Calendar

System & Scanner

Arrays & Collections

SimpleDateFormat

关键问题

集合都是怎么实现的，比如 hashmap?

对象和类？

abstract & interface?

构造方法

抽象类有

接口没有

成员方法

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

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

成员变量

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

接口都是 final变量

使用场景

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

接口适合部分子类要完成

值传递 & 引用传递？

finally & return？

finally语句在return执行之后，return返回之前执行； try语句中有System.exit()，finally不会执行

进制转换？

final、finally、finalize?

重写 equals()方法时，为什么必须重写 hashcode()？

Object 默认 hashcode是根据内存地址计算，不会相同，但是如果自己重写则可能相同

对象相等 hashcode一样；hashcode一样，对象不一定相等（java定的规则）

散列表同时运用了数组和链表，重写hashcode方法为了将数据存入Java集合类时进行比较，集合先根据 hashcode方法判断，如果不同就认为不等，若相同再判断 equals，不同则认为不等（1、先判断 hashcode是为了效率快。2、如果只重写 equals不重写 hashcode，则可能出现内容相同但判断了 hashcode不同，结果都能放到 hashset里面，就不符合 set的规则）

https://blog.csdn.net/javazejian/article/details/51348320

Set如何实现不重复？

hashcode 就应遇而生了，java 就采用了 hash 表，利用哈希算法（也叫散列算法），就是将对象数据根据该对象的特征使用特定的算法将其定义到一个地址上，那么在后面定义进来的数据只要看对应的 hashcode 地址上是否有值，那么就用equals 比较，如果没有则直接插入，这样就大大减少了 equals 的使用次数，执行效率就大大提高了

java序列化为什么慢？

每次都要经过 ClassLoader，并且它在反序列中是热加载

实践

子主题

子主题