（某知名网站）Android 一面问题及答案

1、TCP三次握手、四次挥手

答案：http://blog.csdn.net/m78_snail/article/details/44700919

2、计算机网络分层

答案：http://blog.csdn.net/m78_snail/article/details/46560721

3、进程和线程

答案：

进程是程序的一次运行。线程可以理解为进程中执行的一段程序片段。

进程间是独立的，这表现在内存空间，上下文环境上：线程是运行在进程空间内。一般来讲，进程无法突破进程边界存取其他进程内的存储空间；而线程由于处于进程空间内，所以同一进程所产生的线程共享同一内存空间。

线程是属于进程的，当进程退出时该进程所产生的线程都会被强制退出并清除。

线程占用的资源要少于进程所占用的资源，二者都可以设置优先级。

进程间可以通过IPC通信，但线程不可以。

4.同步和异步

答案： 同步与异步网上一段经典回答：

             同步就是你叫我去吃饭，我听到了就和你去吃饭；如果没有听到，你就不停的叫，直到我告诉你听到了，才一起去吃饭。   
             异步就是你叫我，然后自己去吃饭，我得到消息后可能立即走，也可能等到下班才去吃饭。    

在Android方面 我个人认为同步就是为了防止多线程编程中出现不安全的事情，涉及到死锁，资源贡献等等。而Android实现异步 大体上我认为就

就两种 ：1》使用Android Handler异步处理机制（两个应用：处理UI线程更新，图片异步加载）

                 2》使用AysnTask (内部其实也是Handler)；

附：详细链接  线程同步  Android Handler 异步消息处理机制的妙用 创建强大的图片加载类  Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系

5.临界资源 互斥与锁 定义和 进程间通信的方式及优缺点

临界资源是指一段时间内只允许一个进程访问的资源。许多物理设备（如打印机和磁带机）、变量及表格都属于临界资源，它们要求互斥地被共享。而每个进程中访问临界资源的那段代码称为临界区临界资源是指一段时间内只允许一个进程访问的资源。许多物理设备（如打印机和磁带机）、变量及表格都属于临界资源，它们要求互斥地被共享。而每

个进程中访问临界资源的那段代码称为临界区答案：临界资源 是指一段时间内只允许一个进程访问的资源。许多物理设备（如打印机和磁带机）、变量及表格都属于临界源，它们要求互斥地被共享。而每个进程中访问临界资源的那段代码称为临界区。

在单处理机环境下，进程间的通信方式包括

信号量机制（即进程的同步与互斥，低级通信机制）、

共享存储器系统（具体又可分为基于共享数据结构的通信方式和基于共享存储区的通信方式）、

消息传递系统（主要指直接通信方式）及管道通信方式等。

详细链接：临界资源，进程通信详解

6、操作系统用户态和系统态、内核陷入、系统调用

答案：操作系统为什么要分用户态和内核态

7、Java语言三大特性

答案：继承，封装，多态

8、Java如何实现C++中的多重继承

答案：接口 ，内部类

9、Java接口与抽象类的区别，能否在接口中声明final方法、为什么

答案：深入理解Java的接口和抽象类

final和static方法是实例化后常驻于内存中的接口不能实例化,所以不能存在final和static方法

10、Java语言修饰符关键字作用域

答案：Java语言中的修饰符

11、Android事件传递机

答案：Android事件传递机制【Touch事件】

            Android事件传递机制【按键事件】

12、Android多线程通信机制Handler+Looper+MessageQueue

答案：Android Handler 异步消息处理机制

13、Android进程间通信机制IPC

Android进程间通信（IPC）机制Binder

14、编程：给出一个链表头指针，判断链表中是否存在环

答案：经典面试题：链表的相交与环问题

15、编程：用数组实现栈

public class Stack<E> { 

    // Java 不支持泛型数组，如需使用，请使用Java提供的容器  
    private Object[] stack; 

    // 栈的默认初始大小  
    private static final int INIT_SIZE = 2; 

    // 栈顶索引  
    private int index; 

    public Stack() {  
        stack = new Object[INIT_SIZE];  
        index = -1;  
    } 

    /**  
     * 构造方法  
     *   
     * @param initSize  
     *            栈的初始大小  
     */ 
    public Stack(int initSize) {  
        if (initSize < 0) {  
            throw new IllegalArgumentException();  
        }  
        stack = new Object[initSize];  
        index = -1;  
    } 

    /**  
     * 出栈操作  
     *   
     * @return 栈顶对象  
     */ 
    public synchronized E pop() {  
        if (!isEmpty()) {  
            E temp = peek();  
            stack[index--] = null;  
            return temp;  
        }  
        return null;  
    } 

    /**  
     * 入栈操作  
     *   
     * @param obj  
     *            等待入栈的对象  
     */ 
    public synchronized void push(E obj) {  
        if (isFull()) {  
            Object[] temp = stack;  
            // 如果栈满，则创建空间为当前栈空间两倍的栈  
            stack = new Object[2 * stack.length];  
            System.arraycopy(temp, 0, stack, 0, temp.length);  
        }  
        stack[++index] = obj;  
    } 

    /**  
     * 查看栈顶对象  
     *   
     * @return 栈顶对象  
     */ 
    public E peek() {  
        if (!isEmpty()) {  
            return (E) stack[index];  
        }  
        return null;  
    } 

    /**  
     * 查看栈是否为空  
     *   
     * @return 如果栈为空返回true，否则返回false  
     */ 
    public boolean isEmpty() {  
        return index == -1;  
    } 

    /**  
     * 查看栈是否满  
     *   
     * @return 如果栈满返回true,否则返回false  
     */ 
    public boolean isFull() {  
        return index >= stack.length - 1;  
    }  
}