javaSE知识学习总结

包（package）

作用：分层次，存储类和接口

导入（import）：java.lang包无需导入

枚举类(enum)

与单例类似，是含有限个实例对象的类，特殊的类

其构造方法私有，但对外提供获得实例对象的方法

类（class）

定义：一类事物的抽象，一种模板，而对象是这种模板的实例

作用：分层次

分类：

抽象类：关键字abstract修饰的类，即抽象类

              有抽象方法的类一定是抽象类，

              抽象类未必有抽象方法

              在继承关系中，若继承抽象类不重写其抽象方法，自身也得成为抽象类，或写出空实现也可

普通类：

全名：包名+类名，（包名.类名）

结构：

       包名和导入类或接口

变量：

       静态变量：定义于类中(static)，归属于类，通过类名调用，所有对象共用的是同一个

       成员变量：定义于类中，归属于对象，通过对象名调用，所有对象各用各的

       局部变量：定义于方法体、循环体中，超出范围则失效

代码块：

       静态代码块：类的初始化，用来初始化静态变量 被static修饰

       构造代码块：类的初始化，用来初始化普通成员变量

方法：

       作用：代码提取，功能聚合

       格式：构造方法：访问修饰符 类名(参数列表){}

                方法：访问修饰符 (static) 返回值类型 方法名(参数列表){}

       分类：构造方法：用于创建对象，被子类构造方法调用

                静态方法：定义于类中，归属于类，通过类名调用，所有对象共用一个

                成员方法：定义于类中，归属于对象，通过对象名调用，所有对象各用各

层次

实例变量，实例方法：

可以被继承，可以被重写

所有对象各有一个，类内所有非static皆可调用，类外通过对象名调用

静态变量，静态方法：

可以被继承，不可被重写，但若子类重写定义同名的静态，则父类的会被隐藏，不算重写

单一类所有对象共用一个，类内皆可调用，类外通过类名调用

对于继承到的静态变量、方法，只能在父类定义的地方修改，若子类重写定义了同名的静态方法、变量（不算重写），则在子类中修改即可

构造方法，构造代码块，静态代码块：

关系

继承

实现

关联（聚合）：一各类的属性是另一个类

依赖：一个的方法参数是另一个类

源类（Object类）

hashcode()：作用：返回对象的内存地址，十进制形式

equals()：

作用：（意义上）判断对象是否为同一个，

默认：比较对象的hashcode()值

复写：由业务逻辑修改，由IDE自动生成

多态：equals()内的参数是Object类的引用

toString():

       作用：调试，可以根据需求重写逻辑，改变返回值。其返回值为System.out.println(参数)的输出

       默认：返回值为  包名.类名@内存地址（十六进制形式）

       多态：通过System.out.println()内传入的参数是Object类的引用

常用类

基本类型包装类

       作用：与基本类型使用一致，且多了许多方法

       定义：封装基本类型的类

       分类：

              四大类八小类：

Integer：

       parseInt(String s) : int          静态方法

       valuesOf(String s) : Integer  静态方法

       intValue() : int       获取值   实例方法

Byte,Short,Long,Float,Double,Character,Boolean：

       方法：重写 hashcode(),equals(),toString()

       自动装箱，自动拆箱(编译器现象)：

              Integer中的[-128~127]的对象已缓存，使用自动拆装箱的形式时对象是同一个，使用new 的方式时是新的对象

              自动装箱：Integer a = 3;// Integer a = new Integer(3);

              自动拆箱：int b = a;  //int b = a.value();//int b = a.intValue()

字符串类

String:

       弊端：字符串拼接造成内存碎片，即垃圾

       封装了char[]：

              String s = “abc” a,b,c是静态区已存在的对象，String对象的Char[],指向了静态区a,b,c对象，  String  a = new String(“abc”),类似自动装箱

       方法：

              重写equals() 引用类型比较时，字符串相等比较，不忽略大小写

              重写hashcode()

              重写toString()

              startsWith()：模糊查询，左匹配

              indexOf()：返回指定字符在字符串中的位置

              length()：字符串长度

              subString()：截取字串，起始位置，截至位置，左闭右开

StringBuffer

       作用：解决了内存碎片问题      自动垃圾回收系统，回收堆内的垃圾

       方法：

              toString()：

              delete()：删除指定位置的字符串，起始到结束

              insert()：插入到指定位置

              reverse():反转

              subString()：截取字串，起始位置，截至位置，左闭右开

              append():插入到末尾

StringBuilder

       是StringBuffer的非线程安全版本，不适用多线程，在单线程下性能更高

目录文件类

       File

访问文件名或路径

1）String getName()  返回File对象所表示的文件名或文件路径

2）String getPath()    返回File对象所对应的相对路径名。

3）File getAbsoluteFile() 返回File对象的绝对路径文件

4）String getAbsolutePath() 返回File对象所对应的绝对路径名

5）String getParent（） 返回File对象所对应目录的父目录

6) boolean renameTo(File dest) 重命名File对象的文件或目录

7）Path toPath() 转化为Path对象

文件检测

1)boolean exists()   判断File对象的文件或目录是否存在

2)bool canWrite()     判断File对象是否可写

3)boolean canRead()判断File对象是否可读

4)boolean isDirectory() 判断File对象是否是目录

5)boolean isFile() 判断File对象是否是文件

6)boolean  isAbsolute() 判断File对象是否采用绝对路径

文件信息

1)long length() ; File对象对应文件的长度

2)long lastNodified()   File对象最后修改的时间

文件操作

1）boolean createNewFile() ;检查文件是否存在，当文件不存在时创建一个新的文件

2) boolean delete()             删除File对象所对应的文件或目录 

目录操作

1)boolean mkdir()       创建一个File对象所对应的路径

2)String[] list()         列出File对象所有的子文件名和路径名

3)File[] listFile()     列出File对象的所有子文件或路径

4)static File[] listRoots()   列出系统所有的根路径

Files

  create delete read write copy move walkFileTree

Path

  getFileSystem() : FileSystem

  getNameCount() : int

  getName(int) : Path

  getFileName() : Path

  getParent() : Path     获取父路径

  getRoot() : Path        获取根路径

  toString() : String

  toUri() : URI

  toFile() : File

toRealPath() : Path

toAbsolutePath(LinkOption) : Path

Paths

static Path get(URI uri)    直接通过路径返回Path对象

static Path get(String first, String...more)       通过给出的String字符串组装成一个Path对象

数学工具类

       Math:     random() 返回值为伪随机数[0,1)

       DecimalFormat:格式化数字使用

       Random:生成伪随机数比Math.random()更强大

时间日期类

       Date:                        不被推荐使用，但人仍可以用来保存中间结果

       Calender:       Calender.getInstance()    单例的获取

       SimpleDateFormat:      ”yyyy-MM-dd HH:mm:ss” 构造器需传入模式字符

对象

作用:类的实例化，一种层次结构的体现

地址:

对象：存储在堆内存

引用：名存在栈内存

分类:

引用对象：引用指代对象，但非对象      Son s = new Son();

匿名对象：匿名数组 new Double[]{1.2, 2, 4};

接口(interface)

作用：解决单继承的不足，进而多实现，与类一样是一种层次结构

本质：方法的集合，类的另一种形式

特点：

  没有构造方法，不能实例化

  所有方法都是默认的 public abstract ,编译器默认的

  都是静态常量 public static final 编译器默认的

  类可以实现多个接口，接口继承实现多个接口，类只能继承一个类，类只能继承一个接口

引用(引用变量)

作用：存储对象(数值)内存地址，引用指代对象却并非对象

分类：

       基本数据类型引用：存储的是数据本身，字面量，IEEE754标准，规定了数值表示格式

       引用数据类型引用：存储的是，引用指代的实际对象的内存地址

集合框架

集合

Throwable ，--Iterator

Collenction size,isEmpty,,contains,add,remove,clear,equals,containAll,toArray

List  有序可重复列表，插入取出有序 使用Collenctions.sort(List)排序

  ArrayList 

底层实现数组，逻辑上连续的物理存储也连续,决定了性能

查询，修改遍历比较快，删除增添慢，实际上删除增添是新建数组遍历copy的过程

  LinkedList

底层实现双向链表，逻辑上连续的物理存储未必连续,决定了性能

增删块，查改遍历慢，增删只是在链表中加删存储节点

Set  不重复集合，插入取出无序，有序也是意外

  HashSet 散列集

      重复元素会覆盖之前的元素，去重逻辑取决于存储实现类的equals(),hashcode()

      用于快速查询，写入块，如无必要则不建议排序一个不在意顺序的数据

      散列打乱存放

  TreeSet 树集

    排序且去重，按什么排序，就按什么去重，可重写equals()决定去重逻辑

    排序花费时间，写入慢，查询快，能精准判断每个对象的位置

Iterator()方法

  迭代器：返回一个实现了Iterator接口的的对象

    hasNext(),next(),remove()

  for each增强for循环的实现原理

  Map  键值对映射图

HashMap

  k -> v映射，无序不去重

    K类重写hashcode和equals

      重复元素可进入，但会覆盖之前的元素

TreeMap

  k -> v映射，有序不去重

    K类实现Compareable或Comparator

      重复元素可进入，但会覆盖之前的元素

框架图

设计模式（二十三种+？）

单例模式

  单例实现类，业务中只需要一个对象，创建过的对象反而造成资源浪费

封装单个静态的volatile的对象，单例为空时才new

  使用了volatile关键字后，重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前。

私有构造方法

公有的静态的单实例提供方法 getInstance

线程安全：

锁synchronized

双重锁检查机制 提升了性能，降低了锁力度

  为空时加锁，加锁时在判断，为空时在new对象

工厂模式

工厂实现类，多态的应用

  生产的是某一类的子类  返回值类型多态（与之对应参数多态）

观察者模式

代理模式

封装

定义

用访问修饰符将类的数据隐藏(分层)，控制用户对类的修改和访问数据的程度

作用

分层次

让代码更容易理解，也加强了代码的安全

访问修饰符

private           本类，可访问                           不会被继承

default          本类,包内，可访问                    可能会被继承,看在不在同一包

protected      本类,包内,子类，可访问            会被继承，且继承后的权限可扩张

public            公共，可访问                           会被继承

重载

定义

功能相似或相同的方法

作用

减少代码量

特点

方法同名不同参

相同参数数量的，参数类型必须不同

不同参数数量的，参数类型可以相同

与访问修饰符和返回值类型无关

继承（extends）

定义

已有类中派生新的类，吸收已有类的属性方法

作用

减少代码量,结构体系更清晰

特点

java只支持单继承

继承关系可传递

访问修饰符决定继承了什么

实现(implements)

定义

已有接口中派生新的类，吸收已有接口的方法

特点

类可以实现多个接口，接口继承实现多个接口，类只能继承一个类，类只能继承一个接口

重写(override)

定义

子类，重定义继承自父类的方法

特点

重写方法的返回值，方法名，参数列表和父类完全一致

规则

子类重写方法的权限不能超过父类定义时的权限，protected除外

转型

向上转型

定义

  父类引用指向子类对象 Dad d = new Son();

作用

  调用父子类中共有的方法，考虑重写 d.say();

向下转型

定义

  将经历过向上转型的引用重新转为子类引用

      核实是否发生过向上转型   dad instancef Son

      将父类对象引用复制给子类引用  Son son = (son) d;

作用

  访问子类特有的方法  ((Son)dad).song();

instanceof运算符

作用

核实是否发生过向上转型 即左边引用指向的对象是否为右边类(或其子类)的对象

    dad instanceof Son

    son instanceof Son

计算值

    计算值为boolean

多态

优点

减少工作量，提升编程效率，可读性

要点

所有public 非static 的方法都是多态的

多态指同一个实体具有多种形态

条件

继承

重写

向上转型    特殊情况下，要使用向上转型

 

分类

参数多态

返回值类型多态

多态原理图如下，实际上可能不会有特别长的继承链，这里只是为了帮助理解

异常 

定义

是Java中一种识别及响应错误的一致性机制，是特殊的类

作用

使程序更健壮，易于调试

补充  

Throwable是Java异常类的父类，Object是所有Java类的父类

体系

Throwable(可抛出)

    Error(错误)(不可挽回)

        VirtuMachineError

            StackOverFlowError

            OutOfMemoryError

        AWTError

        ......

    Exception(异常)(也许可挽回)

        IOException

            EOFException

            FileNotFountException

        RunTimeException

            ArrithMeticException

            MissingResourceException

                ClassNotFoundException

                NullpointerException

                IllegalArgumentException

                ArrayIndexOutOfBoundsException

                UnknowTypeException

                .......

        ......

    StackRecorder

异常处理和捕获

抛出异常

throws(声明肯抛出)(方法名旁)

沿方法调用轨迹，逐级向上

throw(直接抛出异常对象)(方法体内)

程序在执行时发生异常，会自动生成异常类对象   

    程序也可自行抛出异常

捕获异常

try

可能出现异常的部分

    出现异常的语句中断异常

    出现异常之后语句不执行

catch

异常处理的逻辑

参数的比较是instanceof逻辑

finally

释放资源的部分  

   无论try 和catch如何执行finally最终一定会执行

IO流

作用:数据的传输

分类

字节流

InputStream

    FileInputStream

        文件流  能处理二进制文件也能处理文本

    BufferedInputStream

        缓冲流  能处理二进制文件也能处理文本

            BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file1))

OutputStream

    FileOutputStream

        文件流  能处理二进制文件也能处理文本

    BufferedOutputStream

        缓冲流  能处理二进制文件也能处理文本

            BufferedOutputStream bis=new BufferedOutputStream(new FileOutputStream(file2))

    PrintStream

字符流

    Reader

        FileReader

            文件流  只能处理文本文件

        BufferedReader

            缓冲流  只能处理文本文件

                BufferedReader br=new BufferedReader(new FileReader(name))

                readLine()方法

    Writer

        FileWriter

            文件流  只能处理文本文件

        BufferedWriter

            缓冲流  只能处理文本文件

        PrintWriter

            只能处理文本文件

                PrintWriter pw=new PrintWriter(name)

println()方法

转换流（字节到字符）（构造方法第二个参数编码）

    InputStreamReader  将InputStream转化为Reader

    OutputStreamWriter  OutputStream转化为Writer

二级制处理流

DataInputStream

DataOutputStresam

序列化

作用  保持现有(内存中)对象的状态(到磁盘中)

Java对象创建机制

    new 用构造方法

    反序列化

反射机制

    clone()  深clone 浅clone

文件类

File,Files,Path,Paths

多线程

程序

    存在磁盘中的引用

进程

    运行在内存中的程序

线程

概念

    轻量级的进程

        同一进程下，可有许多的线程，这些线程共享堆内存和方法区

        同一进程下，不同线程有不同的栈内存和程序计数器

作用

    提高进程的执行效率

线程安全

    synchronized  锁机制

        锁对象

        锁方法

        锁代码块    双重锁检查

        加锁效率低

    线程安全类

优先级

    整数1~10    默认为5   

        优先级高的未必比优先级低的执行快，只是执行快的概率更大

如何设置  setPriority()

new Thread().setPriority(9)

生命周期

    新建  使用new，Thread或其子类创建完对象后

    就绪  线程对象执行start()后    

会等待cpu分配资源  不确定性，

    运行

        执行run()  获得cpu资源后接会执行

    阻塞

        wait(),sleep()睡眠,suspend()挂起，等等某个锁对象,失去资源占用后 处于

    死亡

        执行完run()方法  或stop()和destroy()强制终止

多线程

继承Thread

    run()    欲实现多线程的部分

实现Runnable

    run()    欲实现多线程的部分

属性Lock  Lock是Java实现并发编程的框架类

    Lock lock = new ReentrantLock()

并行

    程序真正同时运行

并发

    程序表面同时运行，实际上是执行一会这个程序，没执行完又去执行其他程序了，同一时刻只运行着一个程序

三大特性

原子性

由Java内存模型来直接保证原子性变量操作，如read,load,assign,use,store,write

基本数据类型具备原子性(long和duoble 除外)

若需要更大的原子性支持可使用Lock和synchronized关键字

可见性

可见性与JVM内存模型有关，非可见性的变量需线程通过主内存来Save和Load。可见性并不能保证线程安全

有序性

不保证有序性指JVM存在机器级(编译时、汇编语言级)的指令优化，但当多个线程对同一个变量的状态依赖时就不能保证符合逻辑

  volatile关键字的说明见博客https://blog.csdn.net/weixin_42231373/article/details/84643771

网络编程

网络协议模型

OSI的体系结构                TCP/IP体系结构             五层协议的体系结构

开发系统互连基本参考模型

7  应用层                      应用层                       5  应用层

6  表示层

5  会话层

4  运输层                      运输层(TCP或UDP)            4  运输层

3  网络层                      网际层                       3  网络层

2  数据链路层                                               2  数据链路层

1  物理层                      网络接口层                   1  物理层

TCP协议  传输控制协议

是一种面向连接的、可靠的、基于字节流的传输层通信协议

三次握手：建立连接

图片源自 计算机网络 

   

第一次:

客户端 - - > 服务器 此时服务器知道了客户端要建立连接了

第二次:

客户端 < - - 服务器 此时客户端知道服务器收到连接请求了

第三次:

客户端 - - > 服务器 此时服务器知道客户端收到了自己的回应

到这里, 就可以认为客户端与服务器已经建立了连接

 

   

四次挥手：释放连接

图片源自 计算机网络 

 

   

UDP协议  用户数据报协议

一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务

IP协议  网络地址协议

Socket编程

ServerSocket类

accpet()  等待客户端(一个socket)连接,线程阻塞

new ServerScocker(port)

Socket类

    close()  释放连接

    new Scocker(“ip”,port)

 

一些关键字

static

属于面向过程

可以被继承，不能被重写，可以通过子类访问，只能在父类修改

    不具备多态

final

   修饰

       类

           修饰的类不能被继承    打破继承链

       实例方法

           修饰的方法不能被重写  可以被继承(各对象各有一个，但值一样)

       实例变量

           修饰的变量不能被修改  等于常量

   注意

       修饰的变量必须显性初始化

       修饰引用，引用只能指向一个对象，该引用不可被修改，但对象内部可变

this

本类，区分参数和实例变量

本类，一个构造方法中访问另一个构造方法  this();

本类，非static方法中访问当前类(考虑继承，向上)的方法  this.drive()

super

访问父类的方法                  super.driver()

子类构造方法中访问父类构造方法  super();