Android 面试（Java 篇）

一 Java 的继承机制

单继承多实现

理解： 如果一个类继承了类 A 和类 B，A 和 B 都有一个 C 方法，那么当我们用这个子类对象调用 C 方法的时候，jvm 就晕了，因为他不能确定你到底是调用 A 类的 C 方法还是调用了 B 类的 C 方法。而 多实现就不会出现这样的问题，假设 A 和 B 都是接口，都有 C 方法，那么问题就能解决了，因为接口 里的方法仅仅是个方法的声明，并没有实现，子类实现了 A 和 B 接口只需要实现一个 C 方法就 OK 了， 这样调用子类的 C 方法时，Java 不至于神志不清。从另外一个方面考虑的话应该就是 Java 是严格的面 向对象思想的语言，一个孩子只能有一个亲爸爸。

二 进程跟线程，以及线程的创建

线程是CPU调度的最小单元，同时线程是一种有限的系统资源进程一般指一个执行单元，在PC和移动设备上一个程序或者一个应用一般来说，一个App程序至少有一个进程，一个进程至少有一个线程(在内存允许的情况下已开启N个进程，在A ndroidMenifest 中给四大组件指定属性android:process开启多进程模式)，

创建：继承Thread类或者直接实现 Runnable 接口来重写 run()方法实现线程

常用方法：

    1  start() 用于启动线程
      
    2   run() 调用线程对象中的run方法

    3  join() 合并插队到当前线程

    4  sellp() 睡眠释放cpu资源

    5 setPriority() 设置线程优先级

三 简述wait()和sleep()的区别

1 wait() 是object 方法，sleep()是Thread类的方法

2 wait() 使线程进入等待状态，并且释放锁，使得其他线程能使用同步控制块或者方法，sleep()是使线程进入睡眠状态，不释放锁，在睡眠时间用完后使用interrupt()方法中断，线程唤醒进入就绪状态

注意：sleep()方法只会让出CPU，并不会让出同步资源锁，wait()必须持有对象锁，而sleep()可以用在任意地方

四 如何终止一个线程

1 stop()方法(废弃):因为线程不安全，释放所有锁不可控，线程终止不应该由其他线程控制 ，而是应该由线程自己控制

2 退出标致法：需要while()循环在某些特定条件下退出，最直接的办法就是设置一个boolean 标志，并通过设置这个标志来控制循环是否退出

 public void stop(View view) {
        FiveThread runnable = new FiveThread();
        Thread fiveThread = new Thread(runnable);
        fiveThread.start();
        SystemClock.sleep(1000);
        runnable.cancel();
    }

    public class FiveThread implements Runnable {
        private volatile boolean isCancelled;

        public void run() {
            Log.e("TAG", "FiveThread:"Thread.currentThread().getName());
            while (!isCancelled) {
                Log.e("TAG", "线程没有中断");
                SystemClock.sleep(500);
            }
            Log.e("TAG", "线程FiveThread终止了");
        }

        public void cancel() {
            sCancelled = true;
        }
    }

五 Synchronized （内置锁，线程同步）

synchronized用于多线程访问，被synchronized修饰的部分不能同时被执行，是代码同步的一种方式。synchronized 加到 static 方法前面是给class 加锁，即类锁，类锁对该类的所有对象都起作用，对象锁能；synchronized 加到非静态方法上是给对象上锁，即对象锁。

使用synchronized修饰方法时，当多个线程同时访问被synchronized修饰的方法时，有且仅有一个线程可以访问该方法，当一个线程在访问时，其它线程只能等待。当一个线程访问完毕后，下一个线程才可以访问。

六 Synchronized 修饰的静态和非静态方法时为什么可以异步执行？

当方法被synchronized修饰后，如果想要执行该方法就必须获得相应的锁。每个类有且仅有一个锁(针对静态方法)，每个类的实例也是有且仅有一个锁。当多个线程在同时访问同一个方法时，执行该方法就必须获得相应的锁，同时锁只有一个，所以只能有一个线程可以获得锁，其它的线程必须等待该线程释放锁后才能获取到该锁。

七 线程同步除了Synchronized 还有别的方法么，区别在哪里

Volatile变量是一种稍弱的同步机制在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比synchronized关键字更轻量级的同步机制。

volatile不如synchronized安全，在代码中如果过度依赖volatile变量来控制状态的可见性，通常会比使用锁的代码更脆弱，也更难以理解。仅当volatile变量能简化代码的实现以及对同步策略的验证时，才应该使用它。一般来说，用同步机制会更安全些。

Synchronized 跟 Volatile 的区别：

 1  volatile 仅能使用在变量级别； synchronized 则可以使用在变量、方法、和类级别的

 2  volatile 仅能实现变量的修改可见性，并不能保证原子性； synchronized 则可以保证变量的修改可见性和原子性

 3  volatile 不会造成线程的阻塞； synchronized 可能会造成线程的阻塞。

 4  volatile 标记的变量不会被编译器优化

八 死锁产生的原因以及预防措施

所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

理解：如果此时有一个线程A，按照先锁a再获得锁b的的顺序获得锁，而在此同时又有另外一个线程B，按照先锁b再锁a的顺序获得锁。

预防：

       1 以确定的顺序获得锁
       2 超时放弃，当使用synchronized关键词提供的内置锁时，只要线程没有获得锁，那么就会永远等待下去，然而Lock接口提供了boolean tryLock(long time, TimeUnit unit) throws InterruptedException方法，该方法可以按照固定时长等待锁，因此线程可以在获取锁超时以后，主动释放之前已经获得的所有的锁。通过这种方式，也可以很有效地避免死锁。

九 Synchronized 和 Lock 的区别

1 synchronized 是一个关键字而lock是一个接口

2 synchronized 是隐式的加锁，lock是显示的加锁。

3 synchronized 可以作用在方法和代码块上而lock只能作用在代码块上。

4 synchronized 没有超时机制，而lock中的trylcok可以支持超时机制。

5 synchronized 不可中断，而lock中的lockInterruptibly可中断的获取锁。

6 synchronized 只有一个同步队列和一个等待队列，而lock有一个同步队列，可以有多        等待队列

7 synchronized 是非公平锁，而lock可以是公平锁也可以是非公平锁。

8 synchronized 用object的notify方法进行唤醒，而lock用condition进行唤醒。

十 Handler 机制（消息机制）

简述：

    Handler将Message发送到Looper的消息队列中，即MessageQueue，等待Looper循环读取Message，处理Message，然后调用Message的target，即附属Handler的dispatchMessage方法，将该消息回调到handleMessage方法中，然后完成UI更新。

问：Looper是如何工作的？

 首先Looper对象会保存一个与之关联的线程的引用，Looper是通过ThreadLocal来获取到当前线程的looper对象的（ThreadLocal类的特性）ThreadLocal是线程内部的数据存储类,当使用ThreadLocal维护变量的时候，它会为每个使用该变量的线程提供一个独立的变量副本，这个变量副本是该线程独有，不受其他线程影响。因此当Looper的prepare（）中调用ThreadLocal.get()时，就获取到了当前线程的一个独有的Looper对象，即在在当前线程关联了一个Looper对象，Looper的实现正是巧妙利用了Threadlocal的特性来实现的，避免了去使用哈希表来维护不同线程及其对应Looper的映射关系。

问：一个线程会有几个Looper,几个Handler,以及Looper会存在线程的哪里

    一个线程一个Looper，可以有多个Handler，Looper会存在线程的ThreadLocal对象里，该对象是线程的缓存区

问：Handler中loop方法为什么不会导致线程卡死

 初始化后，所有主线程做的事情都是在looper.loop()中完成的，因为主线程不做其他事，所以不会卡死

十一 说说 HandlerThread

HandlerThread本身也是Thread，只是在Thread基础上封装上了Handler的载体，并且在run方法中创建了looper对象，这也是为什么在IntentService中能在HandlerThread中直接用handler的原因。而我们知道一个线程是可以有多个handler，所以用HandlerThread更加方便我们不用关心Handler的创建，一般用在多线程中直接处理任务

十二 内部类，内部类的作用

定义在一个类里边的类叫做内部类，对应的包含内部类的类叫做外部类。内部类不允许同一包中的其他类进行访问，但是内部类可以访问外部类的所有属性、方法，包括私有数据。

内部类有四种：匿名、成员、静态、方法（局部）内部类。

十三 静态属性和静态方法可否被继承，可否被重写？

静态属性，静态方法可以被继承，不能被重写，而是被隐藏。当子类当中定义了静态的属性和方法，则父类的静态属性，方法称之为隐藏

问：静态内部类与非静态内部类的区别

 按照是否有 static修饰分为静态内部类和非静态内部类，有static修饰的为静态内部类，没有static修饰的为非静态内部类

十四 Java的四种引用类型

强引用：是指创建一个对象并把这个对象赋给一个引用变量。这种类型最为常见, 取消强引用，可以将相应的引用设置为null，就可以进行垃圾回收了

String strong = new String("Strong Reference")

软引用：如果一个对象具有软引用，内存空间足够，垃圾回收器就不会回收它；如果 内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它， 该对象就可以被程序使用。

软引用的作用：

 软引用是用来描述一些有用但并不是必需的对象，可以很好地用来解决OOM的问题，并且这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。软引用在实际中有重要的应用，例如浏览器的后退按钮，这个后退时显示的网页内容可以重新进行请求或者从缓存中取出：如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建，如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出这时候就可以使用软引用

Object obj = new Object();
SoftReference