基础

Q：Integer和int的区别

int是基本数据类型，Integer是类，因为Java很多地方需要类，比如泛型里
Java有自动装箱和自动拆箱
对象类都是final的
-128到127之间，Integer.valueOf返回的是缓存，不新建对象。这个范围可以通过JVM参数设置

Q：Java和C++的区别

Java和C++都是面向对象的，都有封装继承和多态
C++有指针，需要程序员手动释放内存，Java没有指针，不需要手动释放内存
C++支持多继承，Java不支持多继承

Q：重写、重载

重载是一个类里，函数名相同，参数不同，返回值和访问权限不要求
重写是父类和子类之间，对象方法，static方法不行，是基于对象方法的。父类的方法在子类里必须可见，private不行。要求函数名相同，参数相同，返回值子类小于父类，编译异常子类小于父类，访问修饰符，子类大于等于父类。属性没有覆盖的概念，是一种隐藏。

Q：重载的方法，参数个数相同，都是引用类型，调用的时候如果每个参数都传入null，会有什么反应？编译报错？运行报错？

IDE报错，编译不通过

Q：static方法可以被子类重写吗

不可以，不能被重写，只能同名隐藏
父类引用指向子类对象，只会调用父类的静态方法，不具有多态性。可以继承

Q：初始化

局部变量（函数内的变量）不初始化会报错，成员变量有默认的初始值，数组对象是null

Q：instanceof

对象是不是这个类的对象，返回true或false
接口和父类都是true

Q：transient瞬时的

某成员变量有transient，不参与序列化

Q：代码块、静态代码块、构造代码块

代码块：在方法内部，目的是控制变量生命周期，及早释放，避免命名冲突
静态代码块，类里static{},作用是初始化类里的static变量。
在jvm加载类的时候执行，只执行一次，在主方法之前
构造代码块：初始化成员变量，构造方法共同的初始化可以提到构造代码块
每次创建对象时调用，在构造方法之前

Q：Object中的方法

1.clone
2.toString
3.hashcode
4.equals
5.getclass
6.wait
7.notify
8.notifyAll
9.finalize

Q：null

null可以强制转换成任何类，可以用来调用静态方法
（(People）null)testMethod();
对象方法会报空指针

Q：实参个数可变

public void test（int....i）{}
不确定个实参，可以是0个，可以不传，是一个数组
public void test(int[] i)
会报错，多重定义

Q：参数传递

Java是值传递，对象数组是拷贝地址

Q：实例化方法

1.new
2.clone，不调用构造方法
3.反序列化
4.反射newInstance，会调用无参的构造方法，没有回报错
5.工厂方法：String str = String.valueOf(23)

Q：String

Java虚拟机中有一个字符串池，是共享的，final的，不用担心改变
new String（）会在堆里分配，而且不会再放到常量池中，要放进常量池需要intern()方法，这个方法放进常量池，返回常量池对象

Q：字符串内存分配

String s1 = new String("abc"); // 内存分配
String s2 = "abc";
if (s1 == s2) {
// 能不能进来？ n
}
String s3 = "abc";
if (s2 == s3) {
// 能不能进来？ y
}
s2 = new String("abc");
if (s1 == s2) {
// 能不能进来？ y
}
s2 = s1;
s1 = "bcd";
// s2 = ? ab

Q：String、StringBuilder、StringBuffer

String不可变
StringBuilder可变，但是不线程安全，性能好
StringBuffer，线程安全

Q：final、finally、finalize

• final修饰变量、类、方法，代表不可变，final static 代表常量
  JVM会对方法，变量，类进行性能优化
  final变量必须在声明的时候初始化或者在构造方法初始化
  匿名类中所有变量都必须是final的
• finally
  异常中使用，代表一定会执行，用来断开连接，释放资源等，return会覆盖try,返回
  除非try中exit或者退出虚拟机了
• finalize
  finalize 方法是Object方法，在对象被回收前调用，作用是释放c++层的内存等
  如果方法是纯Java写不需要写这个方法，finalize只执行一次，可以对象复活一次
  垃圾回收的时候，判断这个对象是否覆盖了finalize方法，没有覆盖直接回收，有finalize方法，且没有执行过就放入F-Queue队列，由一个线程执行该队列中的finalize方法，执行完垃圾回收器再次判断，是否可达，不可达回收，否则复活
  如果在执行finalize方法时，出现异常，垃圾回收器不会报异常，只会该对象的finalize执行退出

Q：抽象类和接口的区别

1.接口没有构造方法，抽象类有构造方法
2.抽象类可以有普通方法，接口所有方法都是抽象的
3.抽象类中有普通成员变量，接口没有普通成员变量
4.接口方法只能是public，抽象类可以是public、protected、默认类型
5.接口中可以有静态方法，但是必须实现
接口中可以包含静态成员变量，但是必须是public static final，抽象类都可

Q：多态

父类的引用指向不同的子类对象，可以不修改代码，让引用绑定到不同的类
父类引用可以调用父类中定义的所有属性和方法，只存在子类的方法和属性就不能访问了

内部类

Q：为什么需要内部类

1.通过内部类来隐藏信息
2.实现多重继承

Q：内部类为什么可以访问外部类变量

含有一个外部类的this指针
内部类分：成员内部类、局部内部类、静态内部类、匿名内部类
内部类可以无条件访问外部所有属性和方法，包括private和静态成员
和普通的成员一样
匿名内部类在new后面，只能生成一个对象
编译的时候由系统自动起名Outter$1.class
没有类名，不能写构造方法，编译器会生成一个不带参数的构造方法
要初始化可以用构造代码块
不能有静态方法（没有类名怎么调用啊）

Q：内部类为什么持有外部对象，static内部类为什么没有

内部类会生成一个私有构造函数，传入外部对象
class Outer$Inner{
private Outer&Inner(Outer paramOuter){}
}
这是静态内部类编译后的字节码文件,编译器并没有为它添加额外的构造函数,所以它其实和我们的外部类没有任何关系,这是写在同一个.java源文件中而已.

Q：匿名内部类使用的参数为什么必须是final的

匿名内部类编译后也是单独一个class文件，仅仅有一个外部类的引用，外部传入参数，其实是参数的拷贝，内部的修改并不影响外部。这样从程序员角度看是同一个，内部改变了外部确没变，为了保持一致，所以规定用final避免形参可变。
内部类，实际会在匿名匿名内部类的构造方法中拷贝一份要使用的外部变量。这样，就牵扯两份变量的同步问题，比如内部类实例被回收、匿名内部类被实例化之前外部变量被更改等问题。解决该问题的方法，就是强制使用final，保证引用不可变

Q：内部类为什么可以访问外部private变量

Q：静态内部类和非静态的区别

静态内部类和静态成员变量类似
不能使用外部非静态成员变量或方法
普通内部类都可以方法
静态内部类可以声明普通成员变量和方法，普通内部类不能声明static成员变量和方法
静态内部类可以单独初始化，不依赖于外部
Inner i = new Outer.Inner()
//普通内部类初始化
Outer o = new Outer();
Inner i = o.new Inner();

Q：枚举

枚举也是类，都继承了Enum，每一个变量是类的对象，还是static final修饰的
构造方法是private，没有办法创建枚举值。可以有成员变量，成员方法
public enum Color{ RED,BLUE,BLACK }
编译后
final enum Color{
public static final Color RED;
public static final Color BLUE;
//静态内部类，对对象初始化
static{
new Color[1]
}
private Color(){}
}
继承Enum方法
（1）ordinal():返回枚举的顺序
Color.RED.ordinal(); 返回0
（2）compareTo():比较两个枚举的顺序
（3）values()返回全部枚举的数组
Color[] colors = Color.values();
（4）toString()返回常量的名
Color c = Color.RED;
System.out.println(c); 返回RED
（5）valueOf,返回这个名词的常量
Color.valueOf(“BLUE”); 返回Color.BLUE

Q：IO

字节流InputStream/OutputStream
字符流 Reader/Writer
字符流是字节流读取时查了指定的码表
字节流以字节（8bit）为单位，字符流以字符为单位
字节流能处理所有类型的数据，如图片、AVI，字符流只能处理字符数据
优先使用字节流

反射

Q：什么是反射

反射机制指的是程序在运行时能够获取自身的信息
在Java中，给定类的名字，那么就可以通过反射机制来获得类的所有信息。
Class.forName("com.mysql.jdbc.Driver.class").newInstance();
hibernate、struts都是用反射机制实现的。（android蓝牙）

Q：为什么要有反射，反射是怎么解决这个问题的，Android里如何用的项目里你是如何用反射的

反射可以在运行的时候动态的加载，而不是固定的，增加了灵活性
比如实例化一个对象new Person()，如果想实例化其他的对象，不想修改源码，就可以用反射class.forName(“person”).newInstance()，把加载哪个类写到配置文件中

Q：三种获取Class对象方法

1.Class的静态方法 Class.forName(“java.lang.String”);
2.使用类的.class语法 String.class;
3.对象的getClass（）方法
String str = “aa”;
Class<?> classType = str.getClass();

Q：反射创建对象，获取构造器

不带参的构造方法生成对象有两种方式
1.newInstance()直接生成即可，调用无参构造方法
Class<?> clazz = String.class;
Object obj = clazz.newInstance();
2.用Constructor的构造方法调用newInstance(参数)
Class<?> clazz = Customer.class;
//获得无参构造方法
Constructor cons = clazz.getConstructor(new Class[]{});
//通过构造方法来生成对象，构造方法调 con.newInstance()
Object obj = cons.newInstance(new OBject[]{}); //传入参数
如果要通过带参的构造方法生成对象，只有一种方式
Class<?> clazz = Customer.class;
Constructor cons2 = clazz.getConstructor(new Class[]{String.class,int.class});
Object obj2 = cons2.newInstance(new Object[]{“zhangsan”,20});
私有构造方法加一个cons2.setAccessible(true);
Teacher clazz =Teacher.class;
Constrctor cons = clazz.getConstructor(String.class);
Teacher t = (Teacher)cons.newInstance(“aa”);

Q：反射获取私有属性并修改

1.获得CLass
2.创建对象
3.getField或getDeclaredField获取Field
4.修改
Class<?> clazz = Class.forName("com.ang.Teacher");
通过有参构造获取对象，有参构造必须为public类型
Constructor c = clazz.getConstructor(String.class,int.class);//字节码阶段，构造方法的参数只能是字节码对象；
Teacher t = (Teacher) c.newInstance("王艳",100); //创建实例对象
Field field = clazz.getDeclaredField("name");//获取私有成员变量
field.setAccessible(true);//去除私有权限
field.set(t,”李代理”)； //传入对象和这个属性的新值

Q：反射如何调用私有方法

Class<?> clazz = Class.forName("com.ang.Teacher");
Constructor c = clazz.getDeclaredConstructor(); //获取私有无参构造
c.setAccessible(true); //去除私有权限
Teacher t = (Teacher) c.newInstance();//通过私有构造获取实例
Method method = clazz.getDeclaredMethod("add", int.class,int.class);//字节码阶段反射有参方法是，需传入参数类型的字节码
method.setAccessible(true); //去除私有权限
int num = (Integer) method.invoke(t, 20,8); //invoke第一个是类的实例，第二个是参数
如果是静态方法，第一个参数，传入null
method.invoke(null,20,8);
getMethods()获得该类所有公有的方法，getDeclaredMethod(parameterTypes)获得该类某个方法，getDeclaredMethods()获得该类所有方法。带有Declared修饰的方法可以反射到私有的方法，没有Declared修饰的只能用来反射公有的方法。其他的Annotation、Field、Constructor也是如此

Q：final成员变量修改

Java反射可以修改final成员变量吗？
分别两种情况
1.在定义的时候就初始化了值，private final String name = “huang”;因为编译器final类型的数据自动被优化了，所有用到的地方都替换成立常量，所以是return “huang”，而不是return this.name。所以不能修改，向阻止编译自动优化，可以改为final String name = (null!=null?”ddd”:”huang”)
2.如果是在构造函数初始化，可以修改
final Class<?> clz = p.getClass();
final Field nameField = clz.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(p, String.valueOf("huang.damon"));

equals、hashcode

Q：equals、hashcode

为了提高效率，先判断hashcode,hashcode不相同，equals肯定不相同，就不用算了
如果hashcode相同，再判断equals。这样实际调用equals的次数就大大减少了
在HashSet中的使用，set不允许有相同的对象，就先hashcode，在equals，相同就不存
如果你的类不放在hashcode为基础的容器就不需要重新hashcode
但是如果要放到hashset或者hashmap，他们equals相同，hashcode必须相等
result = 29*getName().hashCode()+getBirthday.hashCode();

Q：怎么重写hashcode方法，String的hashcode方法

用equals中涉及到的属性来计算，equal相同的hashcode要相同
首先定义个初始值，一般来说取17
然后根据属性类型解析
1.boolean: hashcode = a?1:0
2.int,byte,shot,char : hashcode = (int)b
3.long: hashcode = c^c>>>32
4.float: hashcode = d.hashCode()
5.double: hashcode = e.hashCode()
6.引用：若为null则为0，否则递归调用引用的hashcode
7.数组，String：s[0]31 ^ (n-1) + s[1] * 31 ^ (n-2) + ..... + s[n-1]
第三步
result = result31 +hashcode

Q：自定义重写equals的同时还需要重写哪个方法

一般应该重写equals（）还有hashCode()

Q：如果没有重写hashcode会发生什么

有些集合是不允许重复元素出现的，这两个方法用来保证集合中没有重复元素
如果只重写了equals方法，两个对象equals返回了true，但是没有重写hashcode方法
集合还是会插入元素，这样集合中就出现重复元素了
hashMap的put方法是先调用hashCode定位到数组的位置，如果该数组的位置上已经存在元素了，即table[i]!=null，那么遍历链表，调用equals方法判断key是否相等，如果equal不相同，说明没有找到这个key，表明这个key不存在，则会插入
如果没有重写hashcode方法，那么就无法定位到同一个数组位置，集合还是会插入元素，这样集合中就出现重复元素了，重写equals就没有意义了
如果重写了hashcode就能定位到数组相同的位置，就可以遍历这条单向链表，用equals判断这两个对象是否相同，如果相同就覆盖，不相同，就插入到链表的头节点处

Q：为什么要有拷贝？解决了什么问题，怎么解决的，什么场景使用

从一个已有的对象，创建一个相似或相同的对象，是模板设计模式，简化对象的创建
值直接拷贝，引用也直接拷贝，不行，怎么办？引用也实现拷贝，遍历值拷贝
或者先把对象序列化，再反序列化，是另一个对象了
浅拷贝：值直接拷贝，引用和对象，拷贝的地址，指向同一块内存，没有新开辟地址
深拷贝：引用和对象新开辟地址，也全部拷贝
clone方法是浅拷贝，implements Cloneable
要实现深拷贝
1.类里的每一个对象都重新clone方法，在顶层类，调用所有对象的clone方法
age是一个成员变量，age里实现clone方法，Student里有age,再调用age的clone方法
2.通过对象的序列化实现深拷贝
先把这个对象序列化，再反序列化给另一个对象
oos.writeObject(stu1);
Student stu2 = (Student)ois.readObject():
clone()默认是深拷贝还是浅拷贝，如何让clone实现深拷贝