Java复习1

java基础类型

  • 整形：int，long，short，byte
  • 浮点型：double，float
  • 布尔类型：boolean
  • 字符类型：char

int 4个字节
long 8个字节
short 2个字节
byte 1个字节

double 8个字节
float 4个字节

boolean 1个bit， 八分之一个字节

char 2个字节

引用类型

  • 强引用
    • 当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。
  • 软引用
    • 如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。
    • 可以用来内存敏感的高速缓存
    • 可以配合referenceQueue一起使用，当引用被回收的时候，JAVA 虚拟机就会把这个软引用加入到与之关联的引用队列中。
  • 弱引用
    • 与软引用类似，弱引用与软引用的区别在于：更短的生命周期，在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存
    • 弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java 虚拟机就会把这个弱引用加入到与之关联的引用队列中
  • 虚引用
    • 如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。 虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

包装类型：

  • 由于java有基础类型，基础类型本身并不是对象，所以其实本身违反了java的面向对象思想，所以将基础数据类型转换对应的包装类型，那么就可以操作基础类型像操作对象一样了。
基础类型 包装类型
boolean Boolean
char Character
long Long
byte Byte
int Integer
short Short
float Float
double Double
  • 自动拆箱和装箱
    • 拆箱：
      • 自动将包装类型转换成基础数据类型
      • 自动拆箱如果遇到包装给null，则会抛出NEP
    • 装箱：把基础数据类型转换成包装数据类型
      • 装修的数据如果是-128-127之间的数据。调用integer.valueof()会被缓存起来，具体源码如下，
        那么此时访问integer对象使用== ， 还是equals的结果是一致的，都是常量池的数据比较。访问在此区间之外的数据则是内存比较
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

Object

  • object具体方法：

    • hashcode()
    • equals()
    • wait()
    • notify()
    • notifyall()
    • clone()
    • toString()
    • getClass()
    • finalize() //实例被垃圾回收器回收的时候触发的操作
    • registerNatives()

  • equals 和 ==

    • 如果是两个引用类型比较，那么就是内存地址比较
    • == 不能重写值比较
    • 所有对象集成object都有equals方法，默认实现是==

  • equals 和 hashcode

    • 当equals方法被重写时，通常有必要重写hashCode方法，以维护hashCode方法的常规约定：值相同的对象必须有相同的hashCode。
    • hashCode不同时，object1.equals(object2)为false；
    • hashCode相同时，object1.equals(object2)不一定为true；
    • 当我们向一个Hash结构的集合中添加某个元素，集合会首先调用hashCode方法，这样就可以直接定位它所存储的位置，若该处没有其他元素，则直接保存。若该处已经有元素存在，就调用equals方法来匹配这两个元素是否相同，相同则不存，不同则链到后面（如果是链地址法）。

  • string sringbuffer stringbuilder

    • 三个都是final 类，不可以被集成
    • string不可变，sringbuffer stringbuilder长度可变
    • sringbuffer是线程安全的
    • stringbuilder线程不安全
    • StringBuffer在StringBuilder的方法之上添加了synchronized，保证线程安全。

  • string是final类，不可以继承，也不可以重写java.lang.String(类加载机制)

    • 双亲委派模型
      • 因为加载某个类的时候，优先使用父类加载器来加载需要使用的类。如果我们自定义了
        java.lang.String这个类
      • 加载该类的类加载器为appclassloader
      • appclassloader的父加载器为extclaassloader，所以这是加载string的类为extclassloader 但是在jre/lib/ext 下并没有发现string.class信息
      • 所以接着上传给顶级加载器bootstrap。
      • bootstrap在jre/lib目录下的rt.jar找到了string.class, 将其加载到内存中。
      • 这就会类加载器的委托模型
      • 所以用户自定义的类加载器不会生效

  • substring

    • 会创建一个新的string
    • 编译时会吧+转换成stringbuilder 的append方法
    • String = “abc”， 可能创建一个或者不创建对象，如果“ABC”在常量池中不存在，那么久会在常量池中创建一个String 对象，然后将对象的指向这个内存地址，以后无论创建多少次“abc”，都是相同的内存地址，
    • 注意： substring和new String 都是在堆中重新创建一个对象。

  • 常量池

    • String str = new String(“ABC”); 至少创建一个对象，也可能两个。因为用到new关键字，肯定会在heap中创建一个str2的String对象，它的value是“ABC”。同时如果这个字符串在字符串常量池里不存在，会在池里创建这个String对象“ABC”。

      • String s1= “a”;
      • String s2 = “a”;
      • 此时s1 == s2 返回true
      • “” 引号创建的对象在常量池塚
      • String s1= new String(“a”);
      • String s2 = new String(“a”);
      • 此时s1 == s2 返回false
      • 如果“a”在常量池中，那么仅在堆中拷贝一份引用（new String）
      • 如果“a”不在常量池塚，那么会现在常量池中创建一份数据，然后在进行堆拷贝，
      • 会创建两个对象

  • 编译优化
    final 都会在编译器优化，并且会被直接算好

  • String intern

    • jdk7以后吧常量池从方法区移到了堆上
    • 当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），则返回池中的字符串。

String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2);// false

String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);// true

String s = newString("1")，生成了常量池中的“1” 和堆空间中的字符串对象。
s.intern()，这一行的作用是s对象去常量池中寻找后发现"1"已经存在于常量池中了。
String s2 = "1"，这行代码是生成一个s2的引用指向常量池中的“1”对象。
结果就是 s 和 s2 的引用地址明显不同。因此返回了false。

String s3 = new String("1") + newString("1")，这行代码在字符串常量池中生成“1” ，并在堆空间中生成s3引用指向的对象（内容为"11"）。注意此时常量池中是没有 “11”对象的。
s3.intern()，这一行代码，是将 s3中的“11”字符串放入 String 常量池中，此时常量池中不存在“11”字符串，JDK1.6的做法是直接在常量池中生成一个 "11" 的对象。
但是在JDK1.7中，常量池中不需要再存储一份对象了，可以直接存储堆中的引用。这份引用直接指向 s3 引用的对象，也就是说s3.intern() ==s3会返回true。
String s4 = "11"， 这一行代码会直接去常量池中创建，但是发现已经有这个对象了，此时也就是指向 s3 引用对象的一个引用。因此s3 == s4返回了true。

String s3 = new String("1") + new String("1");
String s4 = "11";
s3.intern();
System.out.println(s3 == s4);// false

String s3 = new String("1") + newString("1")，这行代码在字符串常量池中生成“1” ，并在堆空间中生成s3引用指向的对象（内容为"11"）。注意此时常量池中是没有 “11”对象的。
String s4 = "11"， 这一行代码会直接去生成常量池中的"11"。
s3.intern()，这一行在这里就没什么实际作用了。因为"11"已经存在了。
结果就是 s3 和 s4 的引用地址明显不同。因此返回了false。

String str1 = new String("SEU") + new String("Calvin");
System.out.println(str1.intern() == str1);// true
System.out.println(str1 == "SEUCalvin");// true

str1.intern() == str1就是上面例子中的情况，str1.intern()发现常量池中不存在“SEUCalvin”，因此指向了str1。 "SEUCalvin"在常量池中创建时，也就直接指向了str1了。两个都返回true就理所当然啦。

String str2 = "SEUCalvin";//新加的一行代码，其余不变  
String str1 = new String("SEU") + new String("Calvin");
System.out.println(str1.intern() == str1);// false
System.out.println(str1 == "SEUCalvin");// false

str2先在常量池中创建了“SEUCalvin”，那么str1.intern()当然就直接指向了str2，你可以去验证它们两个是返回的true。后面的"SEUCalvin"也一样指向str2。所以谁都不搭理在堆空间中的str1了，所以都返回了false。

面向对象

  • 抽象类和接口的区别

    • 抽象类只能被继承并且只能继承一个，接口需要被实现但是可以实现多个
    • 抽象类中可以有成员变量；接口中的变量必须是static final的，必须是被初始化的，接口中只能有常量，不能有变量
    • 抽象类的中方法可以不是抽象的；但是接口中必须是抽象的
    • java 8 接口有default方法，可以被实现了

  • 使用场景：

    • 如果要创建不带变量和实现的基类，那么应该选择接口而不是抽象类
    • 如果知道某个类应该是基类，那么第一个选择的应该是让它成为一个接口，只有在必须要有方法定义和成员变量的时候，才应该选择抽象类。因为抽象类中允许存在一个或多个被具体实现的方法，只要方法没有被全部实现该类就仍是抽象类。

  • 重写和重载：

    • 编译期的静态多分派：overloading重载 根据调用引用类型和方法参数决定调用哪个方法（编译器）
    • 运行期的动态单分派：overriding 重写 根据指向对象的类型决定调用哪个方法（JVM）
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/yankang/p/13090469.html