声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章
2. 由于是个人总结, 所以用最精简的话语来写文章
3. 若有错误不当之处, 请指出
基本类型和包装类型:
区别:
包装类型可以有null, 而基本类型不可以
包装类型可以用于泛型, 而基本类型不可以
包装类型占用更多内存, 而基本类型占用内存少
包装类型的cache[], 得在你不主动new的时候才能派上用场
Float和Double没有cache[], 因为小数太多没法缓存
值传递和引用传递:
值传递: 传值
引用传递: 传地址
Java里只有值传递, 基本类型作为参数被传递时肯定是值传递(字面量的拷贝)；引用类型作为参数被传递时也是值传递，只不过"值"为 堆中的地址值
方法间传参手段:
不跨类
跨类
JavaBean:
有无参构造器: 无参构造器最好显示写上, 因为一旦有了其他构造器, javac就不会自动生成它,而子类构造器默认调super( ), 那就找不到相应构造器了
有Getter/Setter方法: 在json解析或spring装在bean或springmvc或jsp解析时, 并不是直接调用属性, 而是调用其Getter/Setter方法, 如果没有这些可能报错
属性不能使用基本数据类型;
因为如int score时,score为0可能实际数据为0,也可能是因为赋的默认值才为0;
而如果是Integer时,默认值为null, 就可以和实际数据0区分开了
常见的Object方法:
Object clone( ) 浅拷贝
boolean equals(Object)
int hashCode( )
void finalize( )
Class getClass( )
void wait( )
void notify( ) 唤醒等待在该对象的Monitor上的一个线程
void notifyAll( ) 唤醒等待在该对象的Monitor上的全部线程
String toString( )
浅拷贝&深拷贝:
浅拷贝：
对基本数据类型进行值复制，对引用数据类型复制一个引用指向原始引用的对象，
结果是复制的引用和原始引用指向同一个对象(即只拷贝一层)
实现: 目标类先实现实现Cloneable空接口, 调用方再调用目标类的clone方法(继承自Object类)进行浅拷贝
深拷贝：
对基本数据类型进行值复制，对引用数据类型，创建一个新的对象, 并复制其内容,
结果是复制的引用和原始引用指向不同对象(即递归拷贝多层, 直到最后一层为止)
实现: 使用IO对象流(ObjectInputStream, ObjectOutputStream)进行拷贝
final:
finally:
finalize:
不重写finalize时, GC时会直接调用finalize( )方法来释放内存
重写finalize时, 此类的实例会被包装为Finalizer类的实例, 它们被unfinalized链表串起来;
当第一次GC时, 只是把它迁移到引用队列里, 并不进行释放内存;
得等到第二次GC时,才真正调用finalize方法
如果重写代码里并不是释放内存得逻辑, 比如将这个垃圾对象再赋值给别的引用, 相当于救了这个对象一命使之不再成为垃圾
不要手动调用System.gc( ), GC太伤性能; 另外GC具体什么时候执行 是JVM决定的, 我们决定不了, 只是"建议"一下
循环:
Comparable VS Comparator:
Comparable 是实体类本身具有可比较性, compareTo方法写在实体类内部
Comparator 是第三方比较器, 单独是一个类, 用compare方法比较两个元素
若想升序排序, 则应该返回a-b<0即负数, 证明a<b; 返回值>0代表a>b; 返回值==0代表a==b
方法均必须被public abstract修饰, 可以不显示写出来, 但是不能修改它
属性均必须被public final修饰, 可以不显示写出来, 但是不能修改它
接口中不能写构造器, 因为构造器就是用来初始化的, 而它的属性都是常量了得提前赋值, 没必要再要构造器初始化了
java8中, 接口里也可以有static方法和default方法, 这种是非抽象的方法; 目的是让你万不得已才这样做, 而不是建议你直接这样做;
static方法不可被重写, 但可重名
default方法可被重写, 重写时不可带default关键字
接口是规范
继承抽象类用extends, 实现接口用implement;
继承只有单继承, 实现有多实现; extends写前面, implement写后面
想要重写父类方法, 必须遵循3个规则:
例题: 这个会报错的, 因为"方法权限修饰符≥父类"这个规则, 子类的默认权限<父接口隐藏的public权限
public interface Person{
void eat( );
}
public class Student extends Person{
void eat( ){
System.out.println( );
}
}
证明有些方法不能被重写:
static方法不能被重写, 可以发现@Override检查后报错, 说明只是同名字
private方法不能被重写, 可以发现@Override检查后报错, 说明只是同名字
final方法不能被重写, 而且不能同名字
重载方法是编译型多态, 重写方法是运行时多态
方法返回值不作为判断重载的依据, 重载是方法名一样, 但参数不一样(参数个数, 参数类型, 参数顺序)
有 静态内部类, 非静态内部类, 匿名内部类, 局部(方法)内部类
非静态内部类里不能使用static关键字
方法内部类使用的外部方法里的变量必须为final常量(可以不显示写出)。[方法内的lambad表达式也一样]
这是为了改变它的生命周期, 万一这个方法执行完毕后该变量又没有逃逸出去被别人使用, 它就被回收了, 而方法内部类可能依旧需要使用它
final怎样改变它(外部方法里的变量)的生命周期的?
final修饰的常量引用在方法区, 指向的对象在堆中;
方法区的常量引用不会被因此方法调用结束而被回收, 且final常量是可以作为GcRoots对象的, 那么所指的堆中对象就不会被回收,
从而改变了生命周期
如果要使用user对象, 常用套路:
如果非要修改user对象, 常用套路:
调用方法是动态绑定的(看实例的真正类型是啥, 如果是多态,则按重写调用, 对于同名字的那种视而不见)，
而调用属性是静态绑定的(看类的类型是啥)
例题:
public class Demo01 {
public static void main(String[] args) {
A a = new B( );
// 输出结果是: 20
System.out.println(a.getResult( ));
}
}
class A {
private int i = 10;
public int getResult( ) {
return i + 10;
}
}
class B extends A {
private int i = 20;
}
public class Demo01 {
public static void main(String[] args) {
A a = new B( );
// 输出结果是: 20
System.out.println(a.getResult( ));
}
}
class A {
private int i = 10;
public int getResult( ) {
return i + 10;
}
}
class B extends A {
private int i = 20;
public int getResult( ) {
return i + 20;
}
}
public class Demo01 {
public static void main(String[] args) {
A a = new B( );
// 输出结果是: 20
// 不是权限不足才被迫调用父类中该方法,
// 而是对于那种非重写但同名的方法, 在多态形式调用时,不会理会它,只会理父类中的该方法
System.out.println(a.getResult( ));
}
}
class A {
private int i = 10;
// private权限的getI
private int getI( ) {
return i;
}
public int getResult( ) {
return getI( ) + 10;
}
}
class B extends A {
private int i = 20;
// private权限的getI, 并非重写, private方法不能被重写, 只是同名字
public int getI( ) {
return i;
}
}
public class Demo01 {
public static void main(String[] args) {
A a = new B( );
// 输出结果是: 1
// 对于那种非重写但同名的方法, 在多态形式调用时,不会理会它,只会理父类中的该方法
System.out.println(a.getI( ));
}
}
class A {
// private权限的getI
public static int getI( ) {
return 1;
}
}
class B extends A {
// private权限的getI, 并非重写, private方法不能被重写, 只是同名字
public static int getI( ) {
return 2;
}
}
封装
即包装, 把客观事物封装成类, 有利于解耦
权限封装, get/set 可以写一些数据校验逻辑
参数封装成map, 既美观又拓展性更强, 加参数只需要执行map.put, 而不用修改方法签名
对功能的封装，封装成一个方法，或对方法进一步封装以加强其功能
框架的封装
继承
避免写重复性的代码, 继承父类后可以拥有父类的一部分东西
构造器不能被继承
private可以继承, 但子类无权使用
多态
不同的实现类有不同的功能, 有利于功能的拓展
多态发生的条件: 继承+重写+向上转型
==:
如果==比较的是基本数据类型，那么比较的是两个值是否相等
如果==是比较的两个对象，那么比较的是对象的物理地址是否相等, 即两个对象是否指向了同一块内存
equals:
如果不重写, 则等效于==
很多时候我们想比较的是两个对象的 属性内容是否相等
equals方法要具有以下特性：
hashcode( ):
hashcode是获取散列哈希码, 默认情况是追求不同对象的哈希码不一样, 有极少情况会两个不同对象的哈希码相等(比如Tom(12岁,猫)可能恰好和Jerry(10岁, 鼠))的哈希值是相等的, 但equals不相等
在HashMap集合中重写equals时, 也需要重写hashcode, 如果只重写了equals方法而不重写hashcode的方法，会造成hashcode的值不同，而equals( )方法判断出来的结果为true。造成相同的对象散列到不同的位置而造成对象的不能覆盖的问题。
hashcode的作用:
hashcode相等后，还需要再equals判断：
因为hashcode不相等时那么equals也一定不相等；而hashcode相等时，那equals未必相等
String是不可变对象, 底层是private final char value[]; 若要修改, 实质上是返回一个新的对象
String经常被使用, 所以为了复用性, 用字符串常量池进行了池化
不可变&字符串常量池 的好处:
对象的复用
String的对象不可变, 则hashcode不可变, 可以进行缓存, 不需要重新计算; 所以推荐Map的key为String类型, 寻找值更快
使多线程安全
既然是不可变, 那就自然没有多线程安全问题了
保证其他安全问题
保护 网络连接地址URL，文件路径path 不被黑客修改
StringBuilder是线程不安全的, StringBuffer是线程安全的
但一般StringBuilder作为局部变量且不暴漏给其他线程, 所以常用些
StringBuilder和StringBuffer都是修改this对象, 实现了链式调用
常量池中的字符串仅是符号，第一次用到时才变为实际的对象
字符串常量池里寸存的是字面量对象
字符串变量拼接的原理是StringBuilder, 即最后toString的时候创建了新字符串对象;
1个或2个
当常量池里已经有了"xxx"时, 就只在堆里创建对象就行了
当常量池里没有"xxx"时, 就现在常量池里创建, 然后再在堆里创建一个
注意这个不是意为着手动调用.intern就没意义了:
对于直接字面量相加的字符串, 会被优化为没有拼接这一步
调用 intern( )方法，主动将串池中还没有的字符串对象放入串池(运行时常量池)
所以在s1.intern( ) 没有成功把s1放入串池时, 1.8和1.6做法无差异, 所以s1==s1.intern( );
在s1.intern( ) 成功把s1放入串池时, 1.8和1.6做法有差异(1.8是移动, 1.6是复制), 所以s1!=s1.intern( )
习题:
// jdk1.8时
String s1 = "a";
String s2 = "b";
String s3 = "a" + "b";
String s4 = s1 + s2;
String s5 = "ab";
String s6 = s4.intern( );
System.out.println(s3 == s4); // false
System.out.println(s3 == s5); // true
System.out.println(s3 == s6); // true
String x1 = "cd";
String x2 = new String("c") + new String("d");
String x3=x2.intern( );
System.out.println(x1 == x2); // false
System.out.println(x2 == x3); // false
String y2 = new String("e") + new String("f");
String y3=y2.intern( );
String y1 = "ef";
System.out.println(y1 == y2); // true
System.out.println(y2 == y3); // true
// jdk1.6时
String s1 = "a";
String s2 = "b";
String s3 = "a" + "b";
String s4 = s1 + s2;
String s5 = "ab";
String s6 = s4.intern( );
System.out.println(s3 == s4); // false
System.out.println(s3 == s5); // true
System.out.println(s3 == s6); // true
String x1 = "cd";
String x2 = new String("c") + new String("d");
String x3=x2.intern( );
System.out.println(x1 == x2); // false
System.out.println(x2 == x3); // false
String y2 = new String("e") + new String("f");
String y3=y2.intern( );
String y1 = "ef";
System.out.println(y1 == y2); // false
System.out.println(y2 == y3); // false
String长度的最大值:
在编译期: .class文件的Constant_Utf8_info表 用一个无符号短整型变量记录字符串占用字节大小,
所以最大字节为2^16-1=65535, 而最大长度是2^16-2=65534
在运行期: 字符串长度最大值就变成了数组长度的最大值, 数组的对象头里有4个字节记录数组长度, 故最大长度为2^31-1
都是Throwable的子类
错误是虚拟机自身造成的, 是程序自身不可以处理的, 比如StackOverFlowError, OutOfMemoryError
异常是程序逻辑不对造成的, 是程序自身可以处理的
异常=编译时异常(大部分是IOException)+运行时异常
见过的异常:
ConcurrentModificationException 并发修改异常,
比如遍历ArrayList集合期间删除了元素 导致modCount != expectedModCount
这里的并发并非是线程并发, 而是指一边遍历一遍修改
IllegalAccessException 非法访问权限异常
如调用别类中的private方法
InstantiationException 实例化异常
Class的newInstance( )方法创建某个类的实例, 而该类却没有相应构造器
ClassCastException 类型转换异常
NumberFormatException 数据格式异常
try with source 即省略了finally, 把待释放的资源放在try后的( )里, 这里的变量实质上是final的(可以不显示写出来)
try catch finally中, catch 不是必要的
SimpleDateFormat是非线程安全的, 因为它内部的calendar属性被暴漏出来, 临界区发生了竞态条件
应该使用JDK8新出来的LocalDateTime类
应用场景:
枚举的本质是有一个final static 的引用属性, 指向了自己的对象
什么时候用枚举?
特点:
,隔开, 后面什么都没有时, 可以省略;结束符枚举类的常用方法:
返回值 方法 描述 String name( ) 获取枚举成员的名称 static T valueOf(Class enumType, String name) 获取指定枚举成员名称和类型的枚举成员 String[] values( ) 获取枚举成员的所有值 int compareTo(E o) 比较此枚举与指定对象的 顺序 int ordinal( ) 获取枚举成员的序数(从0开始) Class<E> getDeclaringClass( ) 获取枚举成员的类对象
泛型就是将类型参数化
泛型的优点:
泛型在运行期会被擦除, 都变成Object类型, 这些方法调用时会有checkcast指令去强制类型转换
泛型方法:
泛型 T 是方法独有的, 与所在类上定义的泛型无关
public <T> void fun(T t){
}
静态方法 不可以访问 类上定义的泛型(因为得new 才能传泛型, 而static类初始化阶段 还没有new对象初始化发生),
但可以使用 泛型方法上定义的泛型
通配符 ? 类型:
List<? extends T> 泛型上限是T
List <? super T> 泛型下限是T
List <?> 不确定类型, 可以持有任意类型
错误使用:
而List<Object> list = new ArrayList<Object>( ); 是正确的, <>里面的类型前后必须得一致才行
节点流有: 字节流(读写任何数据格式), 字符流(读写文本格式)
包装流(处理流)有: 缓冲流, 转换流, 数据流, 对象流
形式有: 字节数组形式/文件形式
包装流的反复包装, 使用了装饰者设计模式
转换流(字节转字符):
InputStreamReader 字节输入流 转 字符输入流
OutputStreamWrite 字节输出流 转 字符输出流
序列化是把内存中的数据转换成字节流等形式, 使数据能落盘存储 或 网络传输,
分布式节点中要传输数据, 数据得先序列化才能传输
序列化可以打破单例, 所以需要处理一下:
// 待序列化的类写上此方法, 反序列化时依旧保持单实例
protected Object readResolve( ) {
return instance;
}
Serializable:
需要继承Serializable空接口, 最好要加上public static final long serialVersionUID属性(相当于版本号)
如果没有这个属性, 那么一旦类被修改了, 反序列化时就会报错(相当于每次反序列化会生成新的版本号)
serialVersionUID 用来表明类的不同版本间的兼容性, 值是多少无所谓, 只要不变就行
transient修饰的属性 和 静态属性 是不会被序列化的
serialVersionUID也被static修饰, 为什么serialVersionUID会被序列化?
其实原先的serialVersionUID属性并没有被序列化, JVM在序列化对象时会自动生成一个serialVersionUID; 然后将原先的serialVersionUID属性值 赋值 给自动生成的serialVersionUID
Externalizable:
是Serializable的子接口
重写writeExternal 和 readExternal两个方法, 自己指明要序列化哪些属性
public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(name); } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { name = (String) in.readObject( ); }
是一种可以被程序读取的标记, 可以用来作配置
用@Interface来声明, 属性长得像方法, 使用时, 只有一个value属性的话, value可以省略
注解的传递: 注解A修饰了注解B, 那么注解B去修饰注解C时, 注解C也会被A修饰
元注解:
@Target 声明注解的使用范围
public enum ElementType { TYPE, // 类、接口、枚举类 FIELD, // 成员变量（包括：枚举常量） METHOD, // 成员方法 PARAMETER, // 方法参数 CONSTRUCTOR, // 构造方法 LOCAL_VARIABLE, // 局部变量 ANNOTATION_TYPE, // 注解类 PACKAGE, // 可用于修饰：包 TYPE_PARAMETER, // 类型参数，JDK 1.8 新增 TYPE_USE // 使用类型的任何地方，JDK 1.8 新增}
@Retention 声明注解可以活到什么时候
public enum RetentionPolicy { SOURCE, // 源文件保留 CLASS, // 编译期保留，默认值 RUNTIME // 运行期保留，可通过反射去获取注解信息}
@Inherited 表明 被注解修饰的父类，其子类会自动继承该注解
@Documnent 表明注解可以被javadoc提取生成说明文档
JDK8中注解的新特性:
新增可用于类型的注解
ElementType.TYPE_PARAMETER
ElementType.TYPE_USE
可重复的注解
相当于在原先注解上加个重复注解 表示数组容器, 原先注解被多次使用时 就会被放到此数组中
示例:
反射可以用来突破权限, 但不建议直接这样, 除非你万不得已
lambad表达式, 即函数也进行匿名, 把函数看作对象; 当接口里只有一个方法时, 可以这样做
方法引用(类调用 反而要比对象调用 支持的更多些), 传入getter方法时常常这样做, 比如Student::getScore
函数式接口:
被@FunctionInterface修饰
Function——函数型接口**（有输入、有返回）**
Predicate——断定型接口**（有输入，返回boolean）**
Consumer——消费型接口**（有输入，无返回）**
Supplier——供给型接口**（无输入，有返回值）**
BiConsumer是有两个参数输入
StreamAPI是将集合变为Stream流, 对于Stream流的操作并不会影响原集合, 有丰富的API
如map, flatMap, filter, reduce, sorted
最后通过 .collect(Collectors.toXXX( )) 转为集合