Java中的经典面试题

                l或L：给long型。 

                f或F：给float型

                d或D：给double型

7.判断下面语句是否正确，如果不正确，用三种方法进行修改。

package cn.dong; public class Demo07 { public static void main(String[] args) { /** * 判断下面语句是否正确，若不正确，用三种方法进行修改 */ float f = 3.14; //错误 //方法一 将数据类型改为double double f1 = 3.14; //方法二 加上f后缀 float f2 = 3.14f; //方法三 强制类型转换 float f3 = (float) 3.14; } }

7.用效率最高的方式完成除2操作。

        答：是向右移位操作(x>>1);而不是x/2.

        注意：移位操作的效率高于乘除。

8.简述while和do-while的区别？

        （1）格式不同：

                while(条件){

                        语句；

                }

                do{

                        语句；

                }while(条件);

        (2)如果条件为true,则两者没有任何区别；

        (3)如果条件为false,那么do-while至少比while多执行一次。

9.简述一下封装。

        答：从结构上看：类体中包含属性和方法，换言之，类体将属性和方法封装了起来。

        从访问权限看：如果一个类的属性或方法是私有的(private),外类不能访问，即使你使用"."也不行。这样做的好处就是防止外类给这个对象的属性赋非法值。我们只能通过公有方法给私有属性赋值。我们可以在共有方法内部添加条件语句，来判断输入的值是否合法，而有选择的给属性赋值。进而保护了属性。

10.构造器的特点

        (1)是一个方法；

        (2)没有返回类型

        (3)方法名必须跟类名相同

        (4)可以用public,protected,默认,private(3p+默认)来进行修饰，但不能使用static,final,abstract来修饰

        (5)可以有return;

        (6)可以抛出异常

11.方法的覆盖和重载

        (1)方法的覆盖

                规则：

                    

         (2)方法的重载：一个类中方法名相同但方法的参数不同，则称为方法的重载。

               注意：参数不同是指参数的个数不同或者是参数类型不同；跟参数名无关，也跟方法的返回值和修饰符无关。

代码演示：

package cn.dong.demo; public class Demo01 { /** * 方法的重载 * 一个类中方法名相同，但参数不同方法叫做方法的重载。 * 注意:参数不同是指参数的类型不同或者参数的个数不同； * 与方法的返回值和参数名无关 */ public void aaa(int a,double b){ } public int aaa(int a,int b){ return 0; } public double aaa(double a,int b){ return 0; } public void aaa(int a,int b,int c){ } }

12.super关键字

        用法1：super.方法名(),在子类中调用父类的构造方法。

        用法2：super.属性名，在子类中调用父类的属性。

        用法3：super(参数列表),在子类的构造器中调用父类的构造器。

用法3的实例：

        G.java

package cn.dong.demo1; public class G { public G(){ System.out.println("G()构造器"); } public G(String s){ System.out.println("G(String)构造器"); }

        F.java

package cn.dong.demo1; public class F extends G{ public F() { //super(); System.out.println("F()构造器"); } public F(String s) { //super(); System.out.println("F(String)构造器"); } }

        S.java

package cn.dong.demo1; public class S extends F{ public S(){ //子类构造器中默认调用父类的默认(无参)构造器 //super(); System.out.println("S()构造器"); } public S(String s){ System.out.println("S(String)构造器"); } public static void main(String[] args) { S s = new S(); } }

        运行S.java中的主方法的结果为：

        

 当S.java中主方法的调用有参的构造器创建对象时，即

package cn.dong.demo1; public class S extends F{ public S(){ //子类构造器中默认调用父类的默认(无参)构造器 //super(); System.out.println("S()构造器"); } public S(String s){ System.out.println("S(String)构造器"); } public static void main(String[] args) { S s = new S("lll"); } }

        运行的结果为：

      

 13.Object类的父类是什么

        答：Object类没有父类。

                那么，怎样求一个类的父类，我们可以用反射的知识来演示

                

package cn.dong.demo04; public class Test { public static void main(String[] args) { /** * 用反射判断一个类的父类 * getClass():返回类的字节码对象 * getSuperclass():返回该类父类的字节码对象 */ S s = new S(); Class c = s.getClass();//得到s的字节码对象 Class sc = c.getSuperclass(); System.out.println(sc.getName());//cn.dong.demo04.F Class scc = sc.getSuperclass(); System.out.println(scc);//class java.lang.Object Class sccc = scc.getSuperclass(); System.out.println(sccc);//null } } class F{ } class S extends F{ }

13.final关键字：final表示最终的，可以用来修饰变量，方法和类；

        (1)修饰一个变量时，由于这个变量值不能改变，这个变量就变成了一个常量；

        (2)修饰一个方法时，这个方法是最终方法，不能被子类覆盖；

        (3)修饰一个类时，这个类是最终类，不能被其他类继承。

14.哪些情况下一个一个类没有子类？

        答：(1)用final修饰的类没有子类

                (2)一个类中的所有构造器都是私有的类不能被继承

15.接口的父类是Object类?

        答：错。接口没有父类，可以通过反射来验证。

public class Demo01 { //验证接口的父类是否是Object public static void main(String[] args) { Class c = Area.class; Class su = c.getSuperclass();//得到接口父类的字节码对象 System.out.println(su);//null } }

16.接口也具有继承性，但它不像类，它可以有多个父接口

        代码演示：

public interface Area { double getArea(); } public interface Period { double getPeriod(); } public interface Common extends Area,Period{ //一个接口可以继承多个接口 //接口也具有继承性，但它不像类，它可以有多个父接口。 void show(); }

17.判断下面程序的输出结果。

public class Demo06 { public static void main(String[] args) { String s = "i love java"; String s1 = s.replace('l', 'i'); System.out.println(s==s1);//false String s2 = s.replace('l','l'); System.out.println(s==s2);//true } }

【注意】第二条输出语句的结果为true,为什么呢？我们通过源码来分析

public String replace(char oldChar, char newChar) { if (oldChar != newChar) { int len = value.length; int i = -1; char[] val = value; /* avoid getfield opcode */ while (++i < len) { if (val[i] == oldChar) { break; } } if (i < len) { char buf[] = new char[len]; for (int j = 0; j < i; j++) { buf[j] = val[j]; } while (i < len) { char c = val[i]; buf[i] = (c == oldChar) ? newChar : c; i++; } return new String(buf, true); } } return this; }

18.比较String类,StringBuffer类和StringBuilder类的异同.

        首先我们来看看这三个类的定义：

String类：

public final class String
    implements java.io.Serializable, Comparable, CharSequence {

}

StringBuffer类:

public final class StringBuffer extends AbstractStringBuilder implements         java.io.Serializable, CharSequence {

}

StringBuilder类:

public final class StringBuilder extends AbstractStringBuilder implements         java.io.Serializable, CharSequence {

相同点：

        1.这三个类都是用final修饰，都属于最终类，没有子类；

        2.它们都实现了Serializable接口和CharSequence接口;

        3.StringBuffer和StringBuilder中的定义，构造器，方法都一样；

不同点：

        1.String类在创建对象时，其对象是不会改变的，而StringBuffer和StringBuilder是可变的；

        2.StringBuffer类是线程安全的，因为该类中的许多方法都是用synchronized修饰的；而StringBuilder类是线程不安全的，但是StringBuilder类的效率要远远大于StringBuffer类；

        3.StringBuilder类中的大多数的方法都是返回自身，所以StringBuilder适用于链式编程。

19.比较java.lang.Error和java.lang.Exception的异同？

        答：

         相同：它们的父类都是Throwable类.

         不同点：Exception类是可以从任何标准Java类方法中抛出的基本类型异常，也是程序员需要处理的; Error代表编译期和系统错误，不需要程序员处理。

20.比较RuntimeException和Exception类的异同，并举出至少5个RuntimeException的子类。

答：Exception分为RuntimeException和其他Exception异常，RuntimeException异常(又称不受检查异常)是由Java虚拟机抛出的，不需要程序员处理；而其他Exception(又称受检查异常)必须由程序员处理，处理的方式有两种，一种是try-catch,另一种是用throws抛出异常。

        RuntimeException的子类：

                ArithmeticException类

                ArrayIndexOutBoundsException类

                IllegalArgumentException类

                NumberFormatException类

                ClassCastException类

                NegativeArraySizeException类

                StringIndexOutBoundsException类