基础总结-Java基础（1）

文章目录

1.前言

2.概要

3.细节

3.1. 基本概念

3.1.1语言特点

3.1.2与C++比较

3.1.3 main函数知识

3.1.4 Java程序初始化顺序

3.1.5 作用域与可见性

3.1.6 构造函数

3.1.7 标识接口

3.1.8 clone 方法

3.1.9 反射

3.1.10 创建对象的四种方式

3.1.11 package 作用

3.2 面向对象

3.2.1 与面向过程区别

3.2.2 特性

3.2.3 这种开发方式优点

3.2.4 继承

3.2.5 组合和继承区别

3.2.6 多态

3.2.7 覆盖和重载区别

3.2.8 抽象类与接口异同

3.2.9 内部类

3.2.10 如何获取父类类名

3.2.11 this

3.2.12 super

3.3 关键字

3.3.1 变量命名

3.3.2 assert

3.3.3 static

3.3.4 switch

3.3.5 volatile

3.3.6 instanceof

3.3.7 strictfp

3.3.8 null

3.4. 基本类型与运算

3.4.1 基本数据类型

3.4.2 不可变类

3.4.3 类型转换

3.5.字符串与数组

3.5.1 字符串创建与存储机制

3.5.2 ==、equals和hashCode区别

3.5.3 String,StringBuffer,StringBuilder

3.5.4 其他

3.6 异常处理

3.6.1 finally块执行时机

3.6.2 finally代码块不是一定会被执行

3.6.3 Error

3.6.4 Exception

3.7 Java平台与内存管理

3.7.1 Java平台与其他语言平台的区别

3.7.2 JAVA代码的执行

3.7.3 java源码编译机制

3.7.4 类加载机制

3.7.5 类执行机制

3.7.6 内存空间

3.7.7 内存分配

3.7.8 内存回收

3.7.9 内存泄露

3.8 分布式Java应用

3.8.1 基于消息方式实现系统间的通信

3.8.2 基于远程调用方式实现系统间的通信

3.8.3 基于开源框架

3.9 多线程

3.9.1 线程资源同步机制

3.9.2 线程交互机制

3.9.3 线程状态

3.9.4 sleep()与wait()方法的区别

3.9.5 守护线程

3.9.6 join

3.10 IO

3.10.1 流本质

3.10.2 流分类

3.10.3 装饰者模式

3.10.4 Java Socket

3.10.5 NIO

3.10.6 序列化

3.10.7 如何实现序列化

3.10.8 序列化特点

3.10.9 反序列化

3.10.10 外部序列化

前言

大学期间接触 Java 的时间其实比较短，学习过程中，让我发觉基础的重要性。互联网发展太快了，各种框架各种技术更新迭代的速度非常快，可能你刚好掌握了一门技术的应用，它却已经走在淘汰的边缘了。

而学习新技术总要付出一定的时间成本，那么怎么降低时间成本呢？那就是打好基础，技术再怎么革新，底层的东西也很少会变动，牢固的基础会帮助你在各种新技术的学习中游刃有余，快速上手。

因为我选择的方向是后台开发，所以谈谈我认为的基础有哪些。其他方向肯定也有自己的体系，从低层到高层，可以自己摸索。后台的话，我觉得网络知识，各种协议，web 知识，数据库知识，Linux 基本操作以及自己选择的后台语言知识，这些是最基础最需要牢固掌握的。

所以从今天起，会出一系列与后台基础相关的博文，一是对自己过去学习的一个总结，二是分享出来，希望可以帮助到需要的人。

这个基础系列我希望是像过目录一样给大家一个大体的提纲，我在大学中无论学什么科目，临考前都要做的工作就是对着书的目录做个总览，对每个知识点做到心中有数，举一反三才是对该科目真的了解。因此抛砖引玉的列了这样一个提纲，在使用的时候最好就是先大体浏览一遍，对自己知道的东西加以熟悉，对自己稍感陌生的东西做到查漏补缺，返回去把遗忘的感到不熟悉的地方重温一遍，对自己整体基础的提高尤其重要。

概要

Java 基础我做了 10 个方面的总结，包括基本概念，面向对象，关键字，基本类型与运算，字符串与数组，异常处理，Java 平台与内存管理，分布式 Java 应用，多线程，IO。以下对这些内容做一些简单的总结。

Java 基础大纲

细节

1. 基本概念

1.1 语言特点

• 纯面向对象
• 平台无关性
• 内置类库
• 支持web
• 安全性
  • 防止代码攻击

• 健壮性

  • 强类型机制
    • 垃圾回收器
    • 异常处理
    • 安全检查机制

• 去除C++中难以理解易混淆的特性

1.2 与C++比较

• 解释编译混合型语言，执行速度慢，跨平台
• 纯面向对象，只有类，不存在全局变量或全局函数
• 无指针，无多继承，可多实现
• 垃圾回收器自动管理内存

1.3 main函数知识

• Java程序入口方法
• 可由final，synchronized修饰，不能用abstract

1.4 Java程序初始化顺序

• 静态优于非静态
• 父类优于子类
• 按照成员变量的定义顺序
• 总共10个

1.5 作用域与可见性

• 静态变量属于类
• 局部变量属于花括号
• 成员变量看下一条
• public、protected、default、private 可见性依次递减

1.6 构造函数

• 与类名相同，无返回值
• 可重载，不能被继承，即不能被覆盖
• 参数个数任意
• 伴随new 一起调用，为系统调用
• 完成对象的初始化工作
• 子类可通过super显式调用父类。父类没有提供无参，子类必须显式调用
• 未定义，默认无参，修饰符取决于类修饰符

1.7 标识接口

• 无任何方法声明
• 表示实现它的类属于一个特定的类型

1.8 clone 方法

• 实现Cloneable接口
• 重写Object类中的clone()
• clone()中调用super.clone()
• 把浅复制引用指向新的克隆体

1.9 反射

• 定义：允许程序在运行时进行自我检查，也允许对其内部成员进行操作
• 功能
  • 得到一个对象所属的类
  • 获取一个类的所有成员和方法
  • 运行时创建对象
  • 在运行时调用对象的方法
• 获取类的方式
  • class.forName(“类路径”)
  • 类名.class
  • 实例.getClass()

1.10 创建对象的四种方式

• new
• 反射机制
• clone()
• 反序列化

1.11 package 作用

• 提供多层命名空间，解决命名冲突
• 对类按功能进行分类，使项目组织更加清晰

2. 面向对象

2.1 与面向过程区别

• 层次逻辑关系不同。
  • 面向对象是通过类的层次结构来体现类之间的继承与发展
  • 面向过程是通过模块的层次结构概括模块与模块间的关系与功能
• 数据处理方式不同与控制程序方式不同
  • 面向对象是数据与操作封装成一个整体，通过事件驱动来激活和运行程序
  • 面向过程是数据单独存储，控制程序方式上按照设计调用或返回程序

2.2 特性

• 抽象
• 继承
• 多态
• 封装

2.3 这种开发方式优点

• 开发效率高。代码重用
• 保证软件的鲁棒性。经过长期测试的已有代码
• 保证软件的高可维护性。设计模式成熟

2.4 继承

• 单继承
• 只能继承父类的非私有成员变量和方法
• 同名成员变量，子类覆盖，不会继承
• 相同函数签名，子类覆盖，不会继承

2.5 组合和继承区别

• 组合：在新类中创建原有类的对象。has a
• 继承是 is a

2.6 多态

• 方法重载
  • 编译时多态
• 方法覆盖
  • 运行时多态
• 成员变量无多态概念

2.7 覆盖和重载区别

• 子父类关系，垂直；同类方法间关系，水平
• 一对方法发生关系；多个方法发生关系
• 参数列表相同；参数列表不同
• 调用的方法根据对象的类型决定；根据调用时的实参表决定方法体

2.8 抽象类与接口异同

同

• 不能被实例化
• 接口的实现类实现了接口，抽象类的子类实现了方法，才能被实例化

异

• 接口只能定义方法，不能实现；抽象类可以有定义和实现
• 接口需要被实现；抽象类需要被继承
• 接口强调特定功能的实现；抽象类强调所属关系
• 接口成员变量默认为 public static final，成员方法 public abstract
• 抽象类变量默认default，方法不能用 private、static、synchronized、native 修饰

2.9 内部类

• 静态内部类
  • static 修饰
  • 只能访问外部类中的static数据
• 成员内部类
  • 与实例绑定
  • 不可定义静态属性和方法
  • 外部实例化后，该内部类才能被实例化
• 局部内部类
  • 代码块内
  • 不能被public、protected、private以及static修饰
  • 只能访问final 局部变量
• 匿名内部类
  • 无类名
  • 无构造函数，必须继承或实现其他类
  • 原则
    • 无构造函数
    • 无静态成员，方法和类
    • 不能是public、protected、private、static
    • 只能创建匿名内部类的一个实例
    • new 后面有继承或实现
    • 特殊的局部内部类

2.10 如何获取父类类名

• 利用反射：obj.getClass().getSuperClass().getName()
• 不使用super.getClass()原因：该方法在 Object中为final与native，子类不能覆盖，返回此Object运行时类

2.11 this

• 指向当前实例对象
• 区分成员变量与方法形参
• 可以直接做返回值，返回该类

2.12 super

• 访问父类成员变量或方法
• 子类同名会覆盖，访问父类只能通过super
• 子类构造函数需显示调用父类构造函数时，super()必须为构造函数的第一条语句

3. 关键字

3.1 变量命名

• 英文字母
• 数字
• _和$
• 不能包含空白字符
• 首字符不能为数字
• 保留字不能做标识符
• 区分大小写

3.2 assert

• 软件调试
• 运行时开启 -ea

3.3 static

• 特定类的统一存储空间，类绑定
• 成员变量：属于类，内存中只有一个复制
• 成员方法：调静态数据。可实现单例模式
• 代码块：初始化静态变量，只被执行一次
• 内部类：不能与外部类重名，只能访问外部类静态数据(包括私有)

3.4 switch

• 多分支选择
• 整型或字符类型变量或整数表达式
• Java 7 开始支持 String。原理是String的hashCode()返回的int类型值匹配

3.5 volatile

• 保证线程间的可见性
• 从内存中取数据，而不是缓存
• 不保证原子性

3.6 instanceof

• 二元运算符
• 判断一个引用类型的变量所指向的对象是否是一个类的实例
• 即左边对象是否是右边类的实例

3.7 strictfp

• 精确浮点
• 确保浮点运算的准确性
• 若不指定，结果依赖于虚拟机平台
• 指定后依赖于统一标准，保证各平台的一致性

3.8 null

• 不是合法的Object实例
• 无内存
• 表明该引用目前没有指向任何对象

4. 基本类型与运算

4.1 基本数据类型

• int长度
  • byte(8 bit)
  • short(16 bit)
  • int(32 bit)
  • long(64 bit)
• float长度
  • 单精度(32 bit float)
  • 双精度(64 bit double)
• boolean 类型变量的取值
  • true
  • false
• char数据类型:Unicode字符(16 bit)
• void:java.lang.Void 无法直接对其进行操作

4.2 不可变类

• 实例创建后，值不可变
• 所有的基本类型的包装类+String
• 优点
  • 使用简单
  • 线程安全
  • 节省内存
• 缺点:会因为值的不同而产生新的对象，导致无法预料的问题

4.3 类型转换

• 隐式类型转换
  • 低精度到高精度
  • byte->short->char->int->long->float->double
• 显式类型转换
  • 反之
  • 可能会损失精度
• 类型自动转换
  • 低到高
  • char类型会转换为其对应的ASCII码
  • byte、char、short参与运算自动转为int，但”+=”，不转
  • 基本数据类型与boolean不能相互转换
  • 多种类型混合运算，自动转成容量最大类型

5. 字符串与数组

5.1 字符串创建与存储机制

• 堆
• 常量池
• new String(“abc”)创建1个或2个对象

5.2 ==、equals和hashCode区别

• == 比较引用，内存
• 未覆盖，同==；比较内容
• hashCode鉴定对象是否相等，返回整数

5.3 String,StringBuffer,StringBuilder

• String:不可变，执行效率最低
• StringBuffer:可修改，线程安全，效率较高
• StringBuilder:可修改，线程不安全，效率最高

5.4 其他

• 数组初始化方式
• length属性和length()方法

6. 异常处理

6.1 finally块执行时机

• 若try中有return，在return前
• 若try-finally或catch-finally中都有return，finally会覆盖

6.2 finally代码块不是一定会被执行

• 程序进入try之前出现异常
• try中调用System.exit(0)

6.3 Error

严重错误，不可恢复

6.4 Exception

• 可恢复，编译器可捕捉
• 检查性异常
  • IO
  • SQL
• 运行时异常
  • JVM处理
  • NullPointException
  • ClassCastException
  • ArrayIndexOutOfBoundsException
• 出现异常后，一直往上层抛，直到遇到处理代码或最上层
• 多态。若先捕获基类，再捕获子类。子类处理代码将永远不会得到执行

7. Java平台与内存管理

7.1 Java平台与其他语言平台的区别

• 纯软件，包括JVM与JAVA API
• JVM虚拟，不跨平台

7.2 JAVA代码的执行

• 代码编译为class：sun jdk 中javac
• 装载class：ClassLoader
• 执行class
  • 解释执行
  • 编译执行
    • client compiler
    • server compiler

7.3 java源码编译机制

• 词法分析器组件：Token流
• 语法分析器组件：语法树
• 语义分析器组件：注解语法树
  • 将语法树中的名字、表达式等元素与变量、方法、类型等联系到一起
  • 检查变量使用前是否已声明
  • 推导泛型方法的类型参数
  • 检查类型匹配性
  • 进行常量折叠
  • 检查所有语句都可到达
  • 检查变量的确定性赋值
  • 解除语法糖
  • 将泛型JAVA转成普通Java
  • 检查所有checked exception都被捕获或抛出
  • 将含语法糖的语法树转成简单语法树eg:foreach，自动折叠
• 代码生成器组件：字节码

7.4 类加载机制

• 装载：全限定名+类加载器加载类
• 链接
  • 校验
    • 格式不符，抛VerifyError
    • 加载引用的类失败：抛NoClassDefFoundError
  • 准备：静态变量默认初始化
  • 解析：属性、方法验证(可选)
• 初始化(不是类加载必须触发的)
  • 静态初始化代码
  • 构造器代码
  • 静态属性初始化
  • 触发时机
    • 调用了new
    • 反射调用了类中的方法
    • 子类调用了初始化
    • JVM启动过程中指定的初始化类
      • Bootstrap Class Loader：$JAVA_HOME/jre/lib/rt.jar
      • Extension Class Loader：$JAVA_HOME/jre/lib/ext/*.jar
      • System Class Loader：$CLASSPATH
      • User Defined Class Loader

7.5 类执行机制

• 解释执行

  • JVM字节码为中间代码，由JVM在运行期对其解释并执行
    • invokestatic
    • invokevirtual
    • invokeinterface
    • invokespecial
  • 基于栈
    • 代码紧凑，体积小
    • 线程创建后，产生PC和Stack
    • 指令解释执行
    • 栈顶缓存：栈顶值缓存在寄存器上
    • 部分栈帧共享

• 编译执行

  • client compiler
    • 轻量级，占内存少
    • 方法内联
    • 去虚拟化
    • 冗余消除
  • server compiler
    • 重量级，占内存多
    • 逃逸分析是C2进行很多优化的基础
    • 标量替换：用标量替换聚合量
    • 栈上分配
      • 若对象未逃逸，C2会选择在栈上直接创建Point对象实例，而不是在堆上
      • 栈上分配更快速，对象易回收
    • 同步消除：如果发现同步的对象未逃逸，那也没有同步的必要。C2会去掉同步代码块

7.6 内存空间

• 方法区：类信息，线程共享
• 堆
  • 对象实例+数组
  • 分代管理
    • 新生代
    • 旧生代
• 本地方法栈：支持native方法，Sun JDK的实现中本地方法栈和JVM方法栈是同一个
• PC寄存器：线程私有
• JVM方法栈：线程私有

7.7 内存分配

• Java对象，堆上分配，分配需加锁，开销大
• 当堆上空间不足–>GC–>仍不足–>抛OutOfMemory
• Sun JDK 为新创建的线程在Eden上分配TLAB
• 多个小对象比大对象分配更高效
• 基于逃逸分析直接从栈上分配

7.8 内存回收

• 收集器
  • 引用计数收集器
    • 计数器增减有消耗
    • 不适合循环引用
  • 跟踪收集器
    • 集中式管理
    • 全局记录数据的引用状态
    • 从根集合扫描对象，可能会造成应用程序暂停
    • 三种实现算法
      • 复制
        • 适用于回收空间中存活对象较少
        • 缺点：需要增加一块空的内存空间及进行对象的移动
      • 标记-清除：会产生内存碎片
      • 标记-压缩：不产生内存碎片
• Sun JDK中可用GC
  • 新生代
    • 串行GC(Serial GC)：复制算法
      • Minor GC
      • 强软弱虚
    • 并行回收GC(Parrallel Scavenge)：扫描复制多线程
    • 并行 GC(ParNew)：配合旧生代 CMS
  • 旧生代和持久代可用GC
    • 串行：标记压缩+清除
    • 并行：标记压缩
    • 并发：CMS
      • 1. 标记：暂停
      • 1. 并发标记：恢复，轮询着色对象，以标记它们
      • 1. 重新标记：暂停
      • 1. 并发收集：恢复
      • CMS内存回收易产生碎片，但是它提供了整理碎片的功能
      • 浮动垃圾：CMS回收时产生应该回收但要等到下次CMS才能被回收掉的对象
• Full GC
  • 对新生代旧生代及持久代都进行的GC
  • 触发的四种情况
    • 旧生代空间不足
    • 持久代空间满
    • CMS GC出现promotion failed和concurrent mode failure
    • 统计得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间

7.9 内存泄露

• 一个不再被程序使用的对象或变量还在内存中占有存储空间
• 符合垃圾回收标准
  • 对象赋空值null
  • 给对象赋予新值，重新分配了内存空间
• 泄露的两种情况
  • 堆中申请的空间没有被释放
  • 对象不再被使用，但仍然存活在内存中
• 泄露原因
  • 静态集合类
  • 各种连接
  • 监听器
  • 变量不合理的作用域
  • 单例模式

8. 分布式Java应用

8.1 基于消息方式实现系统间的通信

• TCP/IP+BIO
  • socket.setSoTimeOut()设置等待响应的超时时间
  • 一连接一线程
  • 缺点：无论连接是否真实，都要创建线程
  • BIO下服务器端所能支撑的连接数目有限
• TCP/IP+NIO
  • Channel
    • SocketChannel：建立连接，监听事件，操作读写
    • ServerSocketChannel：监听端口，监听连接事件
  • Selector：获取是否要处理的事件
  • Buffer：存放处理的数据
  • NIO Reactor模式，通过注册感兴趣的事件及扫描是否有感兴趣的事件发生，从而做出相应的动作
  • 多个请求，连接复用
  • 只有在有真实的请求时，才会创建线程
  • 一请求一线程
• UDP/IP+BIO
  • DatagramSocket：负责监听端口，读写数据
  • DatagramPacket：作为数据流对象进行传输
• UDP/IP+NIO
  • DatagramChannel：监听端口，进行读写
  • ByteBuffer：数据流传输
• NIO好处：只在有流要读取或可写入流时才做出相应的IO操作，而不像BIO方式阻塞当前线程

8.2 基于远程调用方式实现系统间的通信

• 远程调用方式
  • 系统间通信和系统内一样
  • 让使用者感觉调用远程同调用本地一样
• 基于Java自身技术
  • RMI：客户端代理，stub，封装对象，序列化为流，TCP/IP BIO，Skeleton，反序列化，获取对象实例，调用
  • WebService
    • 1. 服务端的服务生成WSDL文件
    • 1. 将应用+WSDL文件放入HTTP服务器
    • 1. 借用Java辅助工具根据WSDL文件生成客户端stub代码
    • 1. stub将产生的对象请求信息封装为标准化的SOAP格式数据，并发请求到服务器端
    • 1. 服端在接收到SOAP格式数据时进行转化，反射调用相应的Java类
    • SOAP优点支持跨语言，缺点对复杂对象结构难支持

8.3 基于开源框架

• Spring RMI

9. 多线程

9.1 线程资源同步机制

• JVM保证以下操作顺序
  • 同一线程操作
  • 对于main Memory 上的同一个变量的操作
  • 对于加了锁的main Memory上的对象操作
• 为避免资源操作的脏数据问题，JVM提供了
  • synchronized
  • volatile
  • lock/unlock
  • 目的是控制资源竞争

9.2 线程交互机制

• 基于Object的wait/notify/notifyAll
  • 为避免假唤醒，需要double check
  • 调用对象的wait–>wait sets—>释放锁—>其他线程notify—->wait sets—->执行此对象线程—>删除sets中此线程
• 基于JDK 5 并发包，支持线程交互
  • Semphore的acquire，release
  • Condition的await，signal
  • CountDownLatch的await和countDown

9.3 线程状态

• New
• Runnable
• Running
• Wait
• TimedWait
• Blocked
• Terminated

9.4 sleep()与wait()方法的区别

• sleep
  • 暂停一段时间执行
  • Thread的静态方法
  • 不释放锁
  • 需要捕获异常
• wait
  • 使线程暂停执行
  • Object方法，用于线程间通信
  • 释放锁

9.5 守护线程

• 后台提供服务
• 用户线程全部终止，只剩下守护线程时，JVM就会退出
• 调用start()之前，调用线程对象的setDaemon(true)

9.6 join

• 调用该方法的线程在执行完run()后，再执行join方法后面的代码
• 线程合并，实现同步功能

10. IO

10.1 流本质

• 数据传输

10.2 流分类

• 字节流:不使用缓存
• 字符流
  • 码表映射
  • 使用缓存

10.3 装饰者模式

• 运行时动态给对象增加额外的职责
• 是你还有你，一切拜托你
• FilterInputStream

10.4 Java Socket

• ServerSocket server = new ServerSocket(2000);
• Socker socket = server.accept();
• 客户端：Socket socket = new Socket(“localhost”,2000);

10.5 NIO

• Channel–Selector–Buffer
• 反应器模式

10.6 序列化

• 对象持久化方式
• 解决在对对象流进行读写操作时引发的问题
• 对象写进流里进行网络传输，保存到文件，数据库

10.7 如何实现序列化

• 实现Serializable接口
• 使用FileOutputStream来构造ObjectOutputStream对象
• 使用该对象的writeObject(obj)方法将对象写出
• 要恢复时，使用对应的输入流

10.8 序列化特点

• 一个类能被序列化，它的子类也能被序列化
• static代表类成员，transient代表临时数据。均不能被序列化
• 序列化影响性能，需要才使用
• 需要通过网络来发送对象，或对象的状态需要被持久化到数据库或文件中
• 序列化能实现深复制，即可以复制引用的对象

10.9 反序列化

• 将流转化为对象
• UID最好自己定义。优点
  • 提高程序运行效率。省去计算过程
  • 提高程序不同平台兼容性。不同计算方式，反序列化失败
  • 增强程序各个版本的可兼容性。加入新属性，默认UID变化

10.10 外部序列化

• 实现Externalizable接口控制