1. JDK 和 JRE 有什么区别？

• JDK：Java Development Kit 的简称，java 开发工具包，提供了 java 的开发环境和运行环境。
• JRE：Java Runtime Environment 的简称，java 运行环境，为 java 的运行提供了所需环境。
  注: JDK包含了JRE, 还包含编译器javac, 还包含了很多java程序调试和分析工具.

2.== 和 equals 的区别是什么？

• 1.==对于基本类型来说是值比较; 对于引用类型来说比较的是对象引用地址.
• 2.equals默认用于引用类型, 一般默认用来比较对象引用地址. 重写Object类equals方法, 则可以用于值比较, 例如:String类 和 Integer类, equals比较就是值是否相等.

3.Java基本数据类型以及其包装类

 java有8种基本数据类型  布尔类型 boolean Boolean

基本数据类型.png

• 1.java默认整型是int, 整型（byte、short、int、long）
• 2.浮点型数据在不声明的情况下默认double型，如果要表示一个数据时float 型的，可以在数据后面加上 "F" 。
• 3.Java是面向对象语言，其概念为一切皆为对象. 对象引用一般存放在栈中, 对象值一般存放在堆中. 但是基本类型它本质上是数值, 一般存放在栈中.
• 4.在数据做为参数传递的时候，基本数据类型是值传递，而引用数据类型是引用传递（地址传递）.

装箱就是  自动将基本数据类型转换为包装器类型；拆箱就是  自动将包装器类型转换为基本数据类型。
        Integer i1 = 127;
        Integer i2 = 127;
        Integer i3 = 200;
        Integer i4 = 200;
         
        System.out.println(i1==i2);  //true
        System.out.println(i3==i4);  //false

public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.cache[i + 128];
        else
            return new Integer(i);
    }
而装箱调用的是Integer.valueOf(int i)方法,即当int值为-128~127之间时，自动装箱时，是不创建对象的，直接从缓存中获取
所以i1和i2是同一个对象

        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方法会采用与Integer类的valueOf方法不同的实现。
注意，Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。
   Double、Float的valueOf方法的实现是类似的。

4.两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？

不一定, 对于字符串长度为2, 对比其hashCode()就知道, 很容易找出2个相同hashCode字符串

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;  // value是 char[] val, 数组

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i]; // 长度为2字符串 h=31*s[0] + s[1]
            }
            hash = h;
        }
        return h;
    }
-----------
   String str1 = "通话";  //三个
   String str2 = "重地";  //上下
   System.out.println(String.format("str1：%d | str2：%d",  str1.hashCode(),str2.hashCode()));

5. final 在 java 中有什么作用？

• final修饰的类叫最终类, 该类不能被继承.
• final修饰的方法不能被重写.
• final修饰的变量叫常量, 其常量引用不可修改, 常量也必须初始化.

final、finally、finalize 有什么区别

• final上面说明了
• finally一般作用在try-catch代码块中, 在异常处理的时候, finally中的代码一定会执行, 一般用来存放一些关闭资源的代码。

 5         try
 6         //要检查的程序语句
 7         {
 8             int a[] = new int[5];
 9             a[0] = 3;
10             a[1] = 1;
11             //a[1] = 0;//除数为0异常
12             //a[10] = 7;//数组下标越界异常
13             int result = a[0]/a[1];
14             System.out.println(result);
15         }
16         catch(ArrayIndexOutOfBoundsException ex)
17         //异常发生时的处理语句
18         {
19             System.out.println("数组越界异常");
20             ex.printStackTrace();//显示异常的堆栈跟踪信息
21         }
22         catch(ArithmeticException ex)
23         {
24             System.out.println("算术运算异常");
25             ex.printStackTrace();
26         }
27         finally
28         //这个代码块一定会被执行
29         {
30             System.out.println("finally语句不论是否有异常都会被执行。");
31         }

finally中的return 会覆盖 try 或者catch中的返回值。
finally中的return或异常会抑制（消灭）前面try或者catch块中的异常。

• finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法由垃圾回收器调用finalize(),回收垃圾.

6.方法的重载 和 方法的重写

• 方法重载: 发生在同一个类中，方法名必须相同，参数列表有一个不同即可(参数个数, 类型, 顺序), 方法返回值 和访问修饰符都可以不同.
• 方法重写: 发生在子类中, 子类重写父类的方法, 必须保持方法名、参数列表必须相同, 返回值范围小于等于父类, 抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。子类不能重写父类的private方法.

7.String知识: StringBuffer 和 StringBuilder 的区别是什么?

String对象每次改变的时候, 都会生成一个新的String对象, 然后指针指向新的String对象

1.性能:
   StringBuffer每次对对象操作时, 不会生成新的对象并改变对象引用. 相同情况下StringBuilder 
比StringBuffer 性能提升10%.
2.线程安全
  StringBuffer是线程安全的; StringBuilder 是线程不安全的;
3.数据可变和不可变
  String的值不可变; StringBuffer和StringBuilder的值是可变的

8.String的不可变性.

String是一个final类，不可被继承所以其字符序列不可变，
String对象的字符内容是存储在一个字符数组value[]中的，创建之后不能更改

String s1="abc"; 字符串常量存储在字符串常量池里，目的是共享，并且字符串常量池中是不会存储相同内容的字符串的。
         即s1,s2在栈中为一项，二者常量池指的是同一常量
String s2="abc";
String是不可变类型的，对它进行修改都需要重新造新的引用对象(开辟内存空间)
String s3=new String("abc");字符串对象存储在堆中，s3保存的地址值，是数据在堆空间中开辟以后对应的地址值

方法区：用于存放已被虚拟机加载的类信息，常量（常量池），静态变量，即时编译器编译后的代码等数据。
栈：即虚拟机栈，用于存储局部变量等。局部变量存放了编译期可知长度的各种基本数据类型; 对象引用（不等同于对象本身，是对象在堆内的首地址）方法执行完自动释放
堆：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。

• String设置不可变的好处

1.字符串常量池中是不会存储相同内容的字符串
2.可以确保线程安全

9.String str="i"与 String str=new String("i")一样吗？

不一样, 内存的分配方式不一样; 第一种是存储在字符串常量池中, 属于字符串常量;
第二种存储在堆内存中, 属于字符串变量;

10.字符串常用方法

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

11.基本类型和引用类型？他们的区别

1.创建过程的不同, 基础类型直接创建直接在栈上分配存储空间,将数值存储在栈上.
引用类型创建:
Person p1 = new Person(8, 8, 2000);
  1).首先在栈内存为对象引用p1分配空间;
  2).然后在堆内存中为Person()对象分配空间, 并为属性设置初始值0, 0, 0;
  3).调用相应构造方法, 为相应属性赋值8, 8, 2000;(注意这时候对象引用p1和对象Person之间还没有建立联系)
  4).将Person对象在堆中的地址, 赋值给栈中对象引用p1; 通过p1的地址可以找到堆中对象的具体信息.
2.参数传递不同, 基本类型是值传递, 而引用数据类型是地址传递;

12.面向对象编程三大特性: 封装 继承 多态

封装:
把描述对象的属性和行为的代码封装到一个类中, 属性用变量定义, 行为用方法定义,这一过程就叫封装.

继承
子类继承父类的特征和行为. 子类可以继承父类非私有的方法,属性. 子类也可以对父类进行拓展, 
可以重写父类的方法. 缺点提高代码的耦合性.

多态
运行时多态和编译时多态
多态前提: 1.要有继承或者实现关系  2.要有覆盖
具体参考:https://blog.csdn.net/doncoder/article/details/83243906

13.普通类和抽象类有哪些区别？

普通类不能包含抽象方法，抽象类可以包含抽象方法。
抽象类不能直接实例化，普通类可以直接实例化。

14.接口和抽象类的区别

1.实现：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口
2.接口的方法默认是 public，接口中一般不能有方法实现，而抽象类可以有非抽象的方法。
3.一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过extends关键字扩展多个接口。
4.从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。
5.构造函数：抽象类可以有构造函数；接口不能有

15.抽象类能使用 final 修饰吗？

不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，
这样彼此就会产生矛盾，所以 final 不能修饰抽象类

16.Object类有哪些常用的方法？

equals 方法，getclass方法,hashCode 方法，toString 方法，wait 和 notify 系列的几个，