面向对象测试题

1.说说你对面向对象思想的理解

　　面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，是一种对现

实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

　　面向对象是相对于面向过程来讲的，指的是把 相关的数据和方法组织为一个整体 来看待，从更高的层次来进行系

统建模，更贴近事物的自然运行模式。

　　面向过程到面向对象思想层面的转变：

　　面向过程关注的是执行的过程，面向对象关注的是具备功能的对象。

　　面向过程到面向对象，是程序员思想上 从执行者到指挥者的转变。

 

　　三大特性：

　　封装性：所有的内容对外部不可见

　　继承性：将其他的功能继承下来继续发展

　　多态性：方法的重载本身就是一个多态性的体现

2.Java 对象初始化顺序

　　先初始化父类的静态代码>初始化子类的静态代码>初始化父类的非静态代码>初始化父类构造函数>初始化子类非静态代码>初始化子类构造函数

3.Overload 和 Override 的区别？Overload 的方法是否可以改变返回值的类型

　　重写（Override）规则：

1. 参数列表必须完全与被重写方法的参数列表相同
2. 返回值类型必须完全与被重写方法的返回值类型相同
3. 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected
4. 父类的成员方法只能被它的子类重写
5. 声明为static的private的方法不能被重写，但是能够被再次声明

　　重载（Overload）规则：

1. 方法名称相同
2. 参数列表长度 或 参数列表类型 或 （参数类型顺序不同）

　　区别：

　　1.发生的位置

　　　　重载：一个类中

　　　　重写：子父类中

　　2.参数列表限制

　　　　重载：必须不同的

　　　　重写：必须相同的

　　3.返回值类型

　　　　重载：与返回值类型无关

　　　　重写：返回值类型必须一致

　　4.访问权限

　　　　重载：与访问权限无关

　　　　重写：子的方法权限不许不能小于父的方法权限

　　5.异常处理

　　　　重载：与异常无关

　　　　重写：异常范围可以更小，但是不能抛出新的异常

4.int 和 Integer 有什么区别

　　int基本数据类型　　　　Integer包装类

　　

　　区别：

　　1.int a = 10;这段代码只是在栈里面又一个内存，跟堆没有关系。

　　2.Integer a = new Integer(10);这段代码就是在堆内存中存储了一个int类型的对象10，然后栈中存储此对象的地址。

　　

　　用途：int a = Integer.parseInt("100");将String类型的字符串100转化为int类型。

5.char 型变量中能不能存贮一个中文汉字，为什么

　　char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。

　　unicode编码占用两个字节，char类型的变量也是占用两个字节。

6.Java 中，Serializable 与 Externalizable 的区别

　　Serializable 存储在内存，进程间通信使用。是一个序列化 Java 类的接口，以便于它们可以在网络上传输 或者可以将它们的状态保存在磁盘上，是 JVM 内嵌的默认序列化方式，成本高、脆弱而且不安全。

　　Externalizable 存储在物理介质，主要用于IO操作。允许你控制整个序列化过程，指定特定的二进制格式，增加安全机制。 

7.抽象类和接口有什么区别

　　抽象类是用来捕捉子类的通用特性的，而接口则是抽象方法的集合;抽象类不能被实例化，只能被用作子类的超类，是被用来创建继承层级里子类的模板，而接口只是一种形式，接口自身不能做任何事情。

　　其次，抽象类可以有默认的方法实现，子类使用extends关键字来继承抽象类，如果子类不是抽象类的话，它需要提供抽象类中所有声明方法的实现。而接口完全是抽象的，它根本不存在方法的实现，子类使用关键字implements来实现接口，它需要提供接口中所有声明方法的实现。
　　抽象类可以有构造器，除了不能实例化抽象类之外，它和普通Java类没有任何区别，抽象方法可以有public、protec ted和default这些修饰符。而接口不能有构造器，是完全不同的类型，接口方法默认修饰符是public，不可以使用其它修饰符。

8.String 和 StringBuilder、StringBuffer 的区别

　　这三个类之间的区别主要是在两个方面，即运行速度和线程安全这两方面。

　　1.首先说运行速度，或者说是执行速度，在这方面运行速度快慢为：StringBuilder > StringBuffer > String

　　　　String最慢的原因：

　　　　String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。以下面一段代码为例：

String str="abc";
System.out.println(str);
str=str+"de";
System.out.println(str);

　　如果运行这段代码会发现先输出“abc”，然后又输出“abcde”，好像是str这个对象被更改了，其实，这只是一种假象罢了，JVM对于这几行代码是这样处理的，首先创建一个String对象str，并把“abc”赋值给str，然后在第三行中，其实JVM又创建了一个新的对象也名为str，然后再把原来的str的值和“de”加起来再赋值给新的str，而原来的str就会被JVM的垃圾回收机制（GC）给回收掉了，所以，str实际上并没有被更改，也就是前面说的String对象一旦创建之后就不可更改了。所以，Java中对String对象进行的操作实际上是一个不断创建新的对象并且将旧的对象回收的一个过程，所以执行速度很慢。

　　而StringBuilder和StringBuffer的对象是变量，对变量进行操作就是直接对该对象进行更改，而不进行创建和回收的操作，所以速度要比String快很多。

　　另外，有时候我们会这样对字符串进行赋值

String str="abc"+"de";
StringBuilder stringBuilder=new StringBuilder().append("abc").append("de");
System.out.println(str);
System.out.println(stringBuilder.toString());

　　这样输出结果也是“abcde”和“abcde”，但是String的速度却比StringBuilder的反应速度要快很多，这是因为第1行中的操作和

　　String str="abcde";

　　是完全一样的，所以会很快，而如果写成下面这种形式

String str1="abc";
String str2="de";
String str=str1+str2;

　　那么JVM就会像上面说的那样，不断的创建、回收对象来进行这个操作了。速度就会很慢。

　　2. 再来说线程安全

　　在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的

　　如果一个StringBuffer对象在字符串缓冲区被多个线程使用时，StringBuffer中很多方法可以带有synchronized关键字，所以可以保证线程是安全的，但StringBuilder的方法则没有该关键字，所以不能保证线程安全，有可能会出现一些错误的操作。所以如果要进行的操作是多线程的，那么就要使用StringBuffer，但是在单线程的情况下，还是建议使用速度比较快的StringBuilder。

　　3.总结一下

　　String：适用于少量的字符串操作的情况

　　StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

　　StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

9.阐述 final、finally、finalize 的区别

　　1.final

• 修饰符（bai关键字） 如果一个类被声明为final,意味着它不能再派生新的子类，不能作为父类被继承。因此一个类不能及被声明为abstract，又被声明为final的。
• 将变量或方法声明为final,可以保证他们使用中不被改变。被声明为final的变量必须在声明时给定初值，而以后的引用中只能读取，不可修改，被声明为final的方法也同样只能使用，不能重载。

　　2.finally

• 在异常处理时提供finally块来执行清楚操作。如果抛出一个异常，那么相匹配的catch语句就会执行，然后控制就会进入finally块，如果有的话。

　　3.finalize

• 是方法名。java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除之前做必要的清理工作。这个方法是在垃圾收集器在确定了，被清理对象没有被引用的情况下调用的。
• finalize是在Object类中定义的，因此，所有的类都继承了它。子类可以覆盖finalize()方法，来整理系统资源或者执行其他清理工作。

　　

10.Java 中的异常处理机制的简单原理和应用

　　Java中的异常bai处理机制的简单原理和应用 :

　　java中Throwable这个类可以被作为异常抛出的类,继承它的分为异常Exception和错误Error.

　　　　Exception表示程序需要捕捉和处理的的异常;

　　　　Error表示系统级别的错误和程序无需处理的。

　　我们所需要关心的是Exception. Execption可以分为java标准定义的异常和程序员自定义异常2种.

　　　　（1）一种是当程序违反了java语规则的时候,JAVA虚拟机就会将发生的错误表示为一个异常.这里语法规则指的是JAVA类库内置的语义检查。

　　　　（2）另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是Thowable的子类。

　　异常处理是与程序执行是并行的.

Try{
//可能发现异常的语句块
}catch(异常类型,e){
//发生异常时候的执行语句块
} finnally{
//不管是否发生异常都执行的语句块
}

以下是一个自定义异常测试类:

package code;
class MyException extends Exception
{
    public void f()
    {
        System.out.println("this is my Exception!!");
     }
}
public class ExceptionTestTwo {
     private int i = 0;
      private int j;
       ExceptionTestTwo(int x) throws MyException
      {
         f2();
          j = x / i;
        }
       public void f2() throws MyException
      {
          System.out.println("this is My first Exception!!");
          throw new MyException();
       }
     public static void main(String[] args)
    {
         try {
                  new ExceptionTestTwo(9);
              } catch (MyException e2) {
                    e2.f();
               } catch (Exception e) {
                    e.printStackTrace();
               } finally {
                      System.out.println("Finally is first Exception!!");
                }
        try {
             throw new MyException();
           } catch (MyException e1) {
                e1.f();
            } finally {
                System.out.println("Finally is second Exception!!");
           }
     }
}