java基础思维导图

U134379384

2023-05-14

浏览量: 61

java基础

计算机

技术开发

java基础

树图思维导图提供《java基础》在线思维导图免费制作，点击“编辑”按钮，可对《java基础》进行在线思维导图编辑，本思维导图属于思维导图模板主题，文件编号是：2d662d354a5d53ae5e6869d7c4ba2984

思维导图大纲

类与对象

对象内存机制

方法内存机制

方法会开辟一个新空间

成员方法传参机制

1.基本数据类型

基本数据类型，传递的是值（值拷贝），形参的任何改变不影响实参！

2.引用类型

引用类型数据，传递的是地址，可以通过形参影响实参

方法递归

递归执行机制

先开栈，递给完再依次放回，先进后出

阶乘

作用域

区别

全局变量

1.作用域整个类体

2.有默认值，可以不赋值使用

局部变量

1.作用域在方法块

2.没有默认值，必须赋值才能使用

细节

属性和局部变量可以重名，访问遵循就近原则

属性随着对象创建而创建，局部变量随着代码块的结束而销毁，方法执行完就销毁

局部变量不可以加修饰符

构造器

完成对象的初始化

注意

无返回值

没有定义构造器，默认无参构造器

对象创建流程分析

p是对象引用

面向对象-封装

1.属性私有化

2.公共set方法，对属性判断并赋值

3.公共get方法，获取属性

面向对象-继承

代码复用性、维护性提高

含义

子类拥有父类的属性和方法

父类又叫超类，基类

子类又叫派生类

注意

1.父类非私有属性和方法可以在子类直接访问，私有属性方法要通过父类提高公共方法访问

2.子类必须调用父类构造器（super()默认调用父类无参构造器），完成父类的初始化

3.父类没有无参构造器，子类必须在构造器指定使用父类哪个构造器

4.显示调用父类构造器，super(参数)

5.默认调用super()父类无参构造器，必须放在子类构造器第一行

6.super()和this()必须放在第一行，俩不能共存

7.Object是所有类的基类

单继承

继承的本质

super

1.访问父类非私有属性

2.访问父类非私有方法

3.访问父类构造器super(参数)，第一行

this和super比较

方法重写

子类的一个方法的方法名，返回类型，参数和父类方法一样

父类返回类型object,子类返回类型是object子类

重载与重写区别

面向对象-多态

方法或对象具有多种形态，是oop的三大特征，是建立在封装个继承的基础上

方法或对象有多种形态

重载、重写

对象的多态

1.一个对象的编译类型和运行类型可以不一致

2.编译类型在定义对象时，就确定，不能改变

3.运行类型可以变化，通过getClass获取运行类型

4.编译类型看定义 =号的左边，运行类型 =号的右边

父类的引用指向子类对象 --向上转型

多态细节和注意

前提：继承关系

对象多态

向上转型

父类的引用指向子类对象

含义

1.可以调用父类的所有成员(访问权限)

2.不能调用子类特有成员

3.在编译阶段，能调用哪些成员，由编译类型来决定 javac

4.最终运行效果由子类具体实现子类-->父类 java

向下转型

子类类型引用名 =（子类类型）父类引用

含义

1.只能强转父类的引用

2.父类的引用必须指向的是当前目标类型的对象

3.当向下转型后，可以调用子类类型所有的成员

细节

属性看编译类型

instanceOf比较操作符，判断对象的运行类型是否XX类型或XX类子类型

子主题 4

动态绑定机制

当调用对象方法时，该方法会和该对象内存地址/运行类型绑定

当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用

多态应用

多态数组

子主题 2

Object方法

== 和 equals

==判断基本数据类型是值，引用类型是地址

equals只能判断引用类型，默认判断地址，子类重写该方法，则判断内容是否相等

子主题 3

hashcode

小结

1.提高具有哈希结构容器

2.两个引用，如果指向同一对象，hash值一定一样

3.两个引用，如果指向不同一对象，hash值不一样

4.哈希值主要根据地址号来的

5.在集合，重写hash

toString

默认返回：全类名+@+哈希值十六进制，但子类往往重写tosSting方法，返回对象的属性消息

重写tosSting方法，返回对象的属性消息

输出对象，默认调用toString

finalize

1.当对象回收时，系统自动调用该对象的finalize。子类往往重写该方法，来释放资源。

回收时间：对象没有如何引用，则jvm认为这个对象是一个垃圾对象。就使用垃圾回收机制来销毁该对象，销毁该对象前，会先调用finalize方法

垃圾回收机制调用，由系统来决定(gc算法)

java高级

类(静态)变量和类方法

类变量

类变量内存分析

static变量是同一类所有对象共享，类变量在类加载而创建，没有创建实例对象也可以访问

类变量是该类的所有对象共享的，而实例变量是每一个对象独有

类方法

类方法和普通方法都是随着类加载而加载，将结构信息存在方法区。类方法无this

类名.类方法

main方法

1.main方法是java虚拟机调用

2.不需创建对象，该方法是static

3.该方法接收Sing类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数

java执行程序参数1，2，

代码块

只有方法体的方法[修饰符(static)]{}

加载类或创建对象时隐式创建

好处

类似构造器，可以初始化操作

如果多个构造器有重复语句，可以抽取到初始化块，提高代码重用性。先调用代码块再构造器。

使用注意事项

static代码块，对类进行初始化，随着类的加载而执行，只执行一次。普通代码块，每创建一个对象，就执行一次

类什么时候被加载

1.创建对象实例时

2.创建子类实例时，父类也会被加载

3.使用类的静态成员时

普通代码块

普通代码块，每创建一个对象，就执行一次

使用静态代码块，普通代码块不执行

创建对象，一个类调用顺序

1.调用静态代码块和静态属性初始化(优先级一样，按顺序)

2.调用普通代码块和普通属性(优先级一样，按顺序)

3.调用构造方法

构造器最前面隐含了super()和普通代码块

继承关系，静态代码，静态属性初始化，普通代码块，普通属性初始化，构造方法调用顺序

1.父类静态代码块和静态属性

2.子类静态代码块和静态属性

3.父类普通代码块和普通属性初始化

4.父类构造方法

5.子类普通代码块和普通属性初始化

6.子类构造方法

静态代码块只能调用普通成员，普通代码块可以调用容易成员

单例设计模式

对某个类只能存在一个对象实例，对外提供静态公共方法

类型

1.饿汉式

1.构造器私有化

2.在类的内部直接创建对象(对象是static)

3.提供公共static方法，返回对象

类加载时就创建对象，可能造成创建了对象没使用，不存在线程安全

2.懒汉式

1.构造器私有

2.先判断对象是否为null，再创建对象

在使用时创建对象，存在线程安全

final关键字

使用

1.类不能被继承

2.父类的方法不能被子类重写

3.类的属性不能被修改

4.局部变量不能被修改

细节

1.final修饰的属性叫常量，用XX_XX来命名

2.修饰的属性在定义必须赋值

定义时 public final double TAX_RATE=0.08

在构造器

在代码块中

3.修饰的属性时静态，初始化的位置只能时定义时，静态代码块

4.final类不能继承，但可以实例化对象

5.不是final类，含有final方法，该方法不能重写，但可以被继承

6.final不能修饰构造方法

7.final和static搭配使用，效率更高，不会导致类加载，底层编译器做了优化

8.包装类都是final类，不能被继承

抽象类

父类一些方法不确定，可以使用abstract关键字来修饰，抽象方法没有方法体

抽象类细节

1.抽象类不能被实例化

2.可以没有abstartct方法，可以有实现方法(方法体)

3.一旦类包含abstract方法，则类必须声明abstract

4.abstract只能修饰类和方法

5.抽象类可以有容易成员

6.一个类继承了抽象类，必须实现抽象类的私有抽象方法，除非它也声明abstract类

7.抽象方法，不能有方法体（既不能实现）

8.抽象方法不能使用private、final、static来修饰，与重写相违背

抽象模板模式

将共用属性整成抽象方法

抽象类

子类

接口

给出一些没有实现的方法，封装到一起。类使用时实现接口方法。

interface 接口名

属性

方法（抽象，默认实现，静态）

细节

1.接口不能被实例化

2.接口所有方法是public,接口中抽象方法，可以不用abstract修饰

3.普通子类实现接口必须实现所有方法

4.抽象类实现接口，可以不用实现的方法

5.多实现

6.接口中属性，只能是final,而且是 public static final修饰

7.接口属性访问形式：接口名.属性

8.接口不能继承其他的类，但可以继承多个接口

接口 vs 继承

继承是单继承，接口可以多实现

实现接口时对java单继承机制的补充

继承主要时解决代码复用性和维护性

接口，设计各种规范（方法），让类去实现，接口在一定程度上实现解耦

接口多态性

多态参数：接口的引用可以指向实现了接口的类的对象

多态数组：数组中，仔放Phone和相机对象，Phone类还有一个特有的方法call（）,遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用Phone特有方法call.

接口存在多态传递现象

四种内部类

定义在外部类局部位置上（比如方法内）

1)局部内部类（有类名）

1.可以直接访问外部类的所有成员，包含私有

2.不能添加访问修饰符，但是可以使用final修饰

3.作用域：在定义它的方法或代码块中

4.可以直接访问外部类的成员

6.外部类在方法中，创建内部类对象，然后调用该方法

内部类在外部类方法内创建

7.外部其他类--不能访问--局部内部类

8.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问

2)匿名内部类(没有类名，重点)

本质是类，内部类，该类没有名字，同时还是个对象

基本语法

new 类或接口(参数列表){ 类体}

使用

1.基于接口使用

匿名内部类，不用创建类实现接口，直接使用

2.基于类

重写方法

细节

1.既有类的特征也有对象的特征

2.可以访问外部类外部类的所有成员

3.不能添加访问修饰符

4.作用域仅在定义它的方法或代码块

5.外部其他类--不能访问--匿名内部类

6.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问

匿名内部类实践

当作实参直接传递

定义在外部类的成员位置上

3)成员内部类(没用static修饰)

1.可以直接访问外部类所有成员

2.可以添加任意修饰符

3.作用域：在整个类体

4.外部类--访问--成员内部类，在外部类方法创建成员内部类对象，再调用其属性和方法

6.6.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问

4)静态内部类

有static修饰

可以访问外部类的静态成员

可以有修饰符

作用域：整个类体

静态内部类--访问--外部类：直接访问静态属性

外部类--访问--静态内部类，在外部类方法创建成员内部类对象，再调用其属性和方法

外部其他类--访问---静态内部类

new 外部类对象.静态内部类

在外部类编写方法，返回静态内部类对象

6.6.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问

子主题 9

子主题 10

枚举和注解

枚举

把具体的对象一个个列举出来的类，是一组常量集合，里面包含一组限定特定的对象。

1.自定义实现枚举

1.构造器私有化，防止直接new

2.去掉setXX方法，防止属性被修改

3.在Season内部，直接创建固定的对象

4.加入final修饰符，避免Season被加载

代码

2.使用enum关键字

1.使用关键字代替class，final

2.常量命（实参列表）

3.如果有多个枚举静态常量（对象）,号隔开，最后；结尾

必须知道它调用哪个构造器，枚举对象必须放在首行

无参构造器可以省略（）

代码

使用enum关键字，隐式继承Enum类，所以不能继承其他类，可以实现接口

Enum成员方法

代码

注解

@Overrride 重写父类方法

@Deprecated 过时

@SuppressWarnings 抑制编译器警告

元注解

1)Retention 指定注解的作用范围，三种SOURCE,CLASS,RUNTIME

2)Target 指定注解可以在哪些地方使用

3)Documented 指定该注解是否会在javadoc体现

4)Inherited 子类会继承父类注解

子主题 3

子主题 4

Exception

异常分两类

1.Error

Java虚拟机无法解决的严重问题，如JVM系统内部错误、stackOverflowError

2.Exception

因编译错误或偶然外在因素导致的一般性问题

1.编译时异常

编译期间，就必须处理的异常，否则代码不通过

1.IOException/操作文件时，发生的异常

2.FileNotFoundException/当操作一个不存在的文件时，发生异常

3.SQLException/操作数据库时，查询表可能发生异常

4.ClassNotFoundException/加载类，而该类不存在时，异常

5.EOFException/操作文件，到文件末尾，发生异常

6.IllegalArguementException/参数异常

2.运行时异常

1)NullPointerException空指针异常

2)ArithmeticException数学运算异常

3)ArrayIndexOutOfBoundsException数组下标越界异常

4)ClassCastException类型转换异常

5)NumberFormatException数字格式不正确异常

异常体系图

异常处理

对异常处理的方式

1.try-catch-finally 捕获发生的异常，自行处理

处理机制图

finally优先处理

2.throws 将异常抛出，交给调用者(方法)来处理，最顶级处理JVM

处理机制

throws细节

1.编译异常必须处理，t-c-f,throws

2.运行异常，没有处理，默认throws方式

3.子类抛出异常要和和父类抛出异常一致，要么为父类抛出异常的子类

子主题 4

子主题 5

自定义异常

一般继承RuntimeException

代码

throw和throws对比

异常体系

常用类

包装类

八大wrapper类

自动装箱和拆箱

装箱：基本数据类型-->包装类型

拆箱：包装类型--->基本数据类型

代码

包装类和String转换

Interger类和Charter常用方法

例题

1.Integer

只要是和基本类型判断，判断的是值是否相同

字符串是不可变

小结：底层是StringBuilder sb=new StringBuilder（）;sb.append(a)； sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的。

String

概念

String对象用于保存字符串

String是final类，不能被其他类继承

String有属性 private final char value[] 存放字符串内容（value地址不能指向新地址）

serializalbe:串行化，可以在网络传输

创建String对象两种方式

直接赋值 String s="12"

调用构造器 String s=new String("1")

String的内存布局

String类常用方法

子主题 2

format

StringBuffer

概念

1.直接父类是AbstractStringBuilder

2.实现Serializable,可串行化

3.AbstractStringBuilder,有属性char[]value,保存字符串变量，存放在堆中

4.是final类，不能被继承。

5.因为Stringbuffer字符内容存在 char[] value，所以变化，不是每次更换地址

7.线程安全

StringBuilder String对比

1.String保存的是字符串常量，里面值不能改变，每次String类修改的是地址，效率低。

2.StringBuffer保存的是字符串变量，可变序列，效率较高(增删)、线程安全。

3.StringBuilder可变序列、效率最高，线程不安全

总结

StringBuffe代表可变的字符序列，可以字符内容进行增删，是可变长度，是一个容器

StringBuffer转换

代码与String互转换

StringBuffer常见方法

1)增append

2)删delete[start,end）

3)改replace(start,end,string)将[start--end)间的内容替换掉，不含end

4)查indexOf 查找子串在字符串第1次出现的索引，如果找不到返回-1

5)插insert

6)获取长度length

例题

价格3,456,789.88要求：价格的小数点前面每三位用逗号隔开，在输出

StringBuilder

概念

继承关系

是可变序列，final类，不能继承

对象字符序列，存在其父类AbstarctStringBuilder的 char[] value,存在堆在

线程不安全，在单线程下使用

BigInteger和BigDecimal类

BigInteger

当需要很大的整数，long不够用时，可以使用BigInteger类来搞定

（1）.在对BigInteger 进行加减乘除时，需要使用对应的方法

（2）.可以创建一个要操作的BigInteger 然后进行操作

代码

bigDecimal

当我们需要保存精度很高的数时，double不够，可以使用BigDecimal类

代码

子主题 3

子主题 4

Math

random随机数理解获取a-b之间随机整数（int）(Math.random()*(b-a+1)+a)

abs 绝对值

pow 求幂

ceil向上取整 >=该参数的最小整数

floor向下取整<=该参数的最小整数

round 四舍五入

sqrt 求开方

random [0,1)

max min 最大值和最小值

代码

Arrays

1toString：直接显示数组

2.sort: 数组排序（默认排序和定制排序）

3.binarySearch: 通过二分搜素法进行查询（返回的是数组数下标）

（1）.要求该数组是有序的，如果该数组无序的，则不能使用binarySearch

（2）.如果数组中不存在该元素，就返回return -（low+1),离它最近的值后边下标+1。

4.copyOf: 数组元素复制

5.ill: 数组元素的填充

6.equals: 比较两组元素内容是否完全一致

7.asList 将一组值，转换成List集合

代码

System

1. exit:退出当前程序

（1）exit(0)表示程序退出

（2）0表示一个状态，正常的状态

2.arraycopy:复制数组元素，比较适用底层调用

3.currentTimeMillis:返回当前时间距离1970-1-1的毫秒数

4.运行垃圾回收机制 System.gc

代码

日期类

第一日期类--Date

1.获取当前系统时间默认国外时间需格式化转换

2.通过相应的毫秒数得到时间

3.SimpleDateFormat 时间格式转换

4.把一个格式化的String 转换成对应的 Date

代码

第二日期类--Calende

1.Calender是抽象类，并且构造器私有

2.可以通过getInstance() 来获取实例

3.提供大量的字段和方法

4.没有提供相应的格式化的类

代码

第三日期类--LocalDate、LocalTime、LocalDateTime

前面两代日期类存在的不足分析

1.LocalDate(日期/年月日)

2.LocalTime(时间/时分秒)

3.LocalDateTime(日期时间/年月日时分秒) JDK8加入 (1).使用now() 返回当前日期时间的对象

代码

DateTimeFormatter 格式化日期

本章节作业

1.String反转

2.注册校验

3.Han Sun Ping 以Ping,Han .S的形式打印

4.输入字符串，判断里面有多少个大写字母，小写字母，数字

String内存布局

子主题 6

子主题 7

集合

Collection

List

实现类

ArrayList

概念

1.可以加入多个null,底层是可变数组实现

2.线程不安全（效率搞）

底层源码

1.数据存入 object 类型的数组elementData

2)如果是无参构造器，第一次10，第二次扩容elementData1.5倍

3)有参构造器，则直接扩容为1.5倍。

LinkedList

概念

1.底层实现了双向链表和双端队列特点

2.可以添加任意元素(可重复)，包括null

3.线程不安全

底层结构

1.底层维护了一个双向链表

2.维护两个属性first和last分别执行首节点和尾节点

3.每个节点(Node对象),里面又维护了prev、next、item三个属性，prev 、next执行后一个实现双向链表

4.添加和删除效率高

对比 arrayList

改查 arrayList,增删linkedList。

Vector

概念

底层也是可变对象数组 Object[] elementData

是线程安全的

底层源码

1.无参，默认10，满后就按2倍扩容

2.有参，知道大写，每次直接按2倍扩容

常用方法

(1)add(int index,Collection eles):添加单个元素

(2) addAll(index,list)

(3) get(int index)

(4) indexOf(Object obj) 返回obj在集合首次出现的位置

(5) lastIndexOf(Object obj) 返回obj在集合末次出现的位置

(6) remove(index) 移除

（7）set(int index,Object ele) 替换

(8) List subList(int fromIndex,int toIndex): [fromIndex,toIndex)

概念

1.List集合中元素是有序的、可重复

2.每个元素都有顺序索引

练习题

1.使用常用list方法

2.冒泡排序

子主题 3

list三种遍历方式

1.迭代器 iterator

2.增强for

3.普通for

代码

ArrayList vs Vector

Set

实现子类

HashSet

概念

1.HashSet实现Set接口

2.HashSet实际上是HashMap

3.只能存放一个null

4.无序，取决于hash后，再索引结构

5.不能有重复元素/对象

底层

hashset底层添加元素---hash()+equals()

hashset扩容和转成红黑树

例题

重写hash和equals，name和age相同则认为同一个人

子主题 2

LinkedHashSet

概念

是HashSet的子类

底层是一个LinkenHashMap,底层维护数组+双向链表

根据元素hashCode值来决定存储位置，使用链表维护元素次序，有序

不允许添加重复元素

底层机制

例题

重写equals()和hash

TreeSet

排序

概念

1.无序，没有索引

2.不允许重复元素，最多包含一个null

常用方法，和Collection一样

同Collection遍历方式一样

1.迭代器

2.增强for

继承体系

常用方法

(1)add:添加单个元素

(2)remove:删除单个元素

(3)contains:查找单个元素是否存在

(4)size:获取元素个数

(5)isEmpty:判断是否为空

(6)clear:清空

(7)addAll:添加多个元素

(8)containsAll:查找多个元素是否存在

(9)removeAll:删除多个元素

代码

Colection接口遍历元素方式

1. Iterator迭代器遍历

执行原理

方法

hashNext()

next()

remove()

在调用iterator.next()之前，必须调用iterator.hasNext()进行检测，否则下一条记录无效

iterator遍历运行流程

(1).先得到该对象对应的迭代器

(2).使用while循环，判断是否还有数字（itit快捷键）

(3.)当退出while循环时，这时teration已执指向最后元素

(4)再次遍历需重置我们的迭代器

代码

使用代码

2.增强for遍历

增强for的底层仍然时迭代器

用于遍历集合或数组

代码

Map

继承体系

Map实现类

HashMap

HashMap底层机制

1. (k,v)是一个Node实现Map.Entry<K,V>

2. jak1.7 底层实现【数组+链表】，1.8[数组+链表+红黑树]

3.扩容机制

概念

2.key和value可以是任何引用数据类型，会封装到HashMap$Node对象中

3.Key不允许重复

4.value可以重复

5.key可以为null，只能有一个。value可以为null,可以多个

6.常用String类作为Map的key

7.key和value存在单向一对一关系，通过key找到value

8.key-value存在Node,Node实现Entry接口

9.线程不安全

HashTable

概念

1. 存放元素 k-v

2. 键和值不能为null

3.使用方法和hashMap一样

4. 线程安全

底层机制

1. 底层有数组 HashTable$Entry[] 初始化大小为11

2. 临界值 threshold 8=11*0.75

3.扩容

vs HashMap

Properties

1.Properties:类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据。

2.使用特点和Hashtable类似

3.Properties还可以用于从x.properties文件中，加载数据到Properties类对象，并进行读取和修改

4.配置文件

LinkenHashMap

TreeMap

无参构造器，无序，有参加匿名内部类制定排序规则

排序

实现类特点

1.Map和Collection并列存在。保存映射关系 key-value

2.key和value可以是任何引用数据类型，会封装到HashMap$Node对象中

3.Key不允许重复

4.value可以重复

5.key可以为null，只能有一个。value可以为null,可以多个

6.常用String类作为Map的key

7.key和value存在单向一对一关系，通过key找到value

8.key-value存在Node,Node实现Entry接口

9.线程不安全

常用方法

1.entrySet遍历

2. put 添加

3. remove 根据键删除映射关系

4. get 根据键获取值

5. size 获取元素个数

6. isEmpty 判断个数是否为0

7. clear 清除k-v

8. containsKey 查找键是否存在

Map四大遍历

1. containsKey 查找键是否存在

2. keySet 获取所有的键

3. entrySet 获取k-v

4. values 获取所有值

代码

小结

Collections

概念

是一个操作Set、List、Map等集合的工具类

提供一系列静态方法对集合元素进行排序、查询和修改等

排序操作

1. reverse(List):反转List中元素的顺序

2. shuffle(List): 对List集合元素进行随机排序

3. sort(List) 根据元素的自然排序对指定List集合元素按升序排序

4. sort(List,Coparator) 根据指定的Comparator产生的升序对List集合元素进行排序

5 swap(List,int,int):将指定list集合中 i和j处元素进行交换

代码

查找、替换

1.Object max(Collection) 根据元素的自然排序，返回给定集合中最大元素

2)Object max(Collection,Comparator):根据Comparator指定的顺序，返回给定集合中的最大元素

3)Object min(Collection)

4)Object min(Collection,Comparator)

5)int frequency(Collection,Object):返回指定集合中指定元素的出现次数

6）void copy(List dest,,List src): 将src中的内容复制到dest中

7 ）boolean replaceAll(List list,Object oldVal,Object newVal):新值替换Lst对象的所有旧值

代码

集合好处

1）可以动态保存任意多个对象，使用比较方便！

2）提供了一系列方便的操作对象的方法：add remove、set、get等

任何选择集合实现类

章节作业

1.遍历打印截取15字段

2.更改、所有员工加薪、遍历

3.HashSet、TreeSet如何实现去重

子主题 4

泛型

传统方法

1)不能对加入到集合ArrayListr中的数据类型进行约束（不安全）

2)遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

概念

参数化类型，解决数据类型的安全性问题

泛型的作用是：可以在类声明时通过一个标识表标类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。

在编译时就确定E泛型类型

语法

泛型声明

interface接口<T>{}和class类<K,V>{}

1)其中，T,K,V不代表值，而是表示类型。

泛型的实例化

要在类名后面指定类型参数的值（类型）

1)List<String>strList=new ArrayList<String>():

细节

1.interface List<T>{,public class HashSet<E>).. T,E只能是引用类型

2.在指定泛型具体类型后，可以传入该类型或者其子类类型

3）List list3=new ArrayList（）;默认给它的泛型是[<E>E就是Object

自定义泛型

class 类名<T,R...>

注意细节

1)普通成损可以使用泛型(属性、方法)

2)使用泛型的数组，不能初始化

3)静态方法中不能使用类的泛型---类加载时对象还没常见。

4)泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型

5)如果在创建对象时，没有指定类型，默认为Object

对象创建时指定泛型类型

自定义泛型接口

intefece 接口名 <T,R..>

细节

1)接口中，静态成员也不能使用泛型（这个和泛型类规定一样）

2)泛型接口的类型，在继承接口或者实现接口时确定

3)没有指定类型，默认为Object

自定义泛型方法

细节

1.泛型方法，可以定义在普通类中，也可以定义在泛型类

2.当泛型方法被调用时，类型会确定

3.public void eat(E e){},修饰符后没有<T,R.>eat class Fish方法不是泛型方法，而是使用了泛型

练习题

泛型的继承和通配符

1.泛型不具备继承性

2.<?> 支持任意泛型

3.<? extends A>:支持A类以及A类的子类，规定泛型的上限

4.<? super A>:支持A类以及A类的父类

线程

线程相关概念

进程

1.进程是指运行中的程序，是程序的一次执行过程

线程

1.线程由进程创建，是进程一个实体

2.一个进程可以拥有多个线程

并发：同一时刻，多个任务交替执行

并行：同一时刻，多个任务同时执行

线程的使用

继承 Thread

实现 Runable

代码

区别

实现Runnable接口更加适合多线程共享一个资源的情况，避免了单继承的限制

多线程执行

并发执行

线程终止

1.当线程完成任务后，会自动退出

2.通过变量来控制run方法的方式停止线程，即通知方式

代码

线程常用方法

1.setName/设置线程名称，使之与参数name相同

2.getName 返回该线程的名称

3.start 使该线程开始执行；Java虚拟机底层调用该线程的start(0方法

4.run 调用线程对象run方法

5.setPriority 更改线程的优先级

6.getPriority 获取线程的优先级

7.sleep 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

8.interrupt 中断线程

案例-方法演示

注意事项

1.yieId 线程礼让，让出cpu，让其他线程执行，不一定礼让成功。

2. join 线程插队。先执行插入的线程所有任务

案例--插队到主线程

1.用户线程

当前线程任务执行完或通知方式结束

2.守护线程，主线程退出，线程自动退出 thread.setDaemon(true); --垃圾回收机制

守护线程案例

线程的生命周期

线程同步

概念

synchronized 同一时刻只能有一个线程访问

即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

具体方法-Synchronized

同步代码块 synchronized(对象){ }获取对象锁，才能操作同步代码块

可以放在方法声明中---同步方法

互斥锁

只有一个线程访问该对象

同步方法(非静态)的锁可以是this,也可以是其他对象（要求同一对象）

同步方法（静态的）锁为当前类本身

代码

死锁

多线程都占有对方的资源

代码

释放锁

释放锁操作

1.同步方法、同步代码块执行结束

2. 线程在同步代码块，同步方法遇到break,return

3. 线程在同步代码块，同步方法出现了未处理得Erro和Exception

4. 线程在同步代码块，同步方法执行了线程对象得wait()方法，当前线程暂停，并释放锁

不会释放锁

1.线程执行同步代码块或同步方法时，程序调用Thread.sleep（）、Thread.yield（）方法暂停当前线程的执行，不会释放锁

2.线程执行同步代码块时，其他线程调用了该线程的suspend(0方法将该线程挂起该线程不会释放锁。

本章作业

例题1

IO流

文件

概念

文件在程序以流的形式来操作

内存-->输入流磁盘

常用操作

创建文件

创建文件对象相关构造器

createNewFile 创建新文件

代码

获取文件相关信息

getName 获取文件名

getAbsolutePath 绝对路径

getParent 父级目录

length 文件大小

exists 是否存在

isFile 是不是一个文件

isDirectory 是不是一个文件

例题

目录操作和删除

mkdir 创建一级目录

mkdirs 创建多级目录

delete 删除空目录或文件

代码

IO流原理及流的分类

概念

子主题 2

常用操作

流的分类

操作数据单位

字节流(8 bit)二进制文件，字符流文本文件

数据流的流向

输入流，输出流

流的角色

字节流，处理流/包装流

都是抽象类，衍生出很多子类

IO流体系图

节点流和处理流

处理流/包装流

字节流和处理流一览

字节流和处理流区别

标准输入输出流

System.in--编译类型-->InputStream -->运行类型BuffereInputStrem

System.out-->编译类型--> PrintStream-->运行类型 PrintStream

输入流

InputStream

FileInputStream

常用方法

构造方法

使用FileInputStream 读取hello.txt文件

BufferedInputStream

构造器和常用方法

是字节流，在创建BuffereInputStream时，会创建一个内部缓冲区数据

子主题 3

ObjectInputStream -对象流

构造器--可以放InputStream子类

提供了对基本类型或对象类型的序列化和反序列化方法

序列化和反序列化

1.序列化就是在保存数据时，保存数据的值和数据类型

2.反序列化就是在恢复数据时，恢复数据的值和数据类型

3.需要让某个对像支持序列化机制，类必须实现如下两个接口之一：Serializable这是一个标记接口Externalizable

提高反序列功能

代码--

对象流细节

继承体系图

Reader

FileReader

网络编程

网络通信

概念：两个设备之间通过网络实现数据传输

网络

概念：两台或多台设备通过一定物理设备连接起来构成了网络

网络覆盖范围分类

局域网：覆盖范围最小，仅仅覆盖一个教室或一个机房

城域网：覆盖范围较大，可以覆盖一个城市

广域网：覆盖范围最大，可以覆盖全国，甚至全球，万维网是广域网的代表

ip地址

唯一标识主机

概念

ipv4地址分类

域名和端口

域名：将ip地址映射成域名

端口：用于标识计算机上某个特定的网络程序

端口：区分服务，监听端口

网络协议

概念：数据，数据的组织形式就是协议

协议(tcp/ip) 传输控制协议/因特网、互联网协议。由网络层的IP协议和传输层的TCP协议组成

TCP和UDP

TCP 传输协议

1.使用TCP协议前，须先建立TCP连接，形成传输数据通道

2. 传输前，采用“三次握手“方式，是可靠的

3. TCP协议进行通信的两个应用进程：客户端、服务端

4. 在连接中可进行大数据量的传输

5.传输完毕，需释放已建立的连接，效率低

UDP 用户数据协议

1. 将数据、源、目的封装成数据包，不不需要建立连接

2. 每个数据报的大小限制在64K内，不适合传输大量数据

3.因无需连接，故是不可靠的

4.发送数据结束时无需释放资源（因为不是面向连接的），速度快

InetAddress

反射

反射机制

概念

反射机制允许程序在运行时获取类的名称、属性、方法和构造函数等信息，以及在运行时调用类的方法和构造函数，并对类的属性进行操作

加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息。通过这个对象得到类的结构

反射机制原理图

反射机制相关类

代码

反射作用

运行时： 1.判断任意一个对象所属的类 2.构造任意一个类的对象 3.得到任意一个类所具有的成员变量和方法 4.调用任意一个对象的成员变量和方法 5.生成动态代理

优缺点

优：可以动态的创建和使用对象

缺：使用反射基本是解释执行，对执行速度有影响

Class类

概念

获取Class对象的六种方式

代码

哪些类型有Class对象

类加载

基本说明

1.静态加载

编译时加载相关的类没有则报错，依赖性强

2.动态加载

运行时加载所需的类，若运行时不用该类，则不报错

类加载时机

1.当创建对象时(new) //静态加载

2.当子类被加载时，父类也加载 //静态加载

3.调用类中的静态成员 //静态加载

4.通过反射 //动态加载

类加载过程图

全过程

类加载各阶段完成任务

类加载五个阶段

类加载

将字节码转化为二进制字节流加载到内存，并生成一个代表该类的java.lang.Class对象

连接

1.验证

2.准备 --JVM对静态变量，分配内存并默认初始化

列子

3.解析

虚拟机将常量池内的符号引用替换为直接引用的过程

初始化

依次自动收集类中的所有静态变量的赋值和静态代码块中的语句，并进行合并

代码

反射获取类的结构信息

Class

java.lang.Class类

Filed

代码

Mehod

Constructor

访问属性

访问方法

反射相关类

反射调用性能优化

Class类常用方法

通过反射创建对象

AI数字馆员管理端思维导图

U166854141

4.57

树图思维导图提供《AI数字馆员管理端》在线思维导图免费制作，点击“编辑”按钮，可对《AI数字馆员管理端》进行在线思维导图编辑，本思维导图属于思维导图模板主题，文件编号是：bf1e27a80ee3c4a567e82a9bc37a5bd2

通信网络基础及设计思维导图

U566839978

3.91

树图思维导图提供《通信网络基础及设计》在线思维导图免费制作，点击“编辑”按钮，可对《通信网络基础及设计》进行在线思维导图编辑，本思维导图属于思维导图模板主题，文件编号是：e23ad0aec7a670548c57b7080de2605f

思维导图模板

高校与高等教育

其他学科

正文

相似思维导图模版

思维导图模版推荐

首页

我的文件

我的团队

个人中心

java基础思维导图

思维导图大纲

相关思维导图模版

类与对象

java高级

枚举和注解

Exception

常用类

集合

泛型

线程

IO流

网络编程

反射

相似思维导图模版

思维导图模版推荐