Android开发面试题（一）

一、Java基础

1，请说一下final、finally、finalize的区别。

final:用于声明属性、方法和类，分别表示属性不可修改、方法不可改变，类不可继承；

finally:用于异常处理代码块中一定会执行的语句块；

finalize:是Object的一个方法，在垃圾回收器执行的时候会被调用。

参考：http://jingyan.baidu.com/article/597a064363b676312b5243ad.html

①、final这个关键字在Java中代表不可改变的，可用来修饰类，方法，变量。

    对class来说，用法如：final class A{}代表类A为终极类，不能被继承，也就没有子类之说与接口实现之说。

    对method来说，用法如：public final void test(){} 代表此方法不能被重写。

    对argument（论据）来说，先看看这个测试类：

1

2

3

4

5

6

7

8

public class Test { 

    int i =1;

    final Test t  = new Test(); // Test对象引用变量t不能再指向其他Test对象。但可以通过t来改变此对象中的非常量属性值。  

    public final void test(){

        final int i = 1;//final修饰的变量必须在声明时赋值，且不能再改变。

        t.i++;

    }  

}

②、finally关键字用在异常处理中，用于处理异常后的清理工作，实际中一般用于关闭文件流，释放资源等操作。

1

2

3

4

5

6

7

8

9

10

11

System.out.println("----game start----");

            try

            {

                System.out.println("----try----");

                return ;

            }catch(NullPointerException e){

                System.out.println("----catch----");

            }finally{

                System.out.println("----finally----");

            }      

            System.out.println("----game over----");

打印结果：

1

2

3

----game start----

----try----

----finally----

③、finalize方法，为Object基类自带方法，在实际中还没用上，在垃圾回收之前由这个方法进行清理工作，重写Object的这个方法自定义整理工作。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public class Test {

    public static void main(String[] args) {

        // TODO Auto-generated method stub 

        for(int i=0;i<6;i++){

            System.gc();

            Test t = new Test();           

        }

        System.gc();// 若注释此语句，则只打印0-4，这就是Java垃圾回收机制的一个简单验证。

    }

 

    static int count;

 

    protected void finalize() throws Throwable {

        // TODO Auto-generated method stub

        super.finalize();

        System.out.println("-----------finalize----------"+count++);

    }      

}

    打印如下：

1

2

3

4

5

6

-----------finalize----------0

-----------finalize----------1

-----------finalize----------2

-----------finalize----------3

-----------finalize----------4

-----------finalize----------5 //




2，写出下面程序运行结果：

public class Test1 {


public static void main(String[] args) {
Thread t = new Thread() {


public void run() {
test1();
}
};
t.run();
System.out.println("Hello word!");
}


static void test1() {
System.out.println("test1");
}
}

程序执行过程分析：①首先进入main方法创建一个 Thread类的实例t;②执行t.run()方法；③run方法调用test1（）静态方法打印出test1字符串；④顺序执行打印语句打印出Hello world字符串信息。

注意：

JAVA 中，thread的run()和start()方法到底有什么区别：

1.start（）方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码：通过调用Thread类的start()方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。 然后通过此Thread类调用方法run()来完成其运行操作的， 这里方法run()称为线程体， 它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止， 而CPU再运行其它线程， 2.run（）方法当作普通方法的方式调用，程序还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码：而如果直接用Run方法， 这只是调用一个方法而已， 程序中依然只有主线程--这一个线程， 其程序执行路径还是只有一条， 这样就没有达到写线程的目的。  举例说明一下：记住：线程就是为了更好地利用CPU， 提高程序运行速率的！  public class TestThread1{ public static void main(String[] args){ Runner1 r=new Runner1(); //r.run();//这是方法调用，而不是开启一个线程 Thread t=new Thread(r);//调用了Thread(Runnable target)方法。且父类对象变量指向子类对象。 t.start();  for(int i=0;i<100;i++){     System.out.println("进入Main Thread运行状态");     System.out.println(i);    } } } class Runner1 implements Runnable{ //实现了这个接口，jdk就知道这个类是一个线程 public void run(){ for(int i=0;i<100;i++){     System.out.println("进入Runner1运行状态");     System.out.println(i);     } } }

3，请用Java语言实现一个单例。

单例模式（Singleton Pattern）:Ensure a class only has one instance,and privide a global point of access to it.

即保证一个类，只有一个实例存在，同时提供能对该实例加以全局访问的方法。

单例模式的特点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

饿汉式单例类是在Java语言里实现起来最为简便的单例类。其源代码如下：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

publicclassEagerSingleton {

 

    /** 通过静态变量初始化的类实例 */

    privatestaticfinal EagerSingleton instance = newEagerSingleton();

 

    /**

     * 私有的默认构造子

     */

    privateEagerSingleton() {

    }

 

    /**

     * 获取唯一类实例的静态工厂方法

     *

     * @return

     */

    publicstaticEagerSingleton getInstance() {

        returninstance;

    }

 

}

由Java语言类的初始化顺序可知，在这个类被加载时，静态变量会被初始化，此时类的私有构造子会被调用。这时候，单例类的唯一实例就被创建出来了。

Java语言中单例类的一个最重要的特点是类的构造子是私有的，从而避免外界使用构造子直接创建出任意多该类的实例。值得指出的是，由于构造子是私有的，因此该类不能被继承。

参考：http://my.oschina.net/lichhao/blog/107766

4，简述抽象类和接口的区别。

抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。

接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。

抽象类和接口的对比

参数抽象类接口默认的方法实现它可以有默认的方法实现接口完全是抽象的。它根本不存在方法的实现实现子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现构造器抽象类可以有构造器接口不能有构造器与正常Java类的区别除了你不能实例化抽象类之外，它和普通Java类没有任何区别接口是完全不同的类型访问修饰符抽象方法可以有public、protected和default这些修饰符接口方法默认修饰符是public。你不可以使用其它修饰符。main方法抽象方法可以有main方法并且我们可以运行它接口没有main方法，因此我们不能运行它。多继承抽象方法可以继承一个类和实现多个接口接口只可以继承一个或多个其它接口速度它比接口速度要快接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。添加新方法如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。如果你往接口中添加方法，那么你必须改变实现该接口的类。

什么时候使用抽象类和接口

• 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
• 如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
• 如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

参考：http://www.importnew.com/12399.html

            http://www.cnblogs.com/azai/archive/2009/11/10/1599584.html