文章目录
- 面向对象和面向过程的区别
- Java语言有哪些特点?
- JVM JDK JRE
- Java 和 C++的区别?
- 字符型常量和字符串常量的区别?
- 构造器Constructor 是否可被override?
- 重载和重写的区别
- Java面向对象三大特性
- String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?
- 自动装箱与拆箱
- 在⼀个静态⽅法内调⽤⼀个⾮静态成员为什么是⾮法的?
- 在 Java 中定义⼀个不做事且没有参数的构造⽅法的作⽤
- 接口和抽象类的区别
- 成员变量与局部变量的区别有哪些?
- ⼀个类的构造方法的作用是什么? 若一个类没有声明构造方法,该程序能正确执行吗? 为什么?
- == 与 equals(重要)
- hashCode 与 equals (重要)
- 简述线程、程序、进程的基本概念。以及他们之间关系是什么?
- 线程有哪些基本状态?
- 常见关键字总结:static,final,this,super
- Java 中的异常处理
- Java 序列化中如果有些字段不想进行序列化,怎么办?
- 获取⽤键盘输⼊常⽤的两种⽅法
- IO 流
- 既然有了字节流,为什么还要有字符流?
- BIO,NIO,AIO 有什么区别?
- 深浅拷贝
面向对象和面向过程的区别
⾯向过程 :⾯向过程性能⽐⾯向对象⾼。 因为类调⽤时需要实例化,开销比较⼤,比较消耗资源,所以当性能是最重要的考量因素的时候,⽐如单⽚机、嵌⼊式开发、Linux/Unix 等⼀般采⽤⾯向过程开发。但是,⾯向过程没有⾯向对象易维护、易复⽤、易扩展。
⾯向对象 :⾯向对象易维护、易复⽤、易扩展。 因为⾯向对象有封装、继承、多态性的特性,所以可以设计出低耦合的系统,使系统更加灵活、更加易于维护。但是,⾯向对象性能⽐⾯向过程低。
Java语言有哪些特点?
- 简单易学
- 面向对象——封装继承多态
- 平台无关性(Java虚拟机实现平台无关性)
- 可靠性
- 安全性
- 支持多线程(2011年C++11才开始引入多线程)
- 支持网络编程并且方便
- 编译与解释并存
JVM JDK JRE
JVM
Java 虚拟机(JVM)是运⾏ Java 字节码的虚拟机。JVM 有针对不同系统的特定实现(Windows,Linux,macOS),⽬的是使⽤相同的字节码,它们都会给出相同的结果。
什么是字节码?采⽤字节码的好处是什么?
在 Java 中,JVM 可以理解的代码就叫做字节码 (即扩展名为 .class 的⽂件),它不⾯向任何特定的处理器,只⾯向虚拟机。Java 语⾔通过字节码的⽅式,在⼀定程度上解决了传统解释型语⾔执⾏效率低的问题,同时⼜保留了解释型语⾔可移植的特点。所以 Java 程序运⾏时比较⾼效,⽽且,由于字节码并不针对⼀种特定的机器,因此,Java 程序⽆须重新编译便可在多种不同操作系统的计算机上运⾏。
Java 程序从源代码到运⾏⼀般有下⾯ 3 步:
我们需要格外注意的是 .class→机器码 这⼀步。在这⼀步 JVM 类加载器⾸先加载字节码⽂件,然后通过解释器逐⾏解释执⾏,这种⽅式的执⾏速度会相对⽐较慢。⽽且,有些⽅法和代码块是经常需要被调⽤的(也就是所谓的热点代码),所以后⾯引进了 JIT 编译器,⽽ JIT 属于运⾏时编译。当 JIT 编译器完成第⼀次编译后,其会将字节码对应的机器码保存下来,下次可以直接使⽤。⽽我们知道,机器码的运⾏效率肯定是⾼于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语⾔。
总结:
Java 虚拟机(JVM)是运⾏ Java 字节码的虚拟机。JVM 有针对不同系统的特定实现(Windows, Linux,macOS),⽬的是使⽤相同的字节码,它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语⾔“⼀次编译,随处可以运⾏”的关键所在。
JDK 和 JRE
JDK 是 Java Development Kit,它是功能⻬全的 Java SDK。它拥有 JRE 所拥有的⼀切,还有编译器(javac)和⼯具(如 javadoc 和 jdb)。它能够创建和编译程序。
JRE 是 Java 运⾏时环境。它是运⾏已编译 Java 程序所需的所有内容的集合,包括 Java 虚拟机
(JVM),Java 类库,java 命令和其他的⼀些基础构件。但是,它不能⽤于创建新程序。
如果你只是为了运⾏⼀下 Java 程序的话,那么你只需要安装 JRE 就可以了。如果你需要进⾏⼀些Java 编程⽅⾯的⼯作,那么你就需要安装 JDK 了。但是,这不是绝对的。有时,即使您不打算在计算机上进⾏任何 Java 开发,仍然需要安装 JDK。例如,如果要使⽤ JSP 部署 Web 应⽤程序,那么从技术上讲,您只是在应⽤程序服务器中运⾏ Java 程序。那你为什么需要 JDK 呢?因为应⽤程序服务器会将 JSP 转换为 Java servlet,并且需要使⽤ JDK 来编译 servlet。
Java 和 C++的区别?
- 都是⾯向对象的语⾔,都⽀持封装、继承和多态
- Java不 提 供 指 针 来 直 接 访 问 内 存 , 程 序 内 存 更 加 安 全
- Java 的类是单继承的,C++ ⽀持多重继承;虽然 Java 的类不可以多继承,但是接⼝可以多继承。
- Java 有⾃动内存管理机制,不需要程序员⼿动释放⽆⽤内存
- 在 C 语⾔中,字符串或字符数组最后都会有⼀个额外的字符‘\0’来表示结束。但是,Java 语⾔中没有结束符这⼀概念。
java中无需结束符的原因
Java里面一切都是对象,是对象的话,字符串肯定就有长度,即然有长度,编译器就可以确定要输出的字符个数,当然也就没有必要去浪费那1字节的空间用以标明字符串的结束了。比如,数组对象里有一个属性length,就是数组的长度,String类里面有方法length()可以确定字符串的长度,因此对于输出函数来说,有直接的大小可以判断字符串的边界,编译器就没必要再去浪费一个空间标识字符串的结束。
字符型常量和字符串常量的区别?
- 形式上: 字符常量是单引号引起的⼀个字符; 字符串常量是双引号引起的若⼲个字符
- 含义上: 字符常量相当于⼀个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表⼀个地址值(该字符串在内存中存放位置)
- 占内存⼤⼩:字符常量只占 2 个字节; 字符串常量占若⼲个字节 (注意: char 在 Java 中占两个字节)
构造器Constructor 是否可被override?
Constructor 不能被 override(重写),但是可以 overload(重载),所以你可以看到⼀个类中有多个构造函数的情况。
构造器是不能被继承的,因为每个类的类名都不相同,而构造器名称与类名相同,所以根本谈不上继承。
又由于构造器不能继承,所以就不能被重写。但是,在同一个类中,构造器是可以被重载的。
重载和重写的区别
重载就是同样的⼀个⽅法能够根据输⼊数据的不同,做出不同的处理
重写就是当⼦类继承⾃⽗类的相同⽅法,输⼊数据⼀样,但要做出有别于⽗类的响应时,你就要覆 盖⽗类⽅法
重载
发⽣在同⼀个类中,⽅法名必须相同,参数类型不同、个数不同、顺序不同,⽅法返回值和访问修饰符可以不同。
综上:重载就是同⼀个类中多个同名⽅法根据不同的传参来执⾏不同的逻辑处理。发生在编译期间
重写
重写发⽣在运⾏期,是⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写。
- 返回值类型、⽅法名、参数列表必须相同,抛出的异常范围⼩于等于⽗类,访问修饰符范围⼤于 等于⽗类。
- 如果⽗类⽅法访问修饰符为 private/final/static 则⼦类就不能重写该⽅法,但是被 static
修饰的⽅法能够被再次声明。 - 构造⽅法⽆法被重写
综上:重写就是⼦类对⽗类⽅法的重新改造,外部样⼦不能改变,内部逻辑可以改变 。发生在运行期间
Java面向对象三大特性
封装
封装把⼀个对象的属性私有化,同时提供⼀些可以被外界访问的属性的⽅法,如果属性不想被外界访问,我们⼤可不必提供⽅法给外界访问。但是如果⼀个类没有提供给外界访问的⽅法,那么这个类也没 有什么意义了。
继承
继承是使⽤已存在的类的定义作为基础建⽴新类的技术,新类的定义可以增加新的数据或新的功能,也可以⽤⽗类的功能,但不能选择性地继承⽗类。通过使⽤继承我们能够⾮常⽅便地复⽤以前的代码。
- ⼦类拥有⽗类对象所有的属性和⽅法(包括私有属性和私有⽅法),但是⽗类中的私有属性和⽅ 法⼦类是⽆法访问,只是拥有。
- ⼦类可以拥有⾃⼰属性和⽅法,即⼦类可以对⽗类进⾏扩展。
- ⼦类可以⽤⾃⼰的⽅式实现⽗类的⽅法。(以后介绍)。 重写
多态
所谓多态就是指程序中定义的引⽤变量所指向的具体类型和通过该引⽤变量发出的⽅法调⽤在编程时并不确定,⽽是在程序运⾏期间才确定,即⼀个引⽤变量到底会指向哪个类的实例对象,该引⽤变量发出 的⽅法调⽤到底是哪个类中实现的⽅法,必须在由程序运⾏期间才能决定。
在 Java 中有两种形式可以实现多态:继承(多个⼦类对同⼀⽅法的重写)和接⼝(实现接⼝并覆盖接⼝中同⼀⽅法)。
String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?
可变性
简单的来说:String 类中使⽤ final
关键字修饰字符数组来保存字符串, private final char value[]
,所以 String 对象是不可变的。
在 Java 9 之后,String 类的实现改⽤ byte 数组存储字符串 private final byte[] value
⽽ StringBuilder 与 StringBuffer 都继承⾃ AbstractStringBuilder 类,在AbstractStringBuilder 中也是使⽤字符数组保存字符串 char[]value 但是没有⽤ final 关键字修饰,所以这两种对象都是可变的。
线程安全性
String 中的对象是不可变的,也就可以理解为常量,线程安全。AbstractStringBuilder 是StringBuilder 与 StringBuffer 的公共⽗类,定义了⼀些字符串的基本操作,如 expandCapacity、append、insert、indexOf 等公共⽅法。StringBuffer 对⽅法加了同步锁或者对调⽤的⽅法加了同步锁,所以是线程安全的。StringBuilder 并没有对⽅法进⾏加同步锁,所以是⾮线程安全的。
性能
每次对 String 类型进⾏改变的时候,都会⽣成⼀个新的 String 对象,然后将指针指向新的 String 对象。
StringBuffer 每次都会对 StringBuffer 对象本身进⾏操作,⽽不是⽣成新的对象并改变对象引⽤。相同情况下使⽤ StringBuilder 相⽐使⽤ StringBuffer 仅能获得 10%~15% 左右的性能提升, 但却要冒多线程不安全的⻛险。
对于三者使⽤的总结:
- 操作少量的数据: 适⽤ String
- 单线程操作字符串缓冲区下操作⼤量数据: 适⽤ StringBuilder
- 多线程操作字符串缓冲区下操作⼤量数据: 适⽤ StringBuffer
自动装箱与拆箱
装箱:将基本类型⽤它们对应的引⽤类型包装起来;
Integer i = 10;
拆箱:将包装类型转换为基本数据类型;
int n = i;
反编译得到的字节码内容可以得知,在装箱的时候自动调用的是Integer的valueOf(int)
方法。而在拆箱的时候自动调用的是Integer的intValue
方法。
public static void main(String[] args) {
Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;
System.out.println(i1==i2); // true
System.out.println(i3==i4); // false
}
在通过valueOf
方法创建Integer对象的时候,如果数值在[-128,127]
之间,便返回指向IntegerCache.cache
中已经存在的对象的引用;否则创建一个新的Integer对象。
上面的代码中i1和i2的数值为100,因此会直接从cache中取已经存在的对象,所以i1和i2指向的是同一个对象,而i3和i4则是分别指向不同的对象。
public static void main(String[] args) {
Double i1 = 100.0;
Double i2 = 100.0;
Double i3 = 200.0;
Double i4 = 200.0;
System.out.println(i1==i2); // false
System.out.println(i3==i4); // false
}
至于具体为什么,可以去查看Double类的valueOf的实现。
在这里只解释一下为什么Double类的valueOf方法会采用与Integer类的valueOf方法不同的实现。很简单:在某个范围内的整型数值的个数是有限的,而浮点数却不是。
注意,Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。
Double、Float的valueOf方法的实现是类似的。
public static void main(String[] args) {
Boolean i1 = false;
Boolean i2 = false;
Boolean i3 = true;
Boolean i4 = true;
System.out.println(i1==i2); // true
System.out.println(i3==i4); // true
}
在⼀个静态⽅法内调⽤⼀个⾮静态成员为什么是⾮法的?
类的静态成员(变量或方法)属于类本身,在类加载的时候就会分配内存,可以通过类名直接访问
非静态成员(变量或方法)属于类的对象,只有在类的对象产生(实例化)时才会分配内存,然后通过类的对象(实例)去访问
所以,如果一个类的静态方法去调用非静态方法或变量的时候,因为类的静态方法存在的时候,类的非静态成员可能不存在,访问一个内存中不存在的东西当然会出错(加载时间不一样)
在 Java 中定义⼀个不做事且没有参数的构造⽅法的作⽤
Java 程序在执⾏⼦类的构造⽅法之前,如果没有⽤ super() 来调⽤⽗类特定的构造⽅法,则会调⽤⽗类中“没有参数的构造⽅法”。
因此,如果⽗类中只定义了有参数的构造⽅法,⽽在⼦类的构造⽅法中⼜没有⽤ super() 来调⽤⽗类中特定的构造⽅法,则编译时将发⽣错误,因为 Java 程序在⽗类中找不到没有参数的构造⽅法可供执⾏。解决办法是在⽗类⾥加上⼀个不做事且没有参数的构造⽅法。
接口和抽象类的区别
区别 | 接口 | 抽象类 |
---|---|---|
声明方式 | interface | abstract |
使用方式 | implements | extends |
修饰符 | 接口方法默认修饰符是public static final。你不可以使用其它修饰符。 | 抽象方法可以有public、protected和default这些修饰符 |
方法实现 | 接口没有方法实现(java8以后接口可以有default和static方法) | 抽象类可以有非抽象的方法实现 |
特性 | 可以同时实现多个接口 | 1. 抽象类可以有(无)抽象方法。可以有(无)普通方法 2. 普通类继承抽象类,必须实现其中的抽象方法,抽象类继承抽象类,可以不用实现其抽象方法 3.一个抽象类实现了一个接口,可以不实现其抽象方法 |
实例化 | 不能实例化 | 不能实例化 |
构造函数 | 接口没有构造方法 | 抽象类可以用构造方法 |
成员变量和方法 | 必须是静态常量和抽象方法,不能含有静态代码块以及静态方法(java8以后接口可以有default和static方法) | 可以有成员变量和成员方法,可以有静态代码块和静态方法 |
成员变量与局部变量的区别有哪些?
-
声明位置
**成员变量:**声明在类中方法外
**局部变量:**是声明在⽅法体中,代码块中,还有方法形参 -
修饰
成员变量可以被 public,private,static 等修饰符所修饰,并根据是否被static
修饰而分为类变量和实例变量
局部变量不能被访问控制修饰符及static 所修饰;
但是,成员变量和局部变量都能被 final 所修饰。 -
存储方式
成员变量中的类变量存储在方法区中,实例变量存储在堆中
局部变量存储在栈中 -
⽣存时间
类变量生命周期取决于类的生命周期
实例变量是对象的⼀部分,它随着对象的创建⽽存在
局部变量随着⽅法的调⽤⽽⾃动消失。 -
初始化
成员变量会⾃动以类型的默认值而赋值(⼀种情况例外:被 final 修饰的成员变量必须显式地赋值)
局部变量则不会⾃动赋值。
⼀个类的构造方法的作用是什么? 若一个类没有声明构造方法,该程序能正确执行吗? 为什么?
主要作⽤是完成对类对象的初始化⼯作。可以执⾏。因为⼀个类即使没有声明构造方法也会有默认的不带参数的构造⽅法。
== 与 equals(重要)
==:作⽤是比较值是否相等。即基本数据类型比较的是值,引⽤数据类型比较的是内存地址。
equals() : equals方法不能作用于基本数据类型的变量,equals继承Object类,比较的是是否是同一个对象。但它⼀般有两种使⽤情况:
如果没有对equals方法进行重写,则比较的是引用类型的变量所指向的对象的地址;
诸如String、Date等类对equals方法进行了重写的话,比较的是所指向的对象的内容。
hashCode 与 equals (重要)
hashCode()介绍
hashCode()
的作⽤是获取哈希码,也称为散列码;它实际上是返回⼀个 int 整数。这个哈希码的作⽤是确定该对象在哈希表中的索引位置。hashCode() 定义在 JDK 的 Object.java 中,这就意味着 Java 中的任何类都包含有 hashCode() 函数。
散列表存储的是键值对(key-value),它的特点是:能根据“键”快速的检索出对应的“值”。这其中就利⽤到了散列码!(可以快速找到所需要的对象)
为什么要有 hashCode
我们先以“HashSet 如何检查重复”为例⼦来说明为什么要有 hashCode:
把对象加⼊ HashSet
时,HashSet
会先计算对象的 hashcode
值来判断对象加⼊的位置,同时也会与其他已经加⼊的对象的 hashcode 值作⽐较,如果没有相同的 hashcode,HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象,这时会调⽤ equals() ⽅法来检查 hashcode 相等的对象的内容是否真的相同。如果两者相同,HashSet 就不会让其加⼊操作成功。如果不同的话,就会重新散列到其他位置。这样我们就⼤⼤减少了 equals 的次数,相应就⼤⼤提高了执⾏速度。
hashCode()与 equals()的相关规定
- 如果两个对象相等,则 hashcode ⼀定也是相同的
- 两个对象相等,对两个对象分别调⽤ equals ⽅法都返回 true
- 两个对象有相同的 hashcode 值,它们也不⼀定是相等的
- 因此,equals ⽅法被重写过,则 hashCode ⽅法也必须被重写
- hashCode() 的默认⾏为是对堆上的对象产⽣独特值。如果没有重写 hashCode(),则该 class
的两个对象⽆论如何都不会相等(即使这两个对象指向相同的数据)
简述线程、程序、进程的基本概念。以及他们之间关系是什么?
线程与进程相似,但线程是⼀个⽐进程更小的执⾏单位(线程<进程)。⼀个进程在其执⾏的过程中可以产⽣多个线程。与进程不同的是同类的多个线程共享同⼀块内存空间和⼀组系统资源,所以系统在产⽣⼀个线程,或是在各个线程之间作切换⼯作时,负担要⽐进程⼩得多,也正因为如此,线程也被称为轻量级进程。
程序是含有指令和数据的⽂件,被存储在磁盘或其他的数据存储设备中,也就是说程序是静态的代码。
进程是程序的⼀次执⾏过程,是系统运⾏程序的基本单位,因此进程是动态的。系统运⾏⼀个程序即是⼀个进程从创建,运⾏到消亡的过程。简单来说,⼀个进程就是⼀个执⾏中的程序,它在计算机中⼀个指令接着⼀个指令地执⾏着,同时,每个进程还占有某些系统资源如 CPU 时间,内存空间,⽂件,输⼊输出设备的使⽤权等等。换句话说,当程序在执⾏时,将会被操作系统载⼊内存中。 线程是进程划分成的更⼩的运⾏单位。线程和进程最⼤的不同在于基本上各进程是独⽴的,⽽各线程则不⼀定,因为同⼀进程中的线程极有可能会相互影响。从另⼀⻆度来说,进程属于操作系统的范畴,主要是同⼀段时间内,可以同时执⾏⼀个以上的程序,⽽线程则是在同⼀程序内⼏乎同时执⾏⼀个以上的程序段。
线程有哪些基本状态?
由上图可以看出:线程创建之后它将处于 NEW(新建) 状态,调⽤start()
⽅法后开始运⾏,线程这时候处于READY(可运⾏) 状态。可运⾏状态的线程获得了 cpu 时间⽚(timeslice)后就处于 RUNNING(运⾏) 状态。当线程执⾏ wait()
⽅法之后,线程进⼊ WAITING(等待) 状态。进⼊等待状态的线程需要依靠其他线程的通知才能够返回到运⾏状态,⽽TIME_WAITING(超时等待) 状态相当于在等待状态的基础上增加了超时限制,⽐如通过 sleep(long millis)
⽅法或 wait(long millis)
⽅法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调⽤同步⽅法时,在没有获取到锁的情况下,线程将会进⼊到 BLOCKED(阻塞) 状态。线程在执⾏Runnable 的 run()
⽅法之后将会进⼊到TERMINATED(终⽌) 状态。
常见关键字总结:static,final,this,super
参考https://www.cnblogs.com/baichunyu/p/11401354.html
final 关键字
final 关键字主要⽤在三个地⽅:变量、⽅法、类。
- 对于⼀个 final 变量,如果是基本数据类型的变量,则其数值⼀旦在初始化之后便不能更改; 如果是引⽤类型的变量,则在对其初始化之后便不能再让其指向另⼀个对象。
- 当⽤ final 修饰⼀个类时,表明这个类不能被继承。final 类中的所有成员⽅法都会被隐式地指定为 final ⽅法。
- 使⽤ final ⽅法的原因有两个。第⼀个原因是把方法锁定,以防任何继承类修改它的含义;第
⼆个原因是效率。在早期的 Java 实现版本中,会将 final ⽅法转为内嵌调⽤。但是如果⽅法过于庞⼤,可能看不到内嵌调⽤带来的任何性能提升(现在的 Java 版本已经不需要使⽤ final⽅法进⾏这些优化了)。类中所有的 private ⽅法都隐式地指定为 final。
static 关键字
static 关键字主要有以下四种使用场景:
1、修饰成员变量和成员方法
2、静态代码块
3、静态内部类
4、静态导包
this 关键字
this关键字用于引用类的当前实例。
super 关键字
super关键字用于从子类访问父类的变量和方法。
Java 中的异常处理
Java 异常类层次结构图
在 Java 中,所有的异常都有⼀个共同的祖先 java.lang 包中的 Throwable 类。Throwable: 有两个重要的⼦类:Exception(异常) 和 Error(错误) ,⼆者都是 Java 异常处理的重要⼦类,各⾃都包含⼤量⼦类。
Error(错误):是程序⽆法处理的错误,表示运⾏应⽤程序中较严重问题。⼤多数错误与代码编写者执⾏的操作⽆关,⽽表示代码运⾏时 JVM(Java 虚拟机)出现的问题。例如,Java 虚拟机运⾏错误(VirtualMachineError
),当 JVM 不再有继续执⾏操作所需的内存资源时,将出现OutOfMemoryError
。这些异常发⽣时,Java 虚拟机(JVM)⼀般会选择线程终⽌。这些错误表示故障发⽣于虚拟机⾃身、或者发⽣在虚拟机试图执⾏应⽤时,如 Java 虚拟机运⾏错误(VirtualMachineError
)、类定义错误(NoClassDefFoundError
)等。这些错误是不可查的,因为它们在应⽤程序的控制和处理能⼒之 外,⽽且绝⼤多数是程序运⾏时不允许出现的状况。对于设计合理的应⽤程序来说,即使确实发⽣了错误,本质上也不应该试图去处理它所引起的异常状况。在 Java中,错误通过 Error 的⼦类描述。
Exception(异常):是程序本身可以处理的异常。Exception 类有⼀个重要的⼦类
RuntimeException
。RuntimeException 异常由 Java 虚拟机抛出。NullPointerException
(要访问的变量没有引⽤任何对象时,抛出该异常)、ArithmeticException
(算术运算异常,⼀个整数除以 0 时,抛出该异常)和 ArrayIndexOutOfBoundsException
(下标越界异常)。
注意:异常和错误的区别:异常能被程序本身处理,错误是⽆法处理。
Throwable 类常⽤⽅法
- public string getMessage():返回异常发⽣时的简要描述
- public string toString():返回异常发⽣时的详细信息
- public string getLocalizedMessage():返回异常对象的本地化信息。使⽤ Throwable 的⼦类覆盖这个⽅法,可以⽣成本地化信息。如果⼦类没有覆盖该⽅法,则该⽅法返回的信息与getMessage()返回的结果相同
- public void printStackTrace():在控制台上打印 Throwable 对象封装的异常信息
异常处理总结
- try块: ⽤于捕获异常。其后可接零个或多个 catch 块,如果没有 catch 块,则必须跟⼀个finally 块 。
- catch块 :⽤于处理try捕获到的异常 。
- finally块: ⽆论是否捕获或处理异常,finally 块⾥的语句都会被执⾏。当在 try 块或catch 块中遇到return语句时,finally 语句块将在⽅法返回之前被执⾏。
在以下 4 种特殊情况下,finally 块不会被执⾏:
- 在 finally 语句块第⼀⾏发⽣了异常。 因为在其他⾏,finally 块还是会得到执⾏
- 在前⾯的代码中⽤了
System.exit(int)
已退出程序。 exit 是带参函数 ;若该语句在异常语句之后,finally 会执⾏ - 程序所在的线程死亡。
- 关闭 CPU。
注意: 当 try 语句和 finally 语句中都有 return 语句时,在⽅法返回之前,finally 语句的内容将被执行,并且 finally 语句的返回值将会覆盖原始的返回值。如下:
public static int f(int value) {
try {
return value * value;
} finally {
if (value == 2) {
return 0;
}
}
}
如果调⽤ f(2)
,返回值将是 0,因为 finally 语句的返回值覆盖了 try 语句块的返回值。
Java 序列化中如果有些字段不想进行序列化,怎么办?
对于不想进⾏序列化的变量,使⽤ transient
关键字修饰。
transient 关键字的作⽤是:阻⽌实例中那些⽤此关键字修饰的的变量序列化;当对象被反序列化时, 被 transient 修饰的变量值不会被持久化和恢复。transient 只能修饰变量,不能修饰类和⽅法。
获取⽤键盘输⼊常⽤的两种⽅法
⽅法 1:通过 Scanner
Scanner input = new Scanner(System.in);
String s = input.nextLine();
input.close();
⽅法 2:通过 BufferedReader
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
String s = input.readLine();
IO 流
分类
- 按照流的流向分,可以分为输⼊流和输出流;
- 按照操作单元划分,可以划分为字节流和字符流;
- 按照流的角色划分为节点流和处理流。
4个抽象类基类
InputStream/Reader
: 所有的输入流的基类,前者是字节输⼊流,后者是字符输⼊流。
OutputStream/Writer
:所有输出流的基类,前者是字节输出流,后者是字符输出流。
按操作⽅式分类结构图:
按操作对象分类结构图:
既然有了字节流,为什么还要有字符流?
问题本质想问:不管是⽂件读写还是⽹络发送接收,信息的最⼩存储单元都是字节,那为什么 I/O 流操作要分为字节流操作和字符流操作呢?
回答:字符流是由 Java 虚拟机将字节转换得到的,问题就出在这个过程还算是非常耗时,并且,如果我们不知道编码类型就很容易出现乱码问题。所以, I/O 流就⼲脆提供了⼀个直接操作字符的接⼝,⽅便我们平时对字符进⾏流操作。如果⾳频⽂件、图⽚等媒体⽂件⽤字节流⽐较好,如果涉及到字符的话使⽤字符流⽐较好。
BIO,NIO,AIO 有什么区别?
BIO (Blocking I/O): 同步阻塞 I/O 模式,数据的读取写⼊必须阻塞在⼀个线程内等待其完成。在活动连接数不是特别⾼(⼩于单机 1000)的情况下,这种模型是⽐较不错的,可以让每⼀个连接专注于⾃⼰的 I/O 并且编程模型简单,也不⽤过多考虑系统的过载、限流等问题。线程池本身就是⼀个天然的漏⽃,可以缓冲⼀些系统处理不了的连接或请求。但是,当⾯对⼗万甚⾄百万级连接的时候,传统的 BIO 模型是⽆能为⼒的。因此,我们需要⼀种更⾼效的 I/O 处理模型来应对更⾼的并发量。
NIO (Non-blocking/New I/O): 同步非阻塞的 I/O 模型,在 Java 1.4 中引⼊了NIO 框架,对应 java.nio 包,提供了 Channel , Selector,Buffer 等抽象。NIO 中的 N 可以理解为 Non-blocking,不单纯是 New。它⽀持⾯向缓冲的,基于通道的 I/O 操作⽅法。 NIO提供了与传统 BIO 模型中的Socket
和ServerSocket
相对应的SocketChannel
和ServerSocketChannel
两种不同的套接字通道实现,两种通道都⽀持阻塞和⾮阻塞两种模 式。阻塞模式使⽤就像传统中的⽀持⼀样,⽐较简单,但是性能和可靠性都不好;⾮阻塞模式正好与之相反。对于低负载、低并发的应⽤程序,可以使⽤同步阻塞 I/O 来提升开发速率和更好的维护性;对于⾼负载、⾼并发的(⽹络)应⽤,应使⽤ NIO 的⾮阻塞模式来开发。
AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 1.7 中引⼊了 NIO 的改进版 NIO 2,它是异步⾮阻塞的 IO 模型。异步 IO 是基于事件和回调机制实现的,也就是应⽤操作之后会直接返回,不会堵塞在那⾥,当后台处理完成,操作系统会通知相应的线程进⾏后续的操作。AIO 是异步 IO 的缩写,虽然 NIO 在⽹络操作中,提供了⾮阻塞的⽅法,但是 NIO 的 IO ⾏为还是同步的。对于 NIO 来说,我们的业务线程是在 IO 操作准备好时,得到通知,接着就由这个线程自行进⾏ IO 操作,IO 操作本身是同步的。查阅⽹上相关资料,我发现就⽬前来说 AIO 的应⽤还不是很⼴泛,Netty 之前也尝试使⽤过 AIO,不过⼜放弃了。
深浅拷贝
- 浅拷贝:对基本数据类型进行值传递,对引⽤数据类型进⾏引⽤传递。
- 深拷贝:对基本数据类型进行值传递,对引用数据类型,创建⼀个新的对象,并复制其内容。