Java基础学习笔记（四）

• Java语言有哪些特点

  1. 简单易学、有丰富的类库
  2. 面向对象（Java最重要的特性，让程序耦合度更低，内聚性更高）
  3. 平台无关性（JVM是Java跨平台使用的根本）
  4. 可靠安全
  5. 支持多线程

• Java程序执行过程

  我们日常的工作中都使用开发工具（IntelliJ IDEA 或 Eclipse 等）可以很方便的调试程序，或者是通过打包工具把项目打包成 jar 包或者 war 包，放入 Tomcat 等 Web 容器中就可以正常运行了，但你有没有想过 Java 程序内部是如何执行的？其实不论是在开发工具中运行还是在 Tomcat 中运行，Java 程序的执行流程基本都是相同的，它的执行流程如下：

  先把 Java 代码编译成字节码，也就是把 .java 类型的文件编译成 .class 类型的文件。这个过程的大致执行流程：Java 源代码 -> 词法分析器 -> 语法分析器 -> 语义分析器 -> 字符码生成器 ->最终生成字节码，其中任何一个节点执行失败就会造成编译失败；

  把 class 文件放置到 Java 虚拟机，这个虚拟机通常指的是 Oracle 官方自带的 Hotspot JVM；

  Java 虚拟机使用类加载器（Class Loader）装载 class 文件；

  类加载完成之后，会进行字节码效验，字节码效验通过之后 JVM 解释器会把字节码翻译成机器码交由操作系统执行。但不是所有代码都是解释执行的，JVM 对此做了优化，比如，以Hotspot 虚拟机来说，它本身提供了 JIT（Just In Time）也就是我们通常所说的动态编译器，它能够在运行时将热点代码编译为机器码，这个时候字节码就变成了编译执行。Java 程序执行流程图如下：

  

• Java创建对象有几种方式？

  1. **使用new关键字：**这也是我们平时使用最多的创建对象的方式，示例：User user=new User();
  2. **使用反射机制：**使用newInstance()，但是得处理两个异常 InstantiationException、IllegalAccessException： User user=User.class.newInstance(); Object object=(Object)Class.forName("java.lang.Object").newInstance()
  3. **使用clone方法：**前面题目中 clone 是 Object 的方法，所以所有对象都有这个方法。
  4. **使用反序列化机制：**调用ObjectInputStream类的readObject()方法。我们反序列化一个对象，JVM 会给我们创建一个单独的对象。JVM 创建对象并不会调用任何构造函数。一个对象实现了Serializable接口，就可以把对象写入到文件中，并通过读取文件来创建对象。

• **Java获取类Class对象有几种方式？**

  第一种：通过类对象的 getClass()方法获取，细心点的都知道，这个 getClass是 Object 类里面的方法。

  User user=new User();
  //clazz就是一个User的类对象
  Class<?> clazz=user.getClass();
  

  第二种：通过类的静态成员表示，每个类都有隐含的静态成员 class。

  //clazz就是一个User的类对象
  Class<?> clazz=User.class;
  

  第三种：通过 Class 类的静态方法 forName() 方法获取。

  Class<?> clazz = Class .forName("com.tian.User");
  

• Java四种引用，强弱软虚

  • 强引用

    强引用是平常中使用最多的引用，强引用在程序内存不足（OOM）的时候也不会被回收，使用方式：

    String str = new String("str");
    System.out.println(str);
    

  • 软引用

    软引用在程序内存不足时，会被回收，使用方式：

    // 注意：wrf这个引用也是强引用，它是指向SoftReference这个对象的，
    // 这里的软引用指的是指向new String("str")的引用，也就是SoftReference类中T
    SoftReference<String> wrf = new SoftReference<String>(new String("str"));
    

    可用场景： 创建缓存的时候，创建的对象放进缓存中，当内存不足时，JVM就会回收早先创建的对象。

  • 弱引用

    弱引用就是只要JVM垃圾回收器发现了它，就会将之回收，使用方式：

    WeakReference<String> wrf = new WeakReference<String>(str);
    

    可用场景：Java源码中的java.util.WeakHashMap中的 key 就是使用弱引用，我的理解就是，一旦我不需要某个引用，JVM会自动帮我处理它，这样我就不需要做其它操作。

  • 虚引用

    虚引用的回收机制跟弱引用差不多，但是它被回收之前，会被放入 ReferenceQueue中。注意哦，其它引用是被JVM回收后才被传入 ReferenceQueue中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。还有就是，虚引用创建的时候，必须带有 ReferenceQueue，使用例子：

    PhantomReference<String> prf = new PhantomReference<String>(new String("str"), new ReferenceQueue<>());
    

    可用场景： 对象销毁前的一些操作，比如说资源释放等。 Object.finalize() 虽然也可以做这类动作，但是这个方式即不安全又低效。

  上诉所说的几类引用，都是指对象本身的引用，而不是指Reference的四个子类的引用(SoftReference等)。

• 面向对象和面向过程的区别

  面向过程： 是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调用即可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发。

  面向对象： 是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。

• 标识符的命名规则

  标识符的含义： 是指在程序中，我们自己定义的内容，譬如，类的名字，方法名称以及变量名称等等，都是标识符。

  命名规则：（硬性要求） 标识符可以包含英文字母，0-9的数字，$以及_ 标识符不能以数字开头 标识符不是关键字

  命名规范：（非硬性要求） 类名规范：首字符大写，后面每个单词首字母大写（大驼峰式）。 变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。 方法名规范：同变量名。

• 八种基本数据类型的大小，以及他们的封装类

  

  int是基本数据类型，Integer是int的封装类，是引用类型。int默认值是0，而Integer默认值是null，所以Integer能区分出0和null的情况。一旦看到null，就知道这个引用还没有指向某个对象，在任何引用使用前，必须为其指定一个对象，否则会报错。

  基本数据类型在声明时系统会自动给它分配空间，而引用类型声明只分配了引用空间，必须通过实例化开辟数据空间之后才可以赋值。数组对象也是一个引用对象，将一个数组赋值给另一个数组时只是复制了一个引用，所以通过某一个数组所做的修改在另一个数组中也看的见。

  虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任何提供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素boolean元素占8位。这样我们可以得出boolean类型占了单独使用是4个字节，在数组中又是1个字节。使用int的原因是，对于32位的处理器（CPU）来说，一次处理数据是32位（这里不是指的是32/64位系统，而是指CPU硬件层面），具有高效存取的特点。

• 自动装箱与拆箱

  装箱就是自动将基本数据类型转换为包装器类型（int-->Integer）；调用方法：Integer的valueOf(int)方法

  拆箱就是自动将包装器类型转换为基本数据类型（Integer-->int）。调用方法：Integer的intValue方法

  public class Main {
  	 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
  	 }
  }
  
  public class Main {
  	 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
  	 }
  }
  
  //在[-128,127]之间，返回Cache中已存在的对象，否则创建一个
  public static Integer valueOf(int i) {
  	if(i >= -128 && i <= IntegerCache.high)
  		return IntegerCache.cache[i + 128];
  	else
  		return new Integer(i);
  }
  

• 重载和重写的区别

  • 重写Override 从字面上看，重写就是重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下， 对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。
    1. 发生在父类与子类之间
    2. 方法名，参数列表，返回类型（除过子类中方法的返回类型是父类中返回类型的子类）必须相同
    3. 访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private)
    4. 重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常
  • 重载Overload 在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。
    1. 重载Overload是一个类中多态性的一种表现
    2. 重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)
    3. 重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准

• equals与==的区别

  • == ：

    == 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。

    1. 比较的是操作符两端的操作数是否是同一个对象
    2. 两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过
    3. 比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true

    如：int a = 10与long b = 10L与double c = 10.0都是相同的（为true），因为他们都指向地址为10的堆。

  • equals：

    equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。

    所有比较是否相等时，都是用equals并且在对常量相比较时，把常量写在前面，因为使用object的equals，object可能为null，则空指针。

    阿里的代码规范中只使用equals，阿里插件默认会识别，并可以快速修改，推荐安装阿里插件来排查老代码使用==，替换成equals。

• Hashcode

  java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法就会比较慢。

  hashCode方法可以这样理解：它返回的就是根据对象的内存地址换算出的一个值。这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

  • 有没有可能两个不相等的对象有相同的hashcode

    有可能。在产生哈希冲突时，两个不相等的对象就会有相同的 hashcode值。当hash冲突产生时，一有以下几种方式来处理：

    拉链法：每个哈希表节点都有一个next指针，多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向链表进行存储。

    开放定址法：一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将记录存入。

    再哈希：又叫双哈希法，有多个不同的Hash函数。当发生冲突时，使用第二个，第三个…等哈希函数计算地址,直到无冲突。

• **fail-fast**

  fail-fast机制是 Java 集合Collection中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。

  例如：当某一个线程 A 通过 iterator 去遍历某集合的过程中，若该集合的内容被其他线程所改变了，那么线程 A 访问集合时，就会抛出 ConcurrentModificationException 异常，产生 fail-fast 事件。这里的操作主要是指 add、remove和 clear，对集合元素个数进行修改。

  解决办法：建议使用“java.util.concurrent包下的类”去取代“java.util包下的类”。

  可以这么理解：在遍历之前，把 modCount 记下来 expectModCount，后面 expectModCount 去和 modCount 进行比较，如果不相等了，证明已并发了，被修改了，于是抛出ConcurrentModificationException异常。

• 深拷贝和浅拷贝

  浅拷贝（shallowCopy）只是增加了一个指针指向已存在的内存地址，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

  深拷贝（deepCopy）是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存，拷贝把要复制的对象所引用的对象都复制了一遍。

  使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。