Java修炼之道--基础

时间  2019-11-12
标签 java 修炼 之道 基础 栏目 Java 繁體版
原文   原文链接

原做地址：https://github.com/frank-lam/2019_campus_applyhtml

前言

为了更好的总结Java面试中的系统知识结构，本文根据如下资料整理学习笔记。java

1、基本概念

1. Java程序初始化的顺序是怎么样的

　　在 Java 语言中，当实例化对象时，对象所在类的全部成员变量首先要进行初始化，只有当全部类成员完成初始化后，才会调用对象所在类的构造函数建立象。mysql

初始化通常遵循3个原则：c++

  • 静态对象（变量）优先于非静态对象（变量）初始化，静态对象（变量）只初始化一次，而非静态对象（变量）可能会初始化屡次；
  • 父类优先于子类进行初始化；
  • 按照成员变量的定义顺序进行初始化。 即便变量定义散布于方法定义之中，它们依然在任何方法（包括构造函数）被调用以前先初始化；

加载顺序git

  • 父类（静态变量、静态语句块）
  • 子类（静态变量、静态语句块）
  • 父类（实例变量、普通语句块）
  • 父类（构造函数）
  • 子类（实例变量、普通语句块）
  • 子类（构造函数）

实例程序员

class Base {
    // 1.父类静态代码块
    static {
        System.out.println("Base static block!");
    }
    // 3.父类非静态代码块
    {
        System.out.println("Base block");
    }
    // 4.父类构造器
    public Base() {
        System.out.println("Base constructor!");
    }
}

public class Derived extends Base {
    // 2.子类静态代码块
    static{
        System.out.println("Derived static block!");
    }
    // 5.子类非静态代码块
    {
        System.out.println("Derived block!");
    }
    // 6.子类构造器
    public Derived() {
        System.out.println("Derived constructor!");
    }
    public static void main(String[] args) {
        new Derived();
    }
}

结果是：github

Base static block!
Derived static block!
Base block
Base constructor!
Derived block!
Derived constructor!

2. Java和C++的区别

  • Java 是纯粹的面向对象语言，全部的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
  • Java 经过虚拟机从而实现跨平台特性，可是 C++ 依赖于特定的平台。
  • Java 没有指针，它的引用能够理解为安全指针，而 C++ 具备和 C 同样的指针。
  • Java 支持自动垃圾回收，而 C++ 须要手动回收。（C++11 中引入智能指针，使用引用计数法垃圾回收）
  • Java 不支持多重继承，只能经过实现多个接口来达到相同目的，而 C++ 支持多重继承。
  • Java 不支持操做符重载，虽然能够对两个 String 对象支持加法运算，可是这是语言内置支持的操做，不属于操做符重载，而 C++ 能够。
  • Java 内置了线程的支持，而 C++ 须要依靠第三方库。
  • Java 的 goto 是保留字，可是不可用，C++ 能够使用 goto。
  • Java 不支持条件编译，C++ 经过 #ifdef #ifndef 等预处理命令从而实现条件编译。

参考资料：web

3. 反射

先看一个知乎回答

　　首先看一个在知乎上的优秀回答吧：面试

　　反射是什么呢？当咱们的程序在运行时，须要动态的加载一些类这些类可能以前用不到因此不用加载到 JVM，而是在运行时根据须要才加载，这样的好处对于服务器来讲不言而喻。算法

　　举个例子咱们的项目底层有时是用 mysql，有时用 oracle，须要动态地根据实际状况加载驱动类，这个时候反射就有用了，假设 com.java.dbtest.myqlConnection，com.java.dbtest.oracleConnection 这两个类咱们要用，这时候咱们的程序就写得比较动态化，经过Class tc = Class.forName("com.java.dbtest.TestConnection"); 经过类的全类名让 JVM 在服务器中找到并加载这个类，而若是是 oracle 则传入的参数就变成另外一个了。这时候就能够看到反射的好处了，这个动态性就体现出 Java 的特性了！

　　举多个例子，你们若是接触过spring，会发现当你配置各类各样的bean时，是以配置文件的形式配置的，你须要用到哪些bean就配哪些，spring容器就会根据你的需求去动态加载，你的程序就能健壮地运行。

什么是反射

　　反射 (Reflection) 是 Java 程序开发语言的特征之一，它容许运行中的 Java 程序获取自身的信息，而且能够操做类或对象的内部属性。经过 Class 获取 class 信息称之为反射（Reflection）

　　简而言之，经过反射，咱们能够在运行时得到程序或程序集中每个类型的成员和成员的信息。

　　程序中通常的对象的类型都是在编译期就肯定下来的，而 Java 反射机制能够动态地建立对象并调用其属性，这样的对象的类型在编译期是未知的。因此咱们能够经过反射机制直接建立对象，即便这个对象的类型在编译期是未知的。

　　反射的核心是 JVM 在运行时才动态加载类或调用方法/访问属性，它不须要事先（写代码的时候或编译期）知道运行对象是谁。

Java 反射框架主要提供如下功能：

  1. 在运行时判断任意一个对象所属的类；
  2. 在运行时构造任意一个类的对象；
  3. 在运行时判断任意一个类所具备的成员变量和方法（经过反射甚至能够调用private方法）；
  4. 在运行时调用任意一个对象的方法

重点：是运行时而不是编译时

主要用途

　　不少人都认为反射在实际的Java开发应用中并不普遍，其实否则。

当咱们在使用IDE(如Eclipse，IDEA)时，当咱们输入一个对象或类并想调用它的属性或方法时，一按点号，编译器就会自动列出它的属性或方法，这里就会用到反射。

　　反射最重要的用途就是开发各类通用框架

　　不少框架（好比Spring）都是配置化的（好比经过XML文件配置JavaBean,Action之类的），为了保证框架的通用性，它们可能须要根据配置文件加载不一样的对象或类，调用不一样的方法，这个时候就必须用到反射——运行时动态加载须要加载的对象。

　　对与框架开发人员来讲，反射虽小但做用很是大，它是各类容器实现的核心。而对于通常的开发者来讲，不深刻框架开发则用反射用的就会少一点，不过了解一下框架的底层机制有助于丰富本身的编程思想，也是颇有益的。

得到Class对象

  1. 调用运行时类自己的 .class 属性
Class clazz1 = Person.class;
System.out.println(clazz1.getName());
  1. 经过运行时类的对象获取 getClass();
Person p = new Person();
Class clazz3 = p.getClass();
System.out.println(clazz3.getName());
  1. 使用 Class 类的 forName 静态方法
public static Class<?> forName(String className)
// 在JDBC开发中经常使用此方法加载数据库驱动:
Class.forName(driver);
  1. （了解）经过类的加载器 ClassLoader
ClassLoader classLoader = this.getClass().getClassLoader();
Class clazz5 = classLoader.loadClass(className);
System.out.println(clazz5.getName());

参考资料：

4. 注解

什么是注解

　　Annontation 是 Java5 开始引入的新特征，中文名称叫注解。它提供了一种安全的相似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，而且供指定的工具或框架使用。Annontation 像一种修饰符同样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。

　　Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的做用。包含在 java.lang.annotation 包中。

　　简单来讲：注解其实就是代码中的特殊标记，这些标记能够在编译、类加载、运行时被读取，并执行相对应的处理。

为何要用注解

传统的方式，咱们是经过配置文件 .xml 来告诉类是如何运行的。

有了注解技术之后，咱们就能够经过注解告诉类如何运行

例如：咱们之前编写 Servlet 的时候，须要在 web.xml 文件配置具体的信息。咱们使用了注解之后，能够直接在 Servlet 源代码上，增长注解...Servlet 就被配置到 Tomcat 上了。也就是说，注解能够给类、方法上注入信息。

明显地能够看出，这样是很是直观的，而且 Servlet 规范是推崇这种配置方式的。

基本Annotation

在 java.lang 包下存在着5个基本的 Annotation，重点掌握前三个。

  1. @Override 重写注解
    • 若是咱们使用IDE重写父类的方法，咱们就能够看见它了。
    • @Override是告诉编译器要检查该方法是实现父类的，能够帮咱们避免一些低级的错误。
    • 好比，咱们在实现 equals() 方法的时候，把 euqals() 打错了，那么编译器就会发现该方法并非实现父类的，与注解 @Override 冲突，因而就会给予错误。
  2. @Deprecated 过期注解
    • 该注解也很是常见，Java 在设计的时候，可能以为某些方法设计得很差，为了兼容之前的程序，是不能直接把它抛弃的，因而就设置它为过期。
    • Date对象中的 toLocalString() 就被设置成过期了
    • 当咱们在程序中调用它的时候，在 IDE 上会出现一条横杠，说明该方法是过期的。
@Deprecated
public String toLocaleString() {
    DateFormat formatter = DateFormat.getDateTimeInstance();
    return formatter.format(this);
}
  1. @SuppressWarnings 抑制编译器警告注解
    • 该注解在咱们写程序的时候并非很常见，咱们能够用它来让编译器不给予咱们警告
    • 当咱们在使用集合的时候，若是没有指定泛型，那么会提示安全检查的警告
    • 若是咱们在类上添加了@SuppressWarnings这个注解，那么编译器就不会给予咱们警告了
  2. @SafeVarargs Java 7“堆污染”警告
    • 什么是堆污染呢？？当把一个不是泛型的集合赋值给一个带泛型的集合的时候，这种状况就很容易发生堆污染。
    • 这个注解也是用来抑制编译器警告的注解，用的地方并很少。
  3. @FunctionalInterface 用来指定该接口是函数式接口
    • 用该注解显示指定该接口是一个函数式接口。

自定义注解类编写规则

  1. Annotation 型定义为 @interface, 全部的 Annotation 会自动继承 java.lang.Annotation 这一接口，而且不能再去继承别的类或是接口.
  2. 参数成员只能用 public 或默认(default)这两个访问权修饰
  3. 参数成员只能用基本类型 byte,short,char,int,long,float,double,boolean 八种基本数据类型和 String、Enum、Class、annotations 等数据类型，以及这一些类型的数组
  4. 要获取类方法和字段的注解信息，必须经过 Java 的反射技术来获取 Annotation 对象，由于你除此以外没有别的获取注解对象的方法
  5. 注解也能够没有定义成员, 不过这样注解就没啥用了
    PS：自定义注解须要使用到元注解

自定义注解实例

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * 水果名称注解
 */
@Target(FIELD)
@Retention(RUNTIME)
@Documented
public @interface FruitName {
    String value() default "";
}

参考资料：注解Annotation实现原理与自定义注解例子

5. 泛型

通俗解释

　　通俗的讲，泛型就是操做类型的 占位符，即：假设占位符为 T，那么这次声明的数据结构操做的数据类型为T类型。

　　假定咱们有这样一个需求：写一个排序方法，可以对整型数组、字符串数组甚至其余任何类型的数组进行排序，该如何实现？答案是能够使用 Java 泛型。

　　使用 Java 泛型的概念，咱们能够写一个泛型方法来对一个对象数组排序。而后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。

泛型方法

　　你能够写一个泛型方法，该方法在调用时能够接收不一样类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每个方法调用。

下面是定义泛型方法的规则：

  • 全部泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型以前（在下面例子中的 <E>）。
  • 每个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
  • 类型参数能被用来声明返回值类型，而且能做为泛型方法获得的实际参数类型的占位符。
  • 泛型方法体的声明和其余方法同样。注意类型参数 只能表明引用型类型，不能是原始类型 （像 int,double,char 的等）。
public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 建立不一样类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组
 
        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}

泛型类

　　泛型类的声明和非泛型类的声明相似，除了在类名后面添加了类型参数声明部分。

　　和泛型方法同样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。由于他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

public class Box<T> {
    private T t;
    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<Integer>();
        Box<String> stringBox = new Box<String>();

        integerBox.add(new Integer(10));
        stringBox.add(new String("菜鸟教程"));

        System.out.printf("整型值为 :%d\n\n", integerBox.get());
        System.out.printf("字符串为 :%s\n", stringBox.get());
    }
}

类型通配符

  1. 类型通配符通常是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List<String>，List<Integer> 等全部 List <具体类型实参> 的父类。
  2. 类型通配符上限经过形如 List 来定义，如此定义就是通配符泛型值接受 Number 及其下层子类类型。
  3. 类型通配符下限经过形如 List<? super Number> 来定义，表示类型只能接受 Number 及其三层父类类型，如 Objec 类型的实例。

参考资料：

6. 字节与字符的区别

理解编码的关键，是要把字符的概念和字节的概念理解准确。这两个概念容易混淆，咱们在此作一下区分：

类型 概念描述 举例
字符 人们使用的记号，抽象意义上的一个符号。 '1', '中', 'a', '$', '￥', ……
字节 计算机中存储数据的单元，一个 8 位的二进制数，是一个很具体的存储空间。 0x01, 0x45, 0xFA, ……
ANSI 字符串 在内存中，若是“字符”是以 ANSI 编码形式存在的，一个字符可能使用一个字节或多个字节来表示，那么咱们称这种字符串为 ANSI 字符串或者多字节字符串。 "中文123" （占7字节）
UNICODE 字符串 在内存中，若是“字符”是以在 UNICODE 中的序号存在的，那么咱们称这种字符串为 UNICODE 字符串或者宽字节字符串。 L"中文123" （占10字节）

字节与字符区别

它们彻底不是一个位面的概念，因此二者之间没有“区别”这个说法。不一样编码里，字符和字节的对应关系不一样：

类型 概念描述
ASCII 一个英文字母（不分大小写）占一个字节的空间，一个中文汉字占两个字节的空间。一个二进制数字序列，在计算机中做为一个数字单元，通常为8位二进制数，换算为十进制。最小值0，最大值255。
UTF-8 一个英文字符等于一个字节，一个中文（含繁体）等于三个字节
Unicode 一个英文等于两个字节，一个中文（含繁体）等于两个字节。符号：英文标点占一个字节，中文标点占两个字节。举例：英文句号“.”占1个字节的大小，中文句号“。”占2个字节的大小。
UTF-16 一个英文字母字符或一个汉字字符存储都须要2个字节（Unicode扩展区的一些汉字存储须要4个字节）
UTF-32 世界上任何字符的存储都须要4个字节

参考资料：

7. 有哪些访问修饰符

Java面向对象的基本思想之一是封装细节而且公开接口。Java语言采用访问控制修饰符来控制类及类的方法和变量的访问权限，从而向使用者暴露接口，但隐藏实现细节。访问控制分为四种级别：

修饰符 当前类 同 包 子 类 其余包
public √ √ √ √
protected √ √ √ ×
default √ √ × ×
private √ × × ×
  • 类的成员不写访问修饰时默认为default。默认对于同一个包中的其余类至关于公开（public），对于不是同一个包中的其余类至关于私有（private）。
  • 受保护（protected）对子类至关于公开，对不是同一包中的没有父子关系的类至关于私有。
  • Java中，外部类的修饰符只能是public或默认，类的成员（包括内部类）的修饰符能够是以上四种。

8. 深拷贝与浅拷贝

  • 浅拷贝：被复制对象的全部变量都含有与原来的对象相同的值，而全部的对其余对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制所拷贝的对象，而不复制它所引用的对象。
  • 深拷贝：对基本数据类型进行值传递，对引用数据类型，建立一个新的对象，并复制其内容，此为深拷贝。

参考资料：

9. Lamda表达式

跟上Java8 - 了解lambda
https://zhuanlan.zhihu.com/p/28093333

10. 字符串常量池

Java 中字符串对象建立有两种形式，一种为字面量形式，如 String str = "droid";，另外一种就是使用 new 这种标准的构造对象的方法，如 String str = new String("droid");，这两种方式咱们在代码编写时都常用，尤为是字面量的方式。然而这两种实现其实存在着一些性能和内存占用的差异。这一切都是源于 JVM 为了减小字符串对象的重复建立，其维护了一个特殊的内存，这段内存被成为字符串常量池或者字符串字面量池。

工做原理

当代码中出现字面量形式建立字符串对象时，JVM首先会对这个字面量进行检查，若是字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回，不然新的字符串对象被建立，而后将这个引用放入字符串常量池，并返回该引用。

public class Test {
    public static void main(String[] args) {

        String s1 = "abc";
        String s2 = "abc";

        // 以上两个局部变量都存在了常量池中
        System.out.println(s1 == s2); // true


        // new出来的对象不会放到常量池中,内存地址是不一样的
        String s3 = new String();
        String s4 = new String();

        /**
        * 字符串的比较不能够使用双等号,这样会比较内存地址
        * 字符串比较应当用equals,可见String重写了equals
        */
        System.out.println(s3 == s4); // false
        System.out.println(s3.equals(s4)); // true
    }
}

2、面向对象

1. Java的四个基本特性，对多态的理解，在项目中哪些地方用到多态

  • Java的四个基本特性
    • 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 
    • 封装：一般认为封装是把数据和操做数据的方法绑定起来，对数据的访问只能经过已定义的接口。面向对象的本质就是将现实世界描绘成一系列彻底自治、封闭的对象。咱们在类中编写的方法就是对实现细节的一种封装；咱们编写一个类就是对数据和数据操做的封装。能够说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。
    • 继承：继承是从已有类获得继承信息建立新类的过程。提供继承信息的类被称为父类（超类、基类）；获得继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了必定的延续性，同时继承也是封装程序中可变因素的重要手段。
    • 多态：多态性是指容许不一样子类型的对象对同一消息做出不一样的响应。
  • 多态的理解(多态的实现方式)
    • 方法重载（overload）：实现的是编译时的多态性（也称为前绑定）。
    • 方法重写（override）：实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西。
    • 要实现多态须要作两件事：
      • 1) 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；
      • 2) 对象造型（用父类型引用引用子类型对象，这样一样的引用调用一样的方法就会根据子类对象的不一样而表现出不一样的行为）。
  • 项目中对多态的应用
    • 举一个简单的例子，在物流信息管理系统中，有两种用户：订购客户和卖房客户，两个客户均可以登陆系统，他们有相同的方法 Login，但登录以后他们会进入到不一样的页面，也就是在登陆的时候会有不一样的操做，两种客户都继承父类的 Login 方法，但对于不一样的对象，拥有不一样的操做。
  • 面相对象开发方式优势（B65）
    • 较高的开发效率：能够把事物进行抽象，映射为开发的对象。
    • 保证软件的鲁棒性：高重用性，能够重用已有的并且在相关领域通过长期测试的代码。
    • 保证软件的高可维护性：代码的可读性很是好，设计模式也使得代码结构清晰，拓展性好。

2. 什么是重载和重写

  • 重载：重载发生在同一个类中，同名的方法若是有不一样的参数列表（参数类型不一样、参数个数不一样或者两者都不一样）则视为重载。
  • 重写：重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。根据不一样的子类对象肯定调用的那个方法。

3. 面向对象和面向过程的区别？用面向过程能够实现面向对象吗？

  • 面向对象和面向过程的区别
    • 面向过程就像是一个细心的管家，事无具细的都要考虑到。而面向对象就像是个家用电器，你只须要知道他的功能，不须要知道它的工做原理。
    • 面向过程是一种是“事件”为中心的编程思想。就是分析出解决问题所需的步骤，而后用函数把这些步骤实现，并按顺序调用。面向对象是以“对象”为中心的编程思想。
    • 简单的举个例子：汽车发动、汽车到站
      • 这对于 面向过程 来讲，是两个事件，汽车启动是一个事件，汽车到站是另外一个事件，面向过程编程的过程当中咱们关心的是事件，而不是汽车自己。针对上述两个事件，造成两个函数，之 后依次调用。（事件驱动，动词为主）
      • 然而这对于面向对象来讲，咱们关心的是汽车这类对象，两个事件只是这类对象所具备的行为。并且对于这两个行为的顺序没有强制要求。（对象驱动，名词为主，将问题抽象出具体的对象，而这个对象有本身的属性和方法，在解决问题的时候是将不一样的对象组合在一块儿使用）
  • 用面向过程能够实现面向对象吗 ？
    • 若是是 C 语言来展示出面向对象的思想，C 语言中是否是有个叫结构体的东西，这个里面有本身定义的变量 能够经过函数指针就能够实现对象

4. 面向对象开发的六个基本原则，在项目中用过哪些原则

  • 六个基本原则（参考《设计模式之禅》）
    • 单一职责（Single Responsibility Principle 简称 SRP）：一个类应该仅有一个引发它变化的缘由。在面向对象中，若是只让一个类完成它该作的事，而不涉及与它无关的领域就是践行了高内聚的原则，这个类就只有单一职责。
    • 里氏替换（Liskov Substitution Principle 简称 LSP）：任什么时候候子类型可以替换掉它们的父类型。子类必定是增长父类的能力而不是减小父类的能力，由于子类比父类的能力更多，把能力多的对象当成能力少的对象来用固然没有任何问题。
    • 依赖倒置（Dependence Inversion Principle 简称 DIP）：要依赖于抽象，不要依赖于具体类。要作到依赖倒置，应该作到：①高层模块不该该依赖底层模块，两者都应该依赖于抽象；②抽象不该该依赖于具体实现，具体实现应该依赖于抽象。
    • 接口隔离（Interface Segregation Principle 简称 ISP）：不该该强迫客户依赖于他们不用的方法 。接口要小而专，毫不能大而全。臃肿的接口是对接口的污染，既然接口表示能力，那么一个接口只应该描述一种能力，接口也应该是高度内聚的。
    • 最少知识原则（Least Knowledge Principle 简称 LKP）：只和你的朋友谈话。迪米特法则又叫最少知识原则，一个对象应当对其余对象有尽量少的了解。
    • 开放封闭（Open Closed Principle 简称 OCP）：软件实体应当对扩展开放，对修改关闭。要作到开闭有两个要点：①抽象是关键，一个系统中若是没有抽象类或接口系统就没有扩展点；②封装可变性，将系统中的各类可变因素封装到一个继承结构中，若是多个可变因素混杂在一块儿，系统将变得复杂而换乱。
  • 其余原则
    • 合成聚和复用：优先使用聚合或合成关系复用代码
    • 面向接口编程
    • 优先使用组合，而非继承
    • 一个类须要的数据应该隐藏在类的内部
    • 类之间应该零耦合，或者只有传导耦合，换句话说，类之间要么不要紧，要么只使用另外一个类的接口提供的操做
    • 在水平方向上尽量统一地分布系统功能
  • 项目中用到的原则
    • 单一职责、开放封闭、合成聚合复用(最简单的例子就是String类)、接口隔离

5. 内部类有哪些

能够将一个类的定义放在另外一个类的定义内部，这就是内部类。

在 Java 中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类

（一）成员内部类

成员内部类也是最普通的内部类，它是外围类的一个成员，因此他是能够无限制的访问外围类的全部成员属性和方法，尽管是private的，可是外围类要访问内部类的成员属性和方法则须要经过内部类实例来访问。

public class OuterClass {
    private String str;
   
    public void outerDisplay(){
        System.out.println("outerClass...");
    }
    
    public class InnerClass{
        public void innerDisplay(){
            str = "chenssy..."; //使用外围内的属性
            System.out.println(str);
            outerDisplay();  //使用外围内的方法
        }
    }
    
    // 推荐使用getxxx()来获取成员内部类，尤为是该内部类的构造函数无参数时
    public InnerClass getInnerClass(){
        return new InnerClass();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.getInnerClass();
        inner.innerDisplay();
    }
}
--------------------
chenssy...
outerClass...

在成员内部类中要注意两点：

  • 成员内部类中不能存在任何 static 的变量和方法；
  • 成员内部类是依附于外围类的，因此只有先建立了外围类才可以建立内部类。

（二）局部内部类

有这样一种内部类，它是嵌套在方法和做用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想建立一个类来辅助咱们的解决方案，到那时又不但愿这个类是公共可用的，因此就产生了局部内部类，局部内部类和成员内部类同样被编译，只是它的做用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。

//定义在方法里：
public class Parcel5 {
    public Destionation destionation(String str){
        class PDestionation implements Destionation{
            private String label;
            private PDestionation(String whereTo){
                label = whereTo;
            }
            public String readLabel(){
                return label;
            }
        }
        return new PDestionation(str);
    }
    
    public static void main(String[] args) {
        Parcel5 parcel5 = new Parcel5();
        Destionation d = parcel5.destionation("chenssy");
    }
}

//定义在做用域内:
public class Parcel6 {
    private void internalTracking(boolean b){
        if(b){
            class TrackingSlip{
                private String id;
                TrackingSlip(String s) {
                    id = s;
                }
                String getSlip(){
                    return id;
                }
            }
            TrackingSlip ts = new TrackingSlip("chenssy");
            String string = ts.getSlip();
        }
    }
    
    public void track(){
        internalTracking(true);
    }
    
    public static void main(String[] args) {
        Parcel6 parcel6 = new Parcel6();
        parcel6.track();
    }
}

（三）匿名内部类

匿名内部类也就是没有名字的内部类。正由于没有名字，因此匿名内部类只能使用一次，它一般用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

实例1：不使用匿名内部类来实现抽象方法

abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

运行结果：eat something

能够看到，咱们用 Child 继承了 Person 类，而后实现了 Child 的一个实例，将其向上转型为 Person 类的引用

可是，若是此处的 Child 类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？

这个时候就引入了匿名内部类

实例2：匿名内部类的基本实现

abstract class Person {
    public abstract void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

运行结果：eat something

能够看到，咱们直接将抽象类 Person 中的方法在大括号中实现了，这样即可以省略一个类的书写，而且，匿名内部类还能用于接口上。

实例3：在接口上使用匿名内部类

interface Person {
    public void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

运行结果：eat something

由上面的例子能够看出，只要一个类是抽象的或是一个接口，那么其子类中的方法均可以使用匿名内部类来实现

最经常使用的状况就是在多线程的实现上，由于要实现多线程必须继承 Thread 类或是继承 Runnable 接口

实例4：Thread类的匿名内部类实现

public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

运行结果：1 2 3 4 5

实例5：Runnable接口的匿名内部类实现

public class Demo {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
    }
}

运行结果：1 2 3 4 5

（四）静态内部类

关键字 static 中提到 static 能够修饰成员变量、方法、代码块，其余它还能够修饰内部类，使用 static 修饰的内部类咱们称之为静态内部类，不过咱们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别，咱们知道非静态内部类在编译完成以后会隐含地保存着一个引用，该引用是指向建立它的外围内，可是静态内部类却没有。

  1. 它的建立是不须要依赖于外围类的。
  2. 它不能使用任何外围类的非 static 成员变量和方法。
public class OuterClass {
    private String sex;
    public static String name = "chenssy";
    
    // 静态内部类 
    static class InnerClass1{
        // 在静态内部类中能够存在静态成员
        public static String _name1 = "chenssy_static";
        
        public void display(){ 
            // 静态内部类只能访问外围类的静态成员变量和方法
           // 不能访问外围类的非静态成员变量和方法
            System.out.println("OutClass name :" + name);
        }
    }
    

    // 非静态内部类
    class InnerClass2{
        // 非静态内部类中不能存在静态成员
        public String _name2 = "chenssy_inner";
        // 非静态内部类中能够调用外围类的任何成员,无论是静态的仍是非静态的
        public void display(){
            System.out.println("OuterClass name：" + name);
        }
    }
    
    // 外围类方法
    public void display(){
        // 外围类访问静态内部类：内部类
        System.out.println(InnerClass1._name1);
        // 静态内部类 能够直接建立实例不须要依赖于外围类
        new InnerClass1().display();
        
        // 非静态内部的建立须要依赖于外围类
        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
        // 方位非静态内部类的成员须要使用非静态内部类的实例
        System.out.println(inner2._name2);
        inner2.display();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
    }
}
----------------
Output:
chenssy_static
OutClass name :chenssy
chenssy_inner
OuterClass name：chenssy

6. 组合、继承和代理的区别

定义

  • 组合：在新类中 new 另一个类的对象，以添加该对象的特性。
  • 继承：从基类继承获得子类，得到父类的特性。
  • 代理：在代理类中建立某功能的类，调用类的一些方法以得到该类的部分特性。

使用场合

  • 组合：各部件之间没什么关系，只须要组合便可。例如组装电脑，须要 new CPU(),new RAM(),new Disk()

    public class Computer {
    public Computer() {
        CPU cpu=new CPU();
        RAM ram=new RAM();
        Disk disk=new Disk();
    }
}
class CPU{    }
class RAM{    }
class Disk{    }

  • 继承：子类须要具备父类的功能，各子类之间有所差别。例如 Shape 类做为父类，子类有 Rectangle，CirCle，Triangle……代码不写了，你们都常常用。

  • 代理：飞机控制类，我不想暴露太多飞机控制的功能，只需部分前进左右转的控制（而不须要暴露发射导弹功能）。经过在代理类中 new 一个飞机控制对象，而后在方法中添加飞机控制类的各个须要暴露的功能。

    public class PlaneDelegation{    
    private PlaneControl planeControl;    //private外部不可访问

    // 飞行员权限代理类，普通飞行员不能够开火
    PlaneDelegation(){
        planeControl = new PlaneControl();
    }
    public void speed(){
        planeControl.speed();
    }
    public void left(){
        planeControl.left();
    }
    public void right(){
        planeControl.right();
    }
}

final class PlaneControl {// final表示不可继承，控制器都能继承那还得了
    protected void speed() {}
    protected void fire() {}
    protected void left() {}
    protected void right() {}
}

说明：

  • 继承：代码复用，引用不灵活；
  • 组合：代码复用，
  • 接口：引用灵活；
  • 推荐组合+接口使用，看 IO 中包装流 FilterInputStream 中的策略模式

7. 什么是构造函数

构造函数是函数的一种特殊形式。特殊在哪里？构造函数中不须要定义返回类型（void 是无需返回值的意思，请注意区分二者），且构造函数的名称与所在的类名彻底一致，其他的与函数的特性相同，能够带有参数列表，能够存在函数的重载现象。

通常用来初始化一些成员变量，当要生成一个类的对象（实例）的时候就会调用类的构造函数。若是不显示声明类的构造方法，会自动生成一个默认的不带参数的空的构造函数。

public class Demo{
    private int num=0;

    //无参构造函数
    Demo()
    {
        System.out.println("constractor_run");
    }

    //有参构造函数
    Demo(int num)
    {
        System.out.println("constractor_args_run");
    }

    //普通成员函数
    public void demoFunction()
    {
        System.out.println("function_run");
    }
}

在这里要说明一点，若是在类中咱们不声明构造函数，JVM 会帮咱们默认生成一个空参数的构造函数；若是在类中咱们声明了带参数列表的构造函数，JVM 就不会帮咱们默认生成一个空参数的构造函数，咱们想要使用空参数的构造函数就必须本身去显式的声明一个空参的构造函数。

构造函数的做用

　　经过开头的介绍，构造函数的轮廓已经渐渐清晰，那么为何会有构造函数呢？构造函数有什么做用？构造函数是面向对象编程思想所需求的，它的主要做用有如下两个：

  • 建立对象。任何一个对象建立时，都须要初始化才能使用，因此任何类想要建立实例对象就必须具备构造函数。
  • 对象初始化。构造函数能够对对象进行初始化，而且是给与之格式（参数列表）相符合的对象初始化，是具备必定针对性的初始化函数。

8. 向上造型和向下造型

父类引用能指向子类对象，子类引用不能指向父类对象；

向上造型

父类引用指向子类对象，例如：

Father f1 = new Son();

向下造型

把指向子类对象的父类引用赋给子类引用，须要强制转换，例如：

Father f1 = new Son();
Son s1 = (Son)f1;

但有运行出错的状况：

Father f2 = new Father();
Son s2 = (Son)f2; //编译无错但运行会出现错误

在不肯定父类引用是否指向子类对象时，能够用 instanceof 来判断：

if(f3 instanceof Son){
     Son s3 = (Son)f3;
}

3、关键字

1. final与static的区别

final

  • 1. 数据
    • 声明数据为常量，能够是编译时常量，也能够是在运行时被初始化后不能被改变的常量。
    • 对于基本类型，final 使数值不变；
    • 对于引用类型，final 使引用不变，也就不能引用其它对象，可是被引用的对象自己是能够修改的。
final int x = 1;
// x = 2;  // cannot assign value to final variable 'x'
final A y = new A();
y.a = 1;
  • 2. 方法
    • 声明方法不能被子类覆盖。
      • private 方法隐式地被指定为 final，若是在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是覆盖基类方法，而是在子类中定义了一个新的方法。
  • 3. 类
    • 声明类不容许被继承。

static

  • 1. 静态变量

    静态变量在内存中只存在一份，只在类初始化时赋值一次。

    • 静态变量：类全部的实例都共享静态变量，能够直接经过类名来访问它；
    • 实例变量：每建立一个实例就会产生一个实例变量，它与该实例同生共死。
public class A {
    private int x;        // 实例变量
    public static int y;  // 静态变量
}

　　注意：不能再成员函数内部定义static变量。

  • 2. 静态方法

    静态方法在类加载的时候就存在了，它不依赖于任何实例，因此静态方法必须有实现，也就是说它不能是抽象方法（abstract）。

  • 3. 静态语句块

    静态语句块在类初始化时运行一次。

  • 4. 静态内部类

    内部类的一种，静态内部类不依赖外部类，且不能访问外部类的非静态的变量和方法。

  • 5. 静态导包

import static com.xxx.ClassName.*

　　在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大下降。

  • 6. 变量赋值顺序

    静态变量的赋值和静态语句块的运行优先于实例变量的赋值和普通语句块的运行，静态变量的赋值和静态语句块的运行哪一个先执行取决于它们在代码中的顺序。

public static String staticField = "静态变量";
static {
    System.out.println("静态语句块");
}
public String field = "实例变量";
{
    System.out.println("普通语句块");
}

最后才运行构造函数

public InitialOrderTest() {
    System.out.println("构造函数");
}

存在继承的状况下，初始化顺序为：

  • 父类（静态变量、静态语句块）
  • 子类（静态变量、静态语句块）
  • 父类（实例变量、普通语句块）
  • 父类（构造函数）
  • 子类（实例变量、普通语句块）
  • 子类（构造函数）

2. break、continue、return

break

跳出当前循环；可是若是是嵌套循环，则只能跳出当前的这一层循环，只有逐层 break 才能跳出全部循环。

for (int i = 0; i < 10; i++) {
    // 在执行i==6时强制终止循环，i==6不会被执行
    if (i == 6)
        break;
    System.out.println(i);  
}  

输出结果为0 1 2 3 4 5 ；6之后的都不会输出

continue

终止当前循环，可是不跳出循环（在循环中 continue 后面的语句是不会执行了），继续往下根据循环条件执行循环。

for (int i = 0; i < 10; i++) {  
    // i==6不会被执行，而是被中断了    
    if (i == 6)
        continue;
    System.out.println(i);  
}

输出结果为0 1 2 3 4 5 7 8 9； 只有6没有输出

return

  • return 从当前的方法中退出，返回到该调用的方法的语句处，继续执行。
  • return 返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致。
  • return 后面也能够不带参数，不带参数就是返回空，其实主要目的就是用于想中断函数执行，返回调用函数处。

特别注意：返回值为 void 的方法，从某个判断中跳出，必须用 return。

3. final、finally和finalize区别

final

final 用于声明属性、方法和类，分别表示属性不可变、方法不可覆盖和类不可被继承。

  • final 属性：被final修饰的变量不可变（引用不可变）
  • final 方法：不容许任何子类重写这个方法，但子类仍然能够使用这个方法
  • final 参数：用来表示这个参数在这个函数内部不容许被修改
  • final 类：此类不能被继承，全部方法都不能被重写

finally

　　在异常处理的时候，提供 finally 块来执行任何的清除操做。若是抛出一个异常，那么相匹配的 catch 字句就会执行，而后控制就会进入 finally 块，前提是有 finally 块。例如：数据库链接关闭操做上

　　finally 做为异常处理的一部分，它只能用在 try/catch 语句中，而且附带一个语句块，表示这段语句最终必定会被执行（无论有没有抛出异常），常常被用在须要释放资源的状况下。（×）（这句话其实存在必定的问题，尚未深刻了解，欢迎你们在 issue 中提出本身的看法）

  • 异常状况说明：
    • 在执行 try 语句块以前已经返回或抛出异常，因此 try 对应的 finally 语句并无执行。
    • 咱们在 try 语句块中执行了 System.exit (0) 语句，终止了 Java 虚拟机的运行。那有人说了，在通常的 Java 应用中基本上是不会调用这个 System.exit(0) 方法的
    • 当一个线程在执行 try 语句块或者 catch 语句块时被打断（interrupted）或者被终止（killed），与其相对应的 finally 语句块可能不会执行
    • 还有更极端的状况，就是在线程运行 try 语句块或者 catch 语句块时，忽然死机或者断电，finally 语句块确定不会执行了。可能有人认为死机、断电这些理由有些强词夺理，没有关系，咱们只是为了说明这个问题。

finalize

　　finalize() 是 Object 中的方法，当垃圾回收器将要回收对象所占内存以前被调用，即当一个对象被虚拟机宣告死亡时会先调用它 finalize() 方法，让此对象处理它生前的最后事情（这个对象能够趁这个时机挣脱死亡的命运）。要明白这个问题，先看一下虚拟机是如何判断一个对象该死的。

　　能够覆盖此方法来实现对其余资源的回收，例如关闭文件。

断定死亡

　　Java 采用可达性分析算法来断定一个对象是否死期已到。Java中以一系列 "GC Roots" 对象做为起点，若是一个对象的引用链能够最终追溯到 "GC Roots" 对象，那就天下太平。

　　不然若是只是A对象引用B，B对象又引用A，A B引用链均未能达到 "GC Roots" 的话，那它俩将会被虚拟机宣判符合死亡条件，具备被垃圾回收器回收的资格。

最后的救赎

上面提到了判断死亡的依据，但被判断死亡后，还有生还的机会。

如何自我救赎：

  1. 对象覆写了 finalize() 方法（这样在被判死后才会调用此方法，才有机会作最后的救赎）；
  2. 在 finalize() 方法中从新引用到 "GC Roots" 链上（如把当前对象的引用 this 赋值给某对象的类变量/成员变量，从新创建可达的引用）.

须要注意：

　　finalize() 只会在对象内存回收前被调用一次 (The finalize method is never invoked more than once by a Java virtual machine for any given object. )

　　finalize() 的调用具备不肯定性，只保证方法会调用，但不保证方法里的任务会被执行完（好比一个对象手脚不够利索，磨磨叽叽，还在自救的过程当中，被杀死回收了）。

finalize()的做用

　　虽然以上以对象救赎举例，但 finalize() 的做用每每被认为是用来作最后的资源回收。
　　基于在自我救赎中的表现来看，此方法有很大的不肯定性（不保证方法中的任务执行完）并且运行代价较高。因此用来回收资源也不会有什么好的表现。

　　综上：finalize() 方法并无什么鸟用。

　　至于为何会存在一个鸡肋的方法：书中说 “它不是 C/C++ 中的析构函数，而是 Java 刚诞生时为了使 C/C++ 程序员更容易接受它所作出的一个妥协”。

参考资料：

4. assert有什么做用

　　断言（assert）做为一种软件调试的方法，提供了一种在代码中进行正确性检查的机制，目前不少开发语言都支持这种机制。

　　在实现中，assertion 就是在程序中的一条语句，它对一个 boolean 表达式进行检查，一个正确程序必须保证这个 boolean 表达式的值为 true；若是该值为 false，说明程序已经处于不正确的状态下，系统将给出警告而且退出。通常来讲，assertion 用于保证程序最基本、关键的正确性。assertion 检查一般在开发和测试时开启。为了提升性能，在软件发布后，assertion 检查一般是关闭的。下面简单介绍一下 Java 中 assertion 的实现。

　　在语法上，为了支持 assertion，Java 增长了一个关键字 assert。它包括两种表达式，分别以下：

　　assert

　　若是 为 true，则程序继续执行。

　　若是为 false，则程序抛出 AssertionError，并终止执行。

　　assert : <错误信息表达式>

　　若是 为 true，则程序继续执行。

　　若是为 false，则程序抛出 java.lang.AssertionError，并输入 <错误信息表达式> 。 

public static void main(String[] args) {
    System.out.println("123");

    int a = 0;
    int b = 1;
    assert a == b; //需显示开启，默认为不开启状态 
    assert a == b : "执行失败！";

    System.out.println("1234");
}

assert 的应用范围不少，主要包括：

  • 检查控制流
  • 检查输入参数是否有效
  • 检查函数结果是否有效
  • 检查程序不变

5. volatile

每次都读错，美式发音：volatile /'vɑlətl/ adj. [化学] 挥发性的；不稳定的；爆炸性的；反复无常的

　　volatile 是一个类型修饰符（type specifier），它是被设计用来修饰被不一样线程访问和修改的变量。在使用 volatile 修饰成员变量后，全部线程在任什么时候间所看到变量的值都是相同的。此外，使用 volatile 会组织编译器对代码的优化，所以会下降程序的执行效率。因此，除非无可奈何，不然，能不使用 volatile 就尽可能不要使用 volatile。

  • 每次访问变量时，老是获取主内存的最新值
  • 每次修改变量后，马上写回到主内存中

参考资料：

6. instanceof

instanceof 是 Java 的一个二元操做符，相似于 ==，>，< 等操做符。

instanceof 是 Java 的保留关键字。它的做用是测试它左边的对象是不是它右边的类的实例，返回 boolean 的数据类型。

public class Main {
    public static void main(String[] args) {
        Object testObject = new ArrayList();
        displayObjectClass(testObject);
    }
    public static void displayObjectClass(Object o) {
        if (o instanceof Vector)
            System.out.println("对象是 java.util.Vector 类的实例");
        else if (o instanceof ArrayList)
            System.out.println("对象是 java.util.ArrayList 类的实例");
        else
            System.out.println("对象是 " + o.getClass() + " 类的实例");
    }
}

7. strictfp

strictfp，即 strict float point (精确浮点)。

strictfp 关键字可应用于类、接口或方法。使用 strictfp 关键字声明一个方法时，该方法中全部的 float 和 double 表达式都严格遵照 FP-strict 的限制,符合 IEEE-754 规范。当对一个类或接口使用 strictfp 关键字时，该类中的全部代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着全部表达式的结果都必须是 IEEE 754 算法对操做数预期的结果，以单精度和双精度格式表示。

若是你想让你的浮点运算更加精确，并且不会由于不一样的硬件平台所执行的结果不一致的话，能够用关键字strictfp.

8. transient

transient 英 /'trænzɪənt/ adj. 短暂的；路过的 n. 瞬变现象；过往旅客；候鸟

咱们都知道一个对象只要实现了 Serilizable 接口，这个对象就能够被序列化，Java 的这种序列化模式为开发者提供了不少便利，咱们能够没必要关系具体序列化的过程，只要这个类实现了 Serilizable 接口，这个类的全部属性和方法都会自动序列化。

然而在实际开发过程当中，咱们经常会遇到这样的问题，这个类的有些属性须要序列化，而其余属性不须要被序列化，打个比方，若是一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不但愿在网络操做（主要涉及到序列化操做，本地序列化缓存也适用）中被传输，这些信息对应的变量就能够加上 transient 关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

总之，Java 的 transient 关键字为咱们提供了便利，你只须要实现 Serilizable 接口，将不须要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

参考资料：

9. native

native（即 JNI，Java Native Interface），凡是一种语言，都但愿是纯。好比解决某一个方案都喜欢就单单这个语言来写便可。Java 平台有个用户和本地 C 代码进行互操做的 API，称为 Java Native Interface (Java本地接口)。


参考资料：

4、基本数据类型与运算

1. Java的基本数据类型和引用类型，自动装箱和拆箱

  • 4 类 8 种基本数据类型。4 整数型，2 浮点型，1 布尔型，1 字符型
类型 存储 取值范围 默认值 包装类
整数型
byte 8 最大存储数据量是 255，最小 -27，最大 27-1，
[-128~127]		 (byte) 0 Byte
short 16 最大数据存储量是 65536，[-215,215-1]，
[-32768,32767]，±3万		 (short) 0 Short
int 32 最大数据存储容量是 231-1，
[-231,231-1]，±21亿，[ -2147483648, 2147483647]		 0 Integer
long 64 最大数据存储容量是 264-1，
[-263,263-1]， ±922亿亿（±（922+16个零））		 0L Long
浮点型
float 32 数据范围在 3.4e-45~1.4e38，直接赋值时必须在数字后加上 f 或 F 0.0f Float
double 64 数据范围在 4.9e-324~1.8e308，赋值时能够加 d 或 D 也能够不加 0.0d Double
布尔型
boolean 1 true / flase false Boolean
字符型
char 16 存储 Unicode 码，用单引号赋值 '\u0000' (null) Character
  • 引用数据类型
    • 类（class）、接口（interface）、数组
  • 自动装箱和拆箱
    • 基本数据类型和它对应的封装类型之间能够相互转换。自动拆装箱是 jdk5.0 提供的新特特性，它能够自动实现类型的转换
    • 装箱：从基本数据类型到封装类型叫作装箱
    • 拆箱：从封装类型到基本数据类型叫拆箱
// jdk 1.5
public class TestDemo {
    public static void main(String[] args) {
        Integer m =10;
        int i = m;
    }
}

　　上面的代码在 jdk1.4 之后的版本都不会报错，它实现了自动拆装箱的功能，若是是 jdk1.4，就得这样写了

// jdk 1.4
public class TestDemo {
    public static void main(String[] args) {
        Integer b = new Integer(210);
        int c = b.intValue();
    }
}

2. ValueOf缓存池

　　new Integer(123) 与 Integer.valueOf(123) 的区别在于，new Integer(123) 每次都会新建一个对象，而 Integer.valueOf(123) 可能会使用缓存对象，所以屡次使用 Integer.valueOf(123) 会取得同一个对象的引用。

Integer x = new Integer(123);
Integer y = new Integer(123);
System.out.println(x == y);    // false
Integer z = Integer.valueOf(123);
Integer k = Integer.valueOf(123);
System.out.println(z == k);   // true

　　编译器会在自动装箱过程调用 valueOf() 方法，所以多个 Integer 实例使用自动装箱来建立而且值相同，那么就会引用相同的对象。

Integer m = 123;
Integer n = 123;
System.out.println(m == n); // true

valueOf() 方法的实现比较简单，就是先判断值是否在缓存池中，若是在的话就直接使用缓存池的内容。

// valueOf 源码实现
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

在 Java 8 中，Integer 缓存池的大小默认为 -128~127。

static final int low = -128;
static final int high;
static final Integer cache[];

static {
    // high value may be configured by property
    int h = 127;
    String integerCacheHighPropValue =
        sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    if (integerCacheHighPropValue != null) {
        try {
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            // Maximum array size is Integer.MAX_VALUE
            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
        } catch( NumberFormatException nfe) {
            // If the property cannot be parsed into an int, ignore it.
        }
    }
    high = h;

    cache = new Integer[(high - low) + 1];
    int j = low;
    for(int k = 0; k < cache.length; k++)
        cache[k] = new Integer(j++);

    // range [-128, 127] must be interned (JLS7 5.1.7)
    assert IntegerCache.high >= 127;
}

Java 还将一些其它基本类型的值放在缓冲池中，包含如下这些：

  • boolean values true and false
  • all byte values
  • short values between -128 and 127
  • int values between -128 and 127
  • char in the range \u0000 to \u007F

所以在使用这些基本类型对应的包装类型时，就能够直接使用缓冲池中的对象。

参考资料：

3. i++和++i有什么区别

i++

i++ 是在程序执行完毕后进行自增，而 ++i 是在程序开始执行前进行自增。

i++ 的操做分三步

  1. 栈中取出 i
  2. i 自增 1
  3. 将 i 存到栈

三个阶段：内存到寄存器，寄存器自增，写回内存（这三个阶段中间均可以被中断分离开）

因此 i++ 不是原子操做，上面的三个步骤中任何一个步骤同时操做，均可能致使 i 的值不正确自增

++i

在多核的机器上，CPU 在读取内存 i 时也会可能发生同时读取到同一值，这就致使两次自增，实际只增长了一次。

i++ 和 ++i 都不是原子操做

原子性：指的是一个操做是不可中断的。即便是在多个线程一块儿执行的时候，一个操做一旦开始，就不会被其余线程打断。

JMM 三大特性：原子性，可见性，有序性。详情请阅读 Github 仓库：Java 并发编程 一文。

4. 位运算符

Java 定义了位运算符，应用于整数类型 (int)，长整型 (long)，短整型 (short)，字符型 (char)，和字节型 (byte)等类型。

下表列出了位运算符的基本运算，假设整数变量A的值为60和变量B的值为13

A（60）：0011 1100

B（13）：0000 1101

操做符 名称 描述 例子
＆ 与 若是相对应位都是 1，则结果为 1，不然为 0 （A＆B）获得 12，即 0000 1100
| 或 若是相对应位都是 0，则结果为 0，不然为 1 （A|B）获得 61，即 0011 1101
^ 异或 若是相对应位值相同，则结果为 0，不然为 1 （A^B）获得49，即 0011 0001
〜 非 按位取反运算符翻转操做数的每一位，即 0 变成 1，1 变成 0 （〜A）获得-61，即1100 0011
<< 左移 （左移一位乘2）按位左移运算符。左操做数按位左移右操做数指定的位数。左移 n 位表示原来的值乘 2n A << 2获得240，即 1111 0000
>> （右移一位除2）有符号右移，按位右移运算符。左操做数按位右移右操做数指定的位数 A >> 2获得15即 1111
>>> 无符号右移 无符号右移，按位右移补零操做符。左操做数的值按右操做数指定的位数右移，移动获得的空位以零填充 A>>>2获得15即0000 1111

5. 原码、补码、反码是什么

机器数

　　一个数在计算机中的二进制表示形式，叫作这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号，正数为 0，负数为 1。

　　好比，十进制中的数 +3 ，计算机字长为 8 位，转换成二进制就是 00000011。若是是 -3 ，就是 10000011 。那么，这里的 00000011 和 10000011 就是机器数。

真值

　　由于第一位是符号位，因此机器数的形式值就不等于真正的数值。例如上面的有符号数 10000011，其最高位 1 表明负，其真正数值是 -3 而不是形式值 131（10000011 转换成十进制等于 131）。因此，为区别起见，将带符号位的机器数对应的真正数值称为机器数的真值。

例：0000 0001 的真值 = +000 0001 = +1，1000 0001 的真值 = –000 0001 = –1

原码

　　原码就是符号位加上真值的绝对值，即用第一位表示符号，其他位表示值。好比若是是 8 位二进制:

　　[+1]原 = 0000 0001

　　[-1]原 = 1000 0001

　　第一位是符号位。由于第一位是符号位，因此 8 位二进制数的取值范围就是：[1111 1111 , 0111 1111]，即：[-127 , 127]

　　原码是人脑最容易理解和计算的表示方式

反码

反码的表示方法是：

  • 正数的反码是其自己；
  • 负数的反码是在其原码的基础上，符号位不变，其他各个位取反。

[+1] = [00000001]原 = [00000001]反

[-1] = [10000001]原= [11111110]反

可见若是一个反码表示的是负数, 人脑没法直观的看出来它的数值. 一般要将其转换成原码再计算。

补码

补码的表示方法是：

  • 正数的补码就是其自己；
  • 负数的补码是在其原码的基础上，符号位不变，其他各位取反, 最后+1。(反码的基础上 +1)

[+1] = [0000 0001]原 = [0000 0001]反 = [0000 0001]补

[-1] = [1000 0001]原 = [1111 1110]反 = [1111 1111]补

对于负数，补码表示方式也是人脑没法直观看出其数值的。 一般也须要转换成原码在计算其数值。

参考资料：

6. 不用额外变量交换两个整数的值

若是给定整数 a 和 b，用如下三行代码便可交换 a 和b 的值

a = a ^ b;
b = a ^ b;
a = a ^ b;
  • 假设 a 异或 b 的结果记为 c，c 就是 a 整数位信息和 b 整数位信息的全部不一样信息。
    • 好比：a = 4 = 100，b = 3 = 011，a^b = c = 111
  • a 异或 c 的结果就是 b，好比：a = 4 = 100，c = 111，a^c = 011 = 3 = b
  • b 异或c 的结果就是 a，好比：b = 3 = 011，c = 111，b^c = 100 = 4 = a

说明：位运算的题目基本上都带有靠经验积累才会作的特征，也就是准备阶段须要作足够多的题，面试时才会有良好的感受。

7. 不使用运算符进行a+b操做

  • a^b; 获得不含进位之和
  • (a & b)<<1; 进位
  • 只要进位不为零，则迭代；不然返回
#include <stdio.h>

int add(int a, int b)
{
    int c = a & b;
    int r = a ^ b;
    if(c == 0){
        return r;
    }
    else{
        return add(r, c << 1);
    }
}

int main(int argn, char *argv[])
{
    printf("sum = %d\n", add(-10000, 56789));
    return 0;
}

8. &和&& 、|和||的区别

（1）&& 和 & 都是表示与，区别是 && 只要第一个条件不知足，后面条件就再也不判断。而 & 要对全部的条件都进行判断。

// 例如：
public static void main(String[] args) {  
    if((23!=23) && (100/0==0)){  
        System.out.println("运算没有问题。");  
    }else{  
        System.out.println("没有报错");  
    }  
}  
// 输出的是“没有报错”。而将 && 改成 & 就会以下错误：
// Exception in thread "main" java.lang.ArithmeticException: / by zero
  • 缘由：
    • &&时判断第一个条件为 false，后面的 100/0==0 这个条件就没有进行判断。
    • & 时要对全部的条件进行判断，因此会对后面的条件进行判断，因此会报错。
    （2）|| 和 | 都是表示 “或”，区别是 || 只要知足第一个条件，后面的条件就再也不判断，而 | 要对全部的条件进行判断。 看下面的程序：
public static void main(String[] args) {  
    if((23==23)||(100/0==0)){  
        System.out.println("运算没有问题。");  
    }else{  
        System.out.println("没有报错");  
    }  
}
// 此时输出“运算没有问题”。若将||改成|则会报错。
  • 缘由
    • || 判断第一个条件为 true，后面的条件就没有进行判断就执行了括号中的代码
    • 而 | 要对全部的条件进行判断，因此会报错

5、字符串与数组

1. String,StringBuffer,StringBuilder，以及对String不变性的理解

  • String、StringBuffer、StringBuilder
    • 都是 final 类，都不容许被继承
    • String 长度是不可变的，StringBuffer、StringBuilder 长度是可变的
    • StringBuffer 是线程安全的，StringBuilder 不是线程安全的，但它们两个中的全部方法都是相同的，StringBuffer 在 StringBuilder 的方法之上添加了 synchronized 修饰，保证线程安全
    • StringBuilder 比 StringBuffer 拥有更好的性能
    • 若是一个 String 类型的字符串，在编译时就能够肯定是一个字符串常量，则编译完成以后，字符串会自动拼接成一个常量。此时 String 的速度比 StringBuffer 和 StringBuilder 的性能好的多
  • String 不变性的理解
    • String 类是被 final 进行修饰的，不能被继承
    • 在用 + 号连接字符串的时候会建立新的字符串
    • String s = new String("Hello world"); 可能建立两个对象也可能建立一个对象。若是静态区中有 “Hello world” 字符串常量对象的话，则仅仅在堆中建立一个对象。若是静态区中没有 “Hello world” 对象，则堆上和静态区中都须要建立对象。
    • 在 Java 中, 经过使用 "+" 符号来串联字符串的时候,，实际上底层会转成经过 StringBuilder 实例的 append() 方法来实现。

2. String有重写Object的hashcode和toString吗？若是重写equals不重写hashcode会出现什么问题？

  • String 有重写 Object 的 hashcode 和 toString吗？
    • String 重写了 Object 类的 hashcode 和 toString 方法。
  • 当 equals 方法被重写时，一般有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相对等的两个对象必须有相同的 hashCode
    • object1.euqal(object2) 时为 true， object1.hashCode() == object2.hashCode() 为 true
    • object1.hashCode() == object2.hashCode() 为 false 时，object1.euqal(object2) 一定为 false
    • object1.hashCode() == object2.hashCode() 为 true时，但 object1.euqal(object2) 不必定定为 true
  • 重写 equals 不重写 hashcode 会出现什么问题
    • 在存储散列集合时(如 Set 类)，若是原对象.equals(新对象)，但没有对 hashCode 重写，即两个对象拥有不一样的 hashCode，则在集合中将会存储两个值相同的对象，从而致使混淆。所以在重写 equals 方法时，必须重写 hashCode 方法。

3. 若是你定义一个类，包括学号，姓名，分数，如何把这个对象做为key？要重写equals和hashcode吗

  • 须要重写 equals 方法和 hashcode，必须保证对象的属性改变时，其 hashcode 不能改变。

4. 字面量

在编程语言中，字面量（literal）指的是在源代码中直接表示的一个固定的值。

八进制是用在整数字面量以前添加 “0” 来表示的。

十六进制用在整数字面量以前添加 “0x” 或者 “0X” 来表示的

Java 7 中新增了二进制：用在整数字面量以前添加 “0b” 或者 “0B” 来表示的。

在数值字面量中使用下划线

在 Java7 中，数值字面量，无论是整数仍是浮点数都容许在数字之间插入任意多个下划线。而且不会对数值产生影响，目的是方便阅读，规则只能在数字之间使用。

public class BinaryIntegralLiteral {
    public static void main(String[] args) {
        System.out.println(0b010101);
        System.out.println(0B010101);
        System.out.println(0x15A);
        System.out.println(0X15A);
        System.out.println(077);
        System.out.println(5_000);
        /**
         * 输出结果
         * 21 
         * 21 
         * 346 
         * 346 
         * 63
         * 5000
         */
    }
}

6、异常处理

1. 常见异常分为那两种(Exception，Error)，常见异常的基类以及常见的异常

  • Throwable 是 Java 语言中全部错误和异常的超类（万物便可抛）。它有两个子类：Error、Exception。
  • 异常种类
    • Error：Error 为错误，是程序没法处理的，如 OutOfMemoryError、ThreadDeath 等，出现这种状况你惟一能作的就是听之任之，交由 JVM 来处理，不过 JVM 在大多数状况下会选择终止线程。
    • Exception：Exception 是程序能够处理的异常。它又分为两种 CheckedException（受捡异常），一种是 UncheckedException（不受检异常）。
      • 受检异常（CheckException）：发生在编译阶段，必需要使用 try…catch（或者throws）不然编译不经过。
      • 非受检异常 （UncheckedException）：是程序运行时错误，例如除 0 会引起 Arithmetic Exception，此时程序奔溃而且没法恢复。 （发生在运行期，具备不肯定性，主要是因为程序的逻辑问题所引发的，难以排查，咱们通常都须要纵观全局才可以发现这类的异常错误，因此在程序设计中咱们须要认真考虑，好好写代码，尽可能处理异常，即便产生了异常，也能尽可能保证程序朝着有利方向发展。 ）
  • 常见异常的基类（Exception）
    • IOException
    • RuntimeException
  • 常见的异常

7、Object 通用方法

如下为 Object 中的通用方法

public final native Class<?> getClass()

public native int hashCode()

public boolean equals(Object obj)

protected native Object clone() throws CloneNotSupportedException

public String toString()

public final native void notify()

public final native void notifyAll()

public final native void wait(long timeout) throws InterruptedException

public final void wait(long timeout, int nanos) throws InterruptedException

public final void wait() throws InterruptedException

protected void finalize() throws Throwable {} // JVM内存回收之finalize()方法

equals()

1. equals() 与 == 的区别

  • 对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
  • 对于引用类型，== 判断两个实例是否引用同一个对象，而 equals() 判断引用的对象是否等价。
Integer x = new Integer(1);
Integer y = new Integer(1);
System.out.println(x.equals(y)); // true
System.out.println(x == y);      // false

2. 等价关系

（一）自反性

x.equals(x); // true

（二）对称性

x.equals(y) == y.equals(x); // true

（三）传递性

if (x.equals(y) && y.equals(z))
    x.equals(z); // true;

（四）一致性

屡次调用 equals() 方法结果不变

x.equals(y) == x.equals(y); // true

（五）与 null 的比较

对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false

x.euqals(null); // false;

3. 实现

  • 检查是否为同一个对象的引用，若是是直接返回 true；
  • 检查是不是同一个类型，若是不是，直接返回 false；
  • 将 Object 实例进行转型；
  • 判断每一个关键域是否相等。
public class EqualExample {
    private int x;
    private int y;
    private int z;

    public EqualExample(int x, int y, int z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        EqualExample that = (EqualExample) o;

        if (x != that.x) return false;
        if (y != that.y) return false;
        return z == that.z;
    }
}

hashCode()

　　hasCode() 返回散列值，而 equals() 是用来判断两个实例是否等价。等价的两个实例散列值必定要相同，可是散列值相同的两个实例不必定等价。

　　在覆盖 equals() 方法时应当老是覆盖 hashCode() 方法，保证等价的两个实例散列值也相等。

　　下面的代码中，新建了两个等价的实例，并将它们添加到 HashSet 中。咱们但愿将这两个实例当成同样的，只在集合中添加一个实例，可是由于 EqualExample 没有实现 hasCode() 方法，所以这两个实例的散列值是不一样的，最终致使集合添加了两个等价的实例。

EqualExample e1 = new EqualExample(1, 1, 1);
EqualExample e2 = new EqualExample(1, 1, 1);
System.out.println(e1.equals(e2)); // true
HashSet<EqualExample> set = new HashSet<>();
set.add(e1);
set.add(e2);
System.out.println(set.size());   // 2

　　理想的散列函数应当具备均匀性，即不相等的实例应当均匀分布到全部可能的散列值上。这就要求了散列函数要把全部域的值都考虑进来，能够将每一个域都当成 R 进制的某一位，而后组成一个 R 进制的整数。R 通常取 31，由于它是一个奇素数，若是是偶数的话，当出现乘法溢出，信息就会丢失，由于与 2 相乘至关于向左移一位。

　　一个数与 31 相乘能够转换成移位和减法：31\*x == (x<<5)-x，编译器会自动进行这个优化。

@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + x;
    result = 31 * result + y;
    result = 31 * result + z;
    return result;
}

toString()

默认返回 ToStringExample@4554617c 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。

public class ToStringExample {
    private int number;

    public ToStringExample(int number) {
        this.number = number;
    }
}
ToStringExample example = new ToStringExample(123);
System.out.println(example.toString());
ToStringExample@4554617c

clone()

1. cloneable

clone() 是 Object 的 protect 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。

public class CloneExample {
    private int a;
    private int b;
}
CloneExample e1 = new CloneExample();
// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'

重写 clone() 获得如下实现：

public class CloneExample {
    private int a;
    private int b;

    @Override
    protected CloneExample clone() throws CloneNotSupportedException {
        return (CloneExample)super.clone();
    }
}
CloneExample e1 = new CloneExample();
try {
    CloneExample e2 = e1.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}
java.lang.CloneNotSupportedException: CloneTest

以上抛出了 CloneNotSupportedException，这是由于 CloneTest 没有实现 Cloneable 接口。

public class CloneExample implements Cloneable {
    private int a;
    private int b;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

应该注意的是，clone() 方法并非 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，若是一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。

参考资料：

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程