目录
3.String，StringBuilder，StringBuffer的区别
5.抽象类（abstract class）和接口（interface）的区别
一，Java基础
1.谈谈你对java多态的理解
同一个事件根据发送对象的不同而采用不同的行为方式，在执行期间判断所引用的对象的实际类型，根据其实际的类型调用其相应的方法。
作用：消除类型之间的耦合关系。
必要条件：继承、重写、父类引用指向子类对象。
2.== 和 equals 和 hashCode的区别
==：若是基本数据类型，比较的是值，若是引用类型，比较的是他们在内存中的地址。对象是存放在堆中，对象的引用存放在栈中，==就是对栈中的值进行比较的，返回true代表内存地址相等，基本数据类型是放在栈里的。
equals：是Object类中的方法，判断对象的内存地址引用是不是同一个地址。若没重写此方法，返回的结果和==相同，若重写了该方法，就根据代码逻辑而定，一般重写都是根据内容是否相等来判断的。
hashCode：是一个本地方法，计算对象实例的哈希码（散列码），实际上返回的是一个int整数，这个哈希码的作用是确定对象在哈希表中的索引位置。因为散列表存储的是键值对，特点就是能根据“键”快速的检索出“值”。在对象进行散列时作为key存入。在批量的对象比较中，hashCode要比equals快，在添加新元素时，先调用这个元素的hashCode方法，能立刻定位到它应该存储的物理位置，若该位置没有元素，可直接存储，若有元素，就调用它的equals方法与新元素进行比较，若相同则不存，不相同，就放到该位置的链表末端。
注意点：equals相等，则hashCode一定相等；hashCode相等，equals不一定相等；hashCode不等，equals一定不等。所以重写equals时，需要重写hashCode，确保通过equals判断为true的俩对象具备相等的hashCode返回值。
注意点：Integer是int的包装类，对于-128~127的Integer值，是原生数据类型int，会在内存里重用，==比较的是数值，但超出这个范围比较的就是地址。Integer默认值是null不是0，当new 一个Integer时，实际是生成一个指向此对象的引用，而int是直接存储数据的值。
3.String，StringBuilder，StringBuffer的区别
执行速度：StringBuilder > StringBuffer > String
String：字符串常亮，不可变，每次改变值都会产生新的对象，效率低且浪费内存空间，但线程安全。
StringBuilder：字符串变量，修改字符串不会产生新的对象，效率高但多线程下不安全。
StringBuffer：字符串变量，加了同步锁，多线程下是安全的，但效率比StringBuilder低一些。
小扩展：final可以修饰变量、方法、类，被final修饰的类不能被继承，其所有成员方法都隐式指定为final方法，private修饰的方法就被隐式指定为final方法。
4.内部类
就是在类的内部再定义一个类。作用：
（1）实现多重继承：Java继承只能单继承，使用内部类可以实现多重继承；
（2）很好的实现隐藏，外部类不可以是private或protected，但内部类可以；
（3）拥有外部类所有元素的访问权限。
（5）通过匿名内部类优化接口的实现，如点击事件。
4.1.静态内部类和非静态内部类有什么区别
静态内部类：以static修饰，属性和方法可以为静态的或者非静态的；静态内部类实例A.B b=new A.B()；静态内部类不会持有外部类的引用，只可以引用外部类的静态方法或属性，当然是可以通过外部类的实例访问其他方法和属性的。优点是加强了类的封装性，提高了代码的可读性。
成员内部类：作为外部类的一个成员存在，属性和方法不能声明为静态的；实例A.B b=new A().new B()；持有外部类的引用，可以引用外部类的方法和属性。
内部类是完全依赖于外部类存在的，但静态内部类是则可以完全独立，。
注：为什么非静态内部类不能声明静态方法或者属性？
因为静态方法或属性在类加载时会存在于内存中，使用某个类的静态属性或方法时，这个类必须加载到虚拟机中，但是非静态内部类不会随外部类一起加载，只有实例化外部类才会加载，所以非静态内部类不能声明静态方法和属性。
4.2其他：匿名内部类、局部内部类
在整个操作中只使用一次，没有名字，使用new 创建，没有具体位置。
局部内部类：在方法内或是代码块中定义类。
5.抽象类（abstract class）和接口（interface）的区别
5.1，抽象是什么：
将一类对象的共同特征总结出来，并且构造成1类事物的过程，只关注有哪些数据和行为，不关注其具体细节。作用是提供子类的通用性，创建模板，减少代码编写，代码更规范。实现抽象的2种方式：抽象类和接口。
5.2，抽象类：必须用abstract修饰，抽象方法只有声明，不会实现。
5.3，接口：用interface修饰
区别：
6.进程和线程的区别
进程：具有一定独立功能的程序，是系统进行资源分配和调度运行的基本单位。有独立的地址空间。一个进程有至少一个线程。
线程：进程的一个实体，是CPU调度的基本单位，也是进程中执行运算的最小单位。一个线程只属于一个进程，同一进程的所有线程共享该进程的所有资源，不同进程的线程间要利用消息通信方式实现同步。
7.序列化
将一个对象转换成可存储或可传输的状态，序列化后的对象可以在网络上传输，也可以存储到本地，还可以实现跨进程传输。
为什么要序列化：比如界面跳转时，intent或bundle只能识别基本数据类型和被序列化的类型。
（1）Serializable：Java提供，可以将对象转换为可传输状态，序列化后的对象可以进行IO传输然后持久的保存在相应的地方。原理是使用反射，序列化过程慢。Serializable是一个没有任何方法的接口，直接用类实现即可，具体序列化和反序列化由Java实现。缺点是会产生大量的临时变量，引起频繁GC。
（2）Parcelable：Android提供，原理是将一个对象进行分解，分解后的每一部分都是Intent支持的数据类型，则实现传递对象的功能。解决了Serializable在内存中传递对象效率低下的问题，一般用于在内存中传递对象，如activity之间传递数据，binder传递数组。但不能将数据存储到磁盘上，外界变化时，不能很好的保证数据持续性。所以若仅在内存中使用，优先使用Parcelable。
Parcelable是一个接口，需要实现两个抽象方法：
describeContents()：负责文件描述，针对特殊的需要描述信息的对象返回1，其他情况返回0即可。
writeToParcel(Parcel parcel, int i)：实现序列化的方法，返回Parcel对象，可以直接调用Parcel的write方法。
Creator<ParcelableTest> CREATOR:需要定义一个Creator的变量，通过匿名内部类实现Parcelable中的Creator的接口。注意：静态成员变量属于类，不属于对象，不会参与序列化的过程；用transient关键字编辑的成员变量也不会参与序列化过程；可以通过重写writeObject和readObject方法来重写系统默认的序列化和反序列化。
8，synchronized，volatile关键字
9，强引用，软引用，弱引用，虚引用
强引用：常规创建对象，只要对象存在就不会被回收。
Object object = new Object();
软引用：内存溢出前会进行回收，通过get()方法获取对象，被标记为回收时返回null
SoftRefrence<Object> sf = new SoftRefrence();
Object object = sf.get();
弱引用：第二次垃圾回收时就会回收
WeakReference<Object> wf = new WeakReference<Object>(obj);
虚引用：每次垃圾回收时都会回收。
PhantomRefrence<Object> pr = new PhantomRefrence(obj);
pr.get();//永远返回null
10，泛型
泛型类：
//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{
//key这个成员变量的类型为T,T的类型由外部指定
private T key;
public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
this.key = key;
}
public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
return key;
}
}泛型接口：
//定义一个泛型接口
public interface Generator<T> {
public T next();
}11，反射
获取Class对象
//path为类路径
Class<User> userClass = (Class<User>) Class.forName(path);12，排序
冒泡排序：交换排序，从数组的第一个角标逐个与后面的元素进行比较
for(int i=0;i<list.length;i++){
for(int j=i+1;j<list.length;j++){
if(list[i]>list[j]){
int temp=list[i];
list[i]=list[j];
list[j]=temp;
}
}
}快速排序：交换排序，从数组中选取一个中间数，小于它的放左边，大于的放右边，分开的数组在进行如上操作。
void quickSort(int[] arr,int start,int end){
if(end<=start)
return;
int standard = arr[start];//选取第一个数做中间值
int low = start,high = end;//低位指针和高位指针
while(low<high){
while(low<high&&standard<=arr[high])//从高位开始，选取比中间值小的元素
high--;
arr[low] = arr[high];//找到后退出循环，将小的赋值给低位元素
while(low<high&&standard>=arr[low])//从低位开始，找比中间值大的元素
low++;
arr[high]=arr[low];//找到了，将大的元素放到high的位置处
}
arr[low]=standard;//这儿low==high，标准值放在low/high处，左边都是小的，右边都是大的
quickSort(arr,start,low-1);//左边的再快速排序
quickSort(arr,low+1,end);//右边的快速排序
}
13.说一下你知道的设计模式有哪些，介绍下适配器模式
（1）单例模式：对象创建模式，一个类只产生一个实例。可以节约多次创建对象的时间，减少GC的压力。
饿汉模式：先创建好对象，但是无法对实例做延时加载。
private static final HungurySingleton mHungurySingleton = new HungurySingleton();
public static HungurySingleton getHungurySingleton() {return mHungurySingleton;}
懒汉模式之双重检查检索（double-check-locking）：
public class DclSingleton {
private static volatile DclSingleton mInstance = null;//使用volatile是防止a线程执行到1时被指令重排了，已经先赋值了，但还未完成初始化操作，这时b线程检查到实例不为空，返回的实例其实是没有初始化完成的。volatile就是保证了即使JVM会对代码进行了指令重排序，仍然能保证实例的正确性，就是在赋值前，实例肯定已经完成了初始化。
private DclSingleton() {}
public static DclSingleton getInstance() {
if (mInstance == null) {//2
synchronized (DclSingleton.class) {//虽然synchronized保证了原子性，但保证不了指令重排序的正确性
if (mInstance == null) { mInstance = new DclSingleton();}//1
}
}
return mInstance;
}
}
懒汉模式之静态内部类：运用静态变量唯一性；final和static保证线程安全；不使用锁机制优化性能；私有化静态内部类
public class StaticInnerSingleton {
private StaticInnerSingleton() {}
public static StaticInnerSingleton getInstance() {return SingletonHolder.sInstance;}
private static class SingletonHolder {private static final StaticInnerSingleton sInstance = new StaticInnerSingleton();}
}
（2）观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听被观察者对象，完美的将观察者和被观察的对象隔离开，一个被观察的对象发生变化时，所有依赖于它的对象都得到通知并自动刷新。如回调函数就是一种一对一的观察者模式，button.setOnClickListener(new OnClickListener(){onclick()}),button时被观察者，OnClickListener是观察者，当button触发点击事件时，通知观察者刷新方法。还有Recyclerview adapter.notifydataSetChange也是。
（3）建造者模式：比较复杂的创建型模式，将客户端与 包含多个组成部分的负责对象 的创建过程 分离开。
使用场景：当构造一个对象时需要很多参数，并且参数的类型和个数不固定时。如AlertDialog.Builder,OkHttp
（4）适配器模式：将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类一起工作。分为类适配器，对象适配器。
类适配器时通过继承实现的，对象适配器是适配器和适配者是关联关系。
如：如何在目标接口Target的request方法中调用毫不相关的被适配者的adapteeRequest()方法呢
类适配器：左图，此时就需要一个类，来实现Target接口，并继承Adaptee类，在request方法中调用被适配者的方法。
对象适配器：右图，此时创建一个类实现接口并关联适配者，在request方法中调用被适配者的方法。
如listview的adapter：
那些getCount，getView方法都是在接口类Adapter中定义的。listView引入Adapter适配器类，把布局和数据交给用户处理，通过适配器中的接口获取相应的数据完成自己的操作。
(5)策略模式：相同的行为下有不同的实现策略。如volley
14.Java中的异常处理
所有异常的祖先：Java.lang.Throwable类 ，Throwable的两个子类Exception（异常），Error（错误）。
Exception：程序本身可以处理的异常，子类有：
（1）RuntimeException：由Java虚拟机（JVM）抛出。
（2）NullPointerException：要访问的变量没有引用任何对象时。
（3）ArithmeticException：算术运算异常，如除以0。
（4）ArrayIndexOutOfException：下标越界异常。
Error:程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误和代码执行的操作无关，是JVM出现的问题。比如OutOfMemoryError表示JVM内存不够了，VirtualMachineError表示JVM运行错误，NoClassDefFoundError表示类定义错误，这时JVM一般会选择终止线程。
Throwable类常用的方法：getMessage()返回异常发生时的详细信息，toString()返回简要描述，printStackTrace()打印异常信息。
异常处理：try块用来捕获异常，可接多个catch块，如果没有catch块，则必须跟一个finally块。catch块用来处理try捕获的异常。finally块表示无论是否捕获或处理异常，finally块都会执行，当try或catch块里有return时，finally语句将在方法返回之前执行，当然，也存在不执行的情况：finally里发生了异常；在前面代码用System.exit()退出程序；程序所在线程死亡；CPU关闭。
623
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
