Java是一门面向对象的编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表,极好地实现了面向对象理论,允许程序员以优雅的思维方式进行复杂的编程
Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等
面向对象的思想已经逐步取代了过程化的思想 — 面向过程,java是面向对象的高级编程语言,面向对象语言具有如下特征
1.面向对象是一种常见的思想,比较符合人们的思考习惯
2.面向对象可以将复杂的业务逻辑简单化,增强代码的复用性
3.面向对象具有抽象、封装、继承、多态等特性
面向对象的编程语言主要有:C++,Java,C#
多态 多态指的是同一个行为具有多个不同表现形式。是指一个类实例(对象)的相同方法在不同情形下具有不同表现形式。封装和继承是多态的基础,也就是说,多态只是一种表现形式而已。
多态的实现具有三种充要条件
1.继承
2.重写父类方法
3.父类引用指向子类对象
继承 继承是所有OOP语言和JAVA语言都不可或缺的一部分。只要我们创建一个类,就隐式的继承来自Object父类,只不过没有指定,如果你显示指定了父类,那么你继承于父类,而你的父类继承于Object类。
继承的关键字是extends,如果使用了extends显示指定了继承,那么我们可以说指定的类是父类,
组合 组合其实不难理解,就是将对象引用置于新类中即可。组合也是一种提高类的复用性的一直方式。如果你想让类有更多的扩展功能,你需要记住一句话多用组合,少用继承组合就是把一个类当做另一个类的组成部分,从而允许新类可以直接复用该类的属性和方法
组合和继承的区别
1. 组合是has-a的关系,可以理解为有一个,
继承是一种is-a的关系,可以理解为是一个
**2.**组合双方是一种松耦合,继承双方是紧耦合
**3.**组合不具备多态和向上转型,继承是多态的基础,可以实现向上转型
**4.**组合是运行期绑定,继承是编译期绑定
代理 除了继承和组合外,另一种关系模型称为代理。代理是A类想要调用B类方法,A不直接调用,A在自己类中创建一个B对象的代理,再有代理调用B的方法
向上转型 向上转型代表了父类与子类间的关系,其实父类和子类之间不仅仅有向上转型,还有向下转型,他们的转型后范围都是不一样的
**向上转型:**通过子类对象(小范围)转化为父类对象(大范围),这种转换时自动完成的,不用强制。
**向下转型:**通过父类对象(大范围)实例化子类对象(小范围),这种转换不是自动,需要强制指定。
static static是Java中的关键字,它的意思是静态的,static可以用来修饰成员变量和方法,static用在没有创建对象的情况下调用 方法/变量
- 用static声明的成员变量是静态成员变量,也是类变量。类变量的生命周期和类相同,在整个应用程序执行期间都有效
- 使用static修饰的方法称为静态方法,静态方法能够直接使用类名.方法名进行调用,由于静态方法不依赖于任何对象就可以直接访问,因此对于静态方法来说,是没有this关键字的,实例变量都会有this关键字。在静态方法中不能访问类的非静态成员和非静态方法,
static除了修饰属性和方法外,还有静态代码块,可以用于类的初始化操作,进而提升程序的性能
由于静态代码块随着类的加载而执行,因此很多时候会将只需要进行一次的初始化操作放在static代码块中进行
final final的意思是最后的、最终的、他可以修饰类、属性和方法。
- final修饰类时,表明这个类不能被继承。final类中的成员变量可以根据需要设为final,但是需要注意final类中的所有成员方法都会被隐式的指定为final方法。
- final修饰方法时,表明这个方法不能被任何子类重写,因此,如果只有想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final
- final修饰变量分为两种情况,一种是修饰基本数据类型,表明数据类型的值不能被修改;一种是修饰引用类型,表示对其初始化之后便不能再让其指向另一个对象
从设计层面来说,抽象是对类的抽象,是一种模板设计,接口是行为的抽象,是一种行为的规范
接口 接口相当于对外的一种约定和标准,这里拿操作系统举例子,为什么会有操作系统?就是为了屏蔽软件的复杂性和硬件的简单性之间的差异,为软件提供统一的标准。
在Java语言中,接口是有Interface关键字来表示的
接口的特征:
1.interface接口是一个完全抽象的类,他不会提供任何方法的实现,只是会进行方法的定义
2.接口中只能使用两种访问修饰符,一种是public,它对整个项目可见;一种是default缺省值,它只具有包访问权限
3.接口只提供方法的定义,接口没有实现,但是接口可以被其他类实现。也就是说,实现接口的类需要提供方法的实现,实现接口使用implements关键字来表示,一个接口可以有多个实现
4.接口不能被实例化,所以接口中不能有任何构造方法,你定义构造方法编译会出错
5.接口的实现要实现接口中的全部方法,否则必须定义为抽象类
抽象类 抽象类是一种抽象能力弱于接口的类,在Java中,抽象类使用abstract关键字来表示。如果把接口形容为狗的这个物种,那么抽象类可以说是毛发是白色,小体的品种,而实现类可以是具体的类,比如说是博美、泰迪等。
抽象类的特征:
1.如果一个类中有抽象方法,那么这个类一定是抽象类,也就是说,使用关键字abstract修饰的方法不一定是抽象方法,具有抽象方法的类一定是抽象类,实现类方法中只有方法具体的实现
2.抽象类中不一定只有抽象方法,抽象类中也可以有具体的方法,你可以自己去选择是否实现这些方法
3.抽象类中的约束不想接口那么严格,你可以在抽象类中定义构造方法、抽象方法、普通属性、方法、静态属性和静态方法
4.抽象类和接口一样不能被实例化,实例化只能实例化具体的类
异常 什么是异常 定义:在程序运行过程中出现的错误,称为异常。异常就是程序运行过程中出现了不正常现象导致程序的中断。在Java中,把各种异常现象进行了抽象形成了异常类。
异常的分类 异常的类图结构:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AejVmmaY-1654775931046)(C:UsersoAliPictures20200524101154585.png)]
异常主要分为:错误、一般性异常(受控异常)、运行时异常(非受控异常)
Error: 表示应用程序本身无法克服和恢复的一种严重问题。
**Exception:**表示程序还能够克服和恢复的问题,其中又分为系统异常和普通异常。
-
错误
如果应用程序出现了Error,那么将无法恢复,只能重新启动应用程序,最典型的Error的异常是:OutOfMemoryError
-
普通异常
这种异常属于一般性异常,出现了这种异常必须显示的处理,不显示处理java程序将无法编译通过。编译器强制普通异常必须try…catch处理,或用throws声明继续抛给上层调用方法处理,所以普通异常也称为checked异常。
-
系统异常
非受控异常也即是运行时异常(RuntimeException),这种系统异常可以处理也可以不处理,所以编译器不强制用try…catch处理或用throws声明,所以系统异常也称为unchecked异常。
运行时异常(系统异常)不需要预处理,通过规范的代码可以避免产生这种异常 受检异常(编译时异常)必须预处理,否则编译报错,有两种预处理方式 :
- 捕获处理
- 抛出处理
-
throw
throw 语句用在方法体内,表示抛出异常,由方法体内的语句处理。throw是具体向外抛出异常的动作,所以它抛出的是一个异常实例,执行throw一定是抛出了某种异常。
throw一般用于抛出自定义异常。
-
throws
throws语句是用在方法声明后面,表示如果抛出异常,由该方法的调用者来进行异常的处理。throws主要是声明这个方法会抛出某种类型的异常,让它的使用者要知道需要捕获的异常的类型。
throws表示出现异常的一种可能性,并不一定会发生这种异常。
-
final
用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,被其修饰的类不可继承。 -
finally
在异常处理时提供finally****块来执行任何清除操作,如果抛出一个异常,那么相匹配的catch子句就会执行,然后控制就会进入finally**块(如果有的话)。
在以下4种情况下,finally块不会被执行
- 在finally语句块中发生了异常
- 在前面的代码中使用了**System.exit()**退出程序
- 程序所在的线程死亡
- 关闭了CPU
-
finalize
finalize 是Object 类的一个方法,所以Java对象都有这个方法,当某Java对象没有更多的引用指向的时候,会被垃圾回收器回收,该对象被回收之前,由垃圾回收器来负责调用此方法,通常在该方法中进行回收前的准备工作。该方法更像是一个对象生命周期的临终方法,当该方法被系统调用则代表该对象即将“死亡”,但是需要注意的是,我们主动行为上去调用该方法并不会导致该对象“死亡”,这是一个被动的方法(其实就是回调方法),不需要我们调用。
在Java中一个很重要的概念就是方法的重载,它是类名的不同表现形式。
重载的条件
- 方法名称必须相同
- 参数列表必须不同(个数不同,类型不同,参数类型排列顺序不同等)
- 方法的返回类型可以相同也可以不同
- 仅仅返回类型不同不足以成为方法的重载
- 存在于父类和子类、同类之间
- 重载是发生在编译时的,因为编译器可以根据参数的类型来选择使用哪个方法
方法的重写与重载虽然名字很相似,但却完全是不同的。方法的重写描述的是对子类和父类之间
重写的条件
- 重写的方法必须和父类保持一致,包括返回值类型,返回值,参数列表也都一样
- 重写的方法可以使用**@Override**注解来标注
- 子类方法不能缩小父类方法的访问权限
- 子类方法不能抛出比父类方法更多的异常
集合就是一个容器,类似于数组,用来存储一组数据,但是数组一旦定义,长度将不能再变化。
然而在我们的实际开发中,经常需要保存一些变长的数据集合,于是,我们需 要一些能够动态增长长度的容器来保存我们的数据。
也有我们对数据的存储逻辑可能是各种各样的,于是就需要各种各样的数据结构。
Java当中对于各种数据结构的具体实现,就利用的是集合。
Java集合类是被定义在Java.util包中,它主要包含了4种集合,分别为List、Queue、Set和Map
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6F2sLmx9-1654775931048)(C:UsersoAliAppDataRoamingTyporatypora-user-images1653998506420.png)]
Iterable 接口 顶层接口 Collection 是一个顶层接口,它主要用来定义集合的约定
List接口也是一个顶层接口,它继承了Collection接口,同时也是ArrayList、LinkedList等集合元素的父类
Set接口位于与List接口同级的层次,它同时也继承了Collection接口。set接口提供了额外的规定。他对add、equals、hashCode方法提供了额外的标准
Queue是和List、Set接口并列的Collection的三大接口之一。Queue的设计用来处理之前保持元素的访问次序。除了Collection基础的操作之外,队列提供额外的插入,读取,检查操作。
SortedSet 接口直接继承于Set 接口,使用Comparable对元素进行自然排序或者使用Comparator在创建时对元素提供定制的排序规则。set的迭代器将升序元素顺便遍历集合。
Map是一个支持key-value存储的对象,Map不能包含重复的key,每个键最多映射一个值。这个接口代替了Dictionary类,Dictionary是一个抽象类而不是接口。
●Set中的数据对象没有顺序且不可以重复。
●List中的数据对象有顺序且可以重复。
List接口及实现类List接口继承Collection
有序的(按照插入元素的顺序排列),存储重复元素,值插入后会有索引,可以通过索引访问元素
ArrayList
底层是数组,查询快,从中间删除,添加慢,
LinkedList
底层是双向链表,查询慢,从中间删除,添加快
Vector
底层是数组,查询快,从中间删除,添加慢,线程安全
ArrayList ArrayList是实现了List接口的 可扩容数组(动态数组),它的内部是基于数组实现的。
- ArrayList可以实现所有可选择的列表操作,允许所有的元素,包括控制。ArrayList还提供了内部存储list的方法,它能够完全替代Vector,只有一点例外,ArrayList不是线程安全的容器。
- ArrayList有一个容量的概念,这个数组的容量就是List用来存储元素的容量
- ArrayList不是线程安全的容器,如果多个线程中至少有两个线程修改了ArrayList的结构就会导致线程安全的问题,作为替代条件可以使用线程安全的List
Vector同ArrayList一样,都是基于数组实现的,只不过Vector是一个线程安全的容器,它对内部的每个方法都简单粗暴的上锁,避免多线程引起的安全性问题,但是通常这种同步方式需要的开销比较大,因此访问元素的效率要远远低于ArrayList。
还有一点在于扩容上,ArrayList扩容后的数组长度会增加50%,而Vector的扩容长度后数组会增加一倍
LinkedList LinkedList是一个双向链表,允许存储任何元素(包括 null)。它的主要特征如下:
- LinkedList所有的操作都可以表现为双向性的,索引到链表的操作将遍历从头到尾。视哪个距离近为遍历顺序。
- 注意这个实现也不是线程安全的,如果多个线程并发访问链表,并且至少其中的一个线程修改了链表的结构,那么这个链表必须进行外部加锁。
堆栈是我们常说的**后入先出(吃了吐)**的容器。它继承了Vector类,提供了通常用的push和pop操作,以及在栈顶的peek方法,测试stack是否为空的empty方法,和一个寻找与栈顶距离的search方法
第一次创建栈,不包含任何元素。一个更完善,可靠性更强的LIFO栈操作由Deque接口和他的实现提供
Set接口及实现类Set中所存储的元素不是重复的,但是是无序的,Set中的元素是没有索引的
HashSet:无序,底层使用哈希表+链表+红黑树
TreeSet: 有序(按照值(编码)的顺序排序) 底层是红黑树
HashSet HashSet是Set接口的实现类,由哈希表支持(实际上HashSet是HashMap的一个实例)。它不能保证集合的迭代顺序。这个类允许null元素。
- 注意这个实现不是线程安全的。如果多线程并发访问HashSet,并且至少一个线程修改set,必须进行外部加锁。或者使用Collections.synchronizedSet()方法重写。
- 这个实现支持fail-fast机制
TreeSet是一个基于TreeMap的NavigableSet实现。这些元素使用他们的自然排序或者创建时提供的Comparator进行排序,具体取决于使用的构造函数。
- 此实现为基本操作add,remove和contains提供了log(n)的时间成本。
- 注意这个实现不是线程安全的。如果多线程并发访问TreeSet,并且至少一个线程修改了set,必须进行外部加锁。
- 这个实现持有fail-fast机制。
LinkedHashSet继承于Set,先来看一下LinkedHashSet的继承体系:
LinkedHashSet是Set接口的Hash表和LinkedList的实现。这个实现不同于HashSet的是它维护着一个贯穿所有条目的双向链表。此链表定义了元素插入集合的顺序。注意:如果元素重新插入,则插入顺序不会受到影响。
- LinkedHashSet有两个影响其构成的参数:初始容量和加载因子。他们的定义与HashSet完全相同。但请注意:对于LinkedHashSet,选择过高的初始容量值的开销要比HashSet小,因为LinkedHashSet的迭代次数不受容量影响。
- 注意LinkedHashSet也不是线程安全的,如果多线程同时访问LinkedHashSet,必须加锁,或者通过使用Collections.synchronizedSet
- 该类也支持fail-fast机制
PriorityQueue是AbstarctQueue的实现类,优先级队列的元素根据自然排序或者通过在构造函数时期提供Comparator来排序,具体根据构造器判断。PriorityQueue不允许null元素。
-
队列的头在某种意义上是指定顺序的最后一个元素。队列查找操作poll,remove,peek和element访问队列头部元素。
-
优先级队列是无限制的,但具有内部capactiy,用于控制在队列中存储元素的数组大小
-
该类以及迭代器实现类Collection、lterator接口的所有可选方法。这个迭代器提供了iterator()方法不能保证以特定的顺序遍历优先级队列的元素。如果你需要有序遍历,使用Arrays.sort(pq.toArray);
-
注意这个实现不是线程安全的,多线程不应该并发访问PriorityQueue实例如果有某个线程修改了队列的话,使用线程安全的类PriorityBlockingQueue。
三个实现类:HashMap TreeMap HashTable(线程安全)
HashMap HashMap中的元素的key值不能重复,排列顺序是不固定的,可以存储一个为null的键
HashMap的底层是哈希表+链表+红黑树
用key计算出哈希值,再用哈希值计算出元素在哈希表中的位置。当相同位置有元素加入进来后,才用链表存储(拉链法),当元素个数到达8时,采用红黑树存储
HashMap是一个利用哈希表原理来存储元素的集合,并且允许空的key-value键值对。HashMap是非线程安全的,也就是说在多线程环境下,可能会存在问题,而HashTable是线程安全的容器,HashMap也支持fail-fast机制。HashMap的实例有两个参数影响其性能:初始容量和加载因子。可以使用Collections.synchronizedMap(new HashMap(…))来构造一个线程安全的HashMap。
TreeMaP类 一个基于NavigableMap实现的红黑树。这个map根据key自然排序存储,或者通过Comparator进行定制排序。
- TreeMap为containsKey,get,put和remove方法提供log(n)的时间开销
- 注意这个实现不是线程安全的,如果多线程并发访问TreeMap,并且至少有一个线程修改了map,必须进行外部加锁,这通常通过在自然封装集合的某个对象上实现同步的
- 这个实现持有fail-fast机制
HashTable类实现一个哈希表,能够将键映射到值。任何非空对象都可以用作键或值。
- 此实现类支持fail-fast机制
- 与新的集合实现不同,HashTable是线程安全的。如果不需要线程安全的容器,推荐使用HashMap,如果需要多线程高并发,推荐使用ConcurrentHashMap。
Collection接口定义了存取一组对象的方法,其子接口Set和List分别定义了存储方式。
Set中的数据对象没有顺序且不可重复
List接口中的方法:
add(E e)//添加元素
addAll(Collection extends E> c) //将制定集合添加到此集合
clear() //清空集合
contains(Object o) //如果刺激和包含指定元素,则返回true
containsAll(Collection> c) //如果此集合包含指定 集合中的所有元素,则返回true。
isEmpty() //如果此集合不包含元素,则返回 true 。
remove(Object o) //从集合中删除某个元素
removeAll(Collection> c) //删除指定集合中包含的所有此集合的元素(可选操作)。
size() //集合中的元素数
retainAll(Collection> c) //;求交集,集合数据发生变化返回true, 不变返回false
泛型 泛型其实就是一种参数化的集合,他限制了你添加进集合的类型。泛型的本质就是一种参数化类型,多态也可以看作是泛型的机制。一个类继承了父类,那么就能通过它的父类找到对应的子类,但是不能通过其他类来找到具体要找的这个类。泛型的设计之初就是希望对象或方法具有最广泛的表达能力
反射 反射是java中一个非常重要同时也是一个高级特性,基本上Spring等一系列框架都是基于反射的思想携程的。我们首先来认识一下什么是反射。
Java反射机制是在程序运行过程中,对于任何一个类,都能够知道他的所有属性和方法;对于任何一个对象,都能够知道调用它的任意属性和方法,这种动态获取信息以及动态调用对象的方法的功能称为java语言的反射机制
Java反射机制主要提供了以下这几个功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所有的成员变量和方法
- 在运行时调用任意一个对象的方法
这么一看,反射就像是一个掌控全局的角色,不管你程序怎么运行,我都能知道你这个类有哪些属性和方法,你这个对象是由谁调用的
作用:动态获取类的信息,进一步实现需要的功能
在Java中,使用java.lang.reflect包实现了反射机制。
反射相关API Class 类型
Constructor 构造方法
Method 方法
Field 属性
除了Class外,其他类都位于java.lang.reflect包中
反射API将类的类型、方法、属性都封装成了类
Class类 Class类的对象表示正在运行的Java应用程序中的类和接口.
获得Class类的三种方法
Class c1 = Car.class;//类名.class方式
System.out.println(c1);//class com.ffyc.dormMS.reflect.Car
Class c2 = new Car().getClass();//Object类中的getClass方法
System.out.println(c2);
System.out.println(c1==c2);//true
String carpath = "com.ffyc.dormMS.reflect.Car";
Class c3 = Class.forName(carpath);//Class类的静态方法
System.out.println(c3);
System.out.println(c2==c3);//true
Car car = (Car)c1.newInstance();//创建由此 类对象表示的类的新实例。
IO
File类
- File是java.io包中一个很重要的类
- File类的对象可以表示文件,还可以表示目录,在程序中一个File类对象可以代表一个文件或目录
- File对象可以对文件或目录的属性进行操作,如:文件名、最后修改日期、文件大小等;但无法操作文件的具体数据,即不能直接对文件进行读/写操作。
import java.io.File;
import java.util.Date;
public class FileDemo1 {
public static void main(String[] args) {
File file1 = new File("F:/demo.txt");
File file2 = new File("F");
File file3 = new File(file2, "demo.txt");
System.out.println(file1.canRead());//判断File对象对应的文件或目录是否可读(true/false)
System.out.println(file1.canWrite());//判断File对象对应的文件或目录是否可写(true/false)
System.out.println(file1.getPath());//返回File对象对应的路径
System.out.println(file1.getName());//返回File对象表示的文件或文件夹的名称
System.out.println(file1.getParent());//返回File对象的父级目录
System.out.println(file1.length());//返回File文件内容的长度
System.out.println(file1.isFile());//判断File对象对应的是文件而非目录(true/false)
System.out.println(file1.isDirectory());//判断File对象对应的是目录而非文件(true/false)
System.out.println(file1.isAbsolute());//判断File对象对应的文件或目录是绝对路径
System.out.println(file1.isHidden());
System.out.println(file1.exists());//判断File对象对应的文件或目录是否存在(true/false)
System.out.println(file1.lastModified());//输出1645025723334
System.out.println(new Date(1645025723334L));
}
}
import java.io.File;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
File file1 = new File("F:/www.java");
//指明详细的路径以及文件名
if (!file1.exists()){
try {
file1.createNewFile();//创建文件
} catch (IOException e) {
e.printStackTrace();
}
}
File file2 = new File("F:/demo");
// file2.mkdir();//只能创建单极文件夹
// file2.mkdirs();//创建多级文件夹
file2.delete();//一次只能删除一级文件夹,文件中必修是空的
}
}
获取一个目录中所有的文件及文件夹
import java.io.File;
import java.util.Arrays;
import java.util.Date;
public class FileDemo2 {
public static void main(String[] args) {
//获取一个目录中所有的文件及文件夹
File file = new File("F:/file");
File[] files = file.listFiles((file1,name)->{return name.endsWith(".ppt");});
Arrays.stream(files).forEach((e)->{
System.out.println(e);
});
}
}
输入及输出概念
把电脑硬盘上的数据读到程序中,称为输入,即input,进行数据的read操作;
从程序往外部设备写数据,称为输出,即output,进行数据的write操作
字节流与字符流-
按照流的走向,分为:输入流,输出流
-
按照流的读取单位分为:
字节流(以原始字节为单位:音频、图片、歌曲等)
字节输入流 FileInputStream
字节输出流 FileOutputStream
字符流(例如txt文件、以单个字符为单位)
字符输入流 FileReader
字符输出流 FileWriter
-
按照封装类型不同流又分为:节点流,处理流
节点流:如果流封装的是某种特定的数据源,如文件、字符串、字符串数组等, 则称为节点流
字节输入流 FileInputStream
字节输出流 FileOutputStream
字符输入流 FileReader
字符输出流 FileWriter
处理流:如果流封装的是其它流对象,称为处理流。 处理流提供了缓冲功能,提高读写效率,同时增加了一些新的方法。
缓冲字节输出流 BufferedOutputStream
缓冲字节输入流 BufferedInputStream
缓冲字符输入流 BufferedReader
缓冲字符输出流 BufferedWriter
Print 打印流:只做输出没有输入
打印流分为字节打印流和字符打印流
PrintWriter:字符打印流
print方法可以打印各种类型数据
import java.io.FileNotFoundException;
import java.io.PrintWriter;
public class PrintWriterDemo {
public static void main(String[] args) throws FileNotFoundException {
PrintWriter prw = new PrintWriter("F:/demo.html");
prw.print("aaaaaa");
prw.println("ssssss");
prw.write("bbbbbbb");
prw.close();
}
}
对象的输入输出流
-
对象的输入输出流:主要的作用是用于写入对象信息与读取对象信息。对象信息一旦写到文件上那么对象的信息就可以做到持久化
对象的输出流:ObjectOutputStream
对象的输入流:ObjectInputStream
import java.io.*; import java.util.Date; public class ObjectStreamDemo { public static void main(String[] args) throws IOException, ClassNotFoundException { //对象输出 //对象输入 FileInputStream fin = new FileInputStream("F:/ojb.txt"); ObjectInputStream oin = new ObjectInputStream(fin); Date date1 = (Date)oin.readObject();//对象反序列化 String s1 = (String)oin.readObject(); System.out.println(date1); System.out.println(s1); } }● 对象的寿命通常随着生成该对象的程序的终止而终止。
有时候,可能需要将对象的状态保存下来,在需要时再将对象恢复。
● 对象的输出流将指定的对象写入到文件的过程,就是将对象序列化的过程,对象的输入流将指定序列化好的文件读出来的过程,就是对象反序列化的过程。既然对象的输出流将对象写入到文件中称之为对象的序列化,所以必须要实现Serializable接口。
Serializable接口中没有任何方法。当一个类声明实现Serializable接口后,表明该类可被序列化。
- 对象的输出流将指定的对象写入到文件的过程就是将对象序列化的过程
- 对象的输入流将指定的对象序列化好的文件读出来的过程,就是对象反序列化的过程
- 既然对象的输出流将对象写入到文件中称之为对象的序列化,所以必须要实现Serializable接口
- Serializable接口中没有任何方法,当一个类声明实现Serializable接口后,表明该类可被序列化
java提供的网络类库,可以实现网络连接,联网的底层细节都被隐藏在java的本机安装系统里,由JVM进行控制,并且java实现了一个跨平台的网络库,程序员面对的是一个统一的网络编程环境。
网络编程的主要目的:直接或间接地通过网络协议与其他计算机进行通讯
网络模型OSI七层模型及TCP/IP四层模型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JwlepK6N-1654775931049)(C:UsersoAliPictures网络编程图.png)]
网络通信要素网络编程中三要素:IP地址、端口号和通信协议地址
IP地址:是指互联网协议地址、网络中地计算机使用IP地址进行唯一标识
端口号:用来区分不同地应用程序、
通信协议:计算机网络中实现通信须有一些约定,即通信协议,对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准
网络通信协议 TCP(传输控制协议):- 使用TCP协议前,须先建立TCP连接,形成传输数据通道
- 传输前,采用**“三次握手”**方式,是可靠的
- TCP协议进行通信的两个应用进程:客户端、服务端
- 在连接中可进行大数据量的传输
- 传输完毕,需要释放已建立的连接,效率低
- 在断开时要进行“四次挥手”
- 将数据、源、目的封装成数据包,不需要建立连接
- 每个数据报的大小限制在64K内
- 因无需连接,故是不可靠的
- 发送数据结束时无需释放资源,速度快
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sXkYtR7w-1654775931050)(C:UsersoAliPictures三次握手.png)]
第一次握手:
客户端向服务端发送一个SYN(发送一个新连接)报文,并指明客户端地初始化序列号ISN
第二次握手:
服务器收到客户端发送的SYN报文后,会以自己的SYN报文作为应答
第三次握手:
客户端收到SYN报文后,回应ACK(确认序号有效)报文,进入连接状态
四次挥手[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4Csp0H0L-1654775931051)(C:UsersoAliPictures四次挥手.png)]
第一次挥手:
客户端发送一个FIN(释放一个连接)报文,报文中会指定一个序列号。此时客户端处于FIN_WAIT1(等待状态1)状态
第二次挥手:
服务端收到FIN之后,会发送ACK报文,且把客户端的序列号值+1作为ACK报文的序列号值,表明已经收到客户端的报文,此时服务端处于CLOSE_WAIT(关闭等待)状态
第三次挥手:
服务端断开连接前,发送FIN报文,请求客户端确认关闭连接,服务器进入LAST-ACK(最后确认)状态
第四次挥手:
客户端收到FIN后,同样会发送ACK确认报文作文应答,此时客户端处于TIME_WAIT等待状态,设置的超时时间结束后才到关闭状态
线程 进程与线程及两者之间的关系- 进程(process)就是正在执行的程序,从Windows角度讲,进程是操作系统进行资源分配的最小单位含有内存和资源以及存放线程
- 线程(thread)进程可以进一步细化为线程,是一个进程内部的最小执行单元,是操作系统进行任务调度的最小单元,隶属于进程
关系:
-
一个进程可以包含多个线程,一个线程只能属于一个进程,线程不能脱离进程而独立运行
-
每一个进程至少包含一个线程(称为主线程);在主线程中开始执行程序
java程序中的入口main()方法就是在主线程中被执行的
-
在主线程中可以创建并启动其他的线程
-
一个进程内的所有线程共享该进程的内存资源
-
继承Thread类的方式
在java中要实现线程,扩展Thread类,重写其中的run方法,当线程启动时,它执行run方法
-
实现Runnable接口的方式
Runnable接口的存在主要是为了解决java不允许多继承的问题,因为Java中当一个类继承一个其他的父类,那么就无法通过继承Thread类方式创建线程,所以可以实现Runnable接口的方式来创建线程
-
实现Callable接口的方式
实现Callable接口后,需重写它的call()方法,
-
使用线程池
- 在计算机中事实上只有一个CPU,各个线程轮流获得CPU使用权才能执行任务
- 优先级取值范围在1~10,一般线程的默认优先级都是5
- 优先级较高的线程有更多获得CPU的机会
线程在它的声明周期中会处于不同的状态
新建->就绪->运行->阻塞->死亡
**新建:**当一个Thread类或其他子类的对象被声明并创建时,新生的线程对象处于新建状态
**就绪:**当处于新建状态的线程调用start()后,进入线程队列等待CPU资源可用
**运行:**当就绪的线程被调度并获得CPU资源时,进入运行状态,其中run()方法定义了线程的操作和功能
**阻塞:**线程休眠、等待、阻塞进入阻塞状态,在某种特殊情况下被人挂起或执行输入输出操作时,让出CPU并临时中止自己的执行进入阻塞状态
**死亡:**线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束,注意:线程执行了stop(),线程会进入到死亡状态
多线程多线程即包含多个执行单元,即在一个程序中可以同时多个不同的线程来执行不同的任务,即允许单个程序创建多个并行执行的线程来完成各自任务
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qFKfex80-1654775931052)(C:UsersoAliPictures多线程.png)]
何时需要多线程- 当程序需要同时执行两个或多个任务时
- 当程序需要实现一些需要等待的任务时(如用户输入、文件读写操作等)
- 需要一些后台运行的程序时
- 能够提高程序的响应
- 提高CPU的利用率
- 能够改善程序结构,即可以执行的复杂任务为多个线程如何独立运行
- 当线程越多时内存占用也越多
- 多线程需要协调和管理,所以需要CPU时间跟踪线程
- 线程间对于共享资源的访问会产生影响,因此需要解决资源共享的问题
- 线程安全问题主要是出现在多线程的情况下,即在同一时间有多个线程同时抢占并使用同一资源(线程并发)时出现
- 多线程对程序的共享造成了操作不完整,破坏数据出现线程安全问题
同步代码块:synchronized关键字可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问
注:在Java代码中实现同步:
使用synchronized(同步监视器)关键字同步方法或代码块。
synchronized (同步监视器){
// 需要被同步的代码;
}
synchronized还可以放在方法声明中,表示整个方法,为同步方法
例如:
public synchronized void show (String name){
// 需要被同步的代码;
}
同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁:
- 锁对象 可以是任意类型
- 多个线程对象 要使用同一把锁
**同步方法:**使用synchronized修饰的方法,就叫做同步方法,保证线程执行该方法的时候,其他线程只能在方法外等着
第三种方法:Lock锁-
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。
-
锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
-
可重入锁:外层方法获取到锁之后,在内层的调用方法中也能获取这把锁;
非公平锁:线程释放锁资源后,线程们一拥而上获取锁,而不是规矩的排队等待获取锁;
独占式锁:当前的锁被一个线程使用时,其他线程不能来使用。
-
ReentarntLook作为显示锁,它拥有与synchronized相同的并发性和内存语义可用来修饰代码块;在使用时需要手动加锁,手动释放锁。可以显示加锁、释放锁
**sleep()*使当前线程进入休眠阻塞状态,不释放锁,结束休眠后回到就绪状态
**wait()*使当前线程进入等待阻塞状态,释放锁



