zoukankan      html  css  js  c++  java
  • java面试题整理

    原文】 

    本篇文档将持续更新,有基础滴,也有深层次的,谢谢!

    1.看下面的程序是否有问题,如果有问题,请指出并说明理由。

    * byte b1 = 3;

    * byte b2 = 4;

    * byte b3 = b1 + b2;

    * byte b4 = 3 + 4;

    答:byte b3 = b1 + b2;会编译失败,因为这个相加后得到的结果是int类型的,

    而b3是byte类型的,这样转换会损失精度,可用强制类型转换或是两个变量,变量值不确定;

    byte b4 = 3 + 4; 3和4是常量.Java中有常量优化机制,编译时已经变成了常量7了。

     

    2.看下面的程序是否有问题,如果有问题,请指出并说明理由。

    * short s=1; s = s+1;

    答:s赋值后的类型是int类型的,在赋值一个给一个short类型.缺失精度.不能转换

    * short s=1;s+=1;

    答:相当于s=(short)(s+1);里面包含了一个强制转换

     

    3.jdbc简单的编程实现过程

    (1) 加载数据库驱动(com.mysql.jdbc.Driver)

    (2) 创建并获取数据库链接(Connection)

    (3) 创建jdbc statement对象(PreparedStatement)

    (4) 设置sql语句

    (5) 设置sql语句中的参数(使用preparedStatement)

    (6) 通过statement执行sql并获取结果

    (7) 对sql执行结果进行解析处理

    (8) 释放资源(resultSet、preparedstatement、connection)

    复制代码
    package cn.wh.jdbc.test; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException;  /**  * JdbcTest.java 简单的jdbc编程步骤过程  */ public class JdbcTest {     public static void main(String[] args) {         Connection connection = null;         PreparedStatement preparedStatement = null;         ResultSet resultSet = null;         try {             // 1.加载数据库驱动             Class.forName("com.mysql.jdbc.Driver");             // 2.创建数据库连接             connection = DriverManager.getConnection(                     "jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8",                     "root", "1234");             // 3.书写sql语句             String sql = " select * from user where username=? ";             // 4.创建statement,预处理sql语句             preparedStatement = connection.prepareStatement(sql);             // 5.设置sql里的参数             preparedStatement.setString(1, "张三");             // 6.执行sql,得到结果集             resultSet = preparedStatement.executeQuery();             // 7.遍历结果集,打印输出             while (resultSet.next()) {                 System.out.println(resultSet.getString("id") + " "                         + resultSet.getString("username"));             }         }         catch (Exception e) {             // TODO Auto-generated catch block             e.printStackTrace();         }         finally {             // 8.释放资源             if (resultSet != null) {                 try {                     resultSet.close();                 }                 catch (SQLException e) {                     // TODO Auto-generated catch block                     e.printStackTrace();                 }             }             if (preparedStatement != null) {                 try {                     preparedStatement.close();                 }                 catch (SQLException e) {                     // TODO Auto-generated catch block                     e.printStackTrace();                 }             }             if (connection != null) {                 try {                     connection.close();                 }                 catch (SQLException e) {                     // TODO Auto-generated catch block                     e.printStackTrace();                 }             }         }      } }
    复制代码

    注意:jar包的导入,参数的设置,释放资源的顺序,以及jdbc存在的问题,如何解决??

    详见下一篇博客,jdbc编程步骤!

     

     

    4.Java 语言switch语句表达式的类型

    表达式的取值:byte,short,int,char

    JDK5以后可以是枚举
    JDK7以后可以是String

    5.请用最有效率的方式写出计算2乘以8的结果

    System.out.println(2 << 3);//最有效率,直接操作的是二进制

    注:用<<

    6.如何将俩个整型变量交换

      * 引用第三方变量

      * 加减运算

      * 位异或运算

      * 一句话代码

    复制代码
    * int x = 5; int y = 10;    int temp;    temp = x; x = y; y = temp;  * int x = 5; int y = 10;    x = x+y; y = x-y; y = x-y;  *  int x = 5; int y = 10;     x = x^y; y = x^y; x = x^y;   * x = (x+y) - (y=x);      
    复制代码

    7.用最简单的方法计算2*8的结果

      system.out.println(2<<3);

      注:直接操作二进制,效率最快。

    8.什么是水仙花数?

      例:153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153;

    9.方法重载

      方法名相同,只是参数个数、参数类型不同。

    10.java是值传递还是址传递

      1,既是值传递,又是址传递,基本数据类型是值,引用数据类型是址。

      2,值传递,非址传递,因为地址值也是值,高司令支持的说法。

    11.静态变量和成员变量的区别

    * A:所属不同
        * 静态变量属于类,所以也称为为类变量
        * 成员变量属于对象,所以也称为实例变量(对象变量)
    * B:内存中位置不同
        * 静态变量存储于方法区的静态区
        * 成员变量存储于堆内存
    * C:内存出现时间不同
        * 静态变量随着类的加载而加载,随着类的消失而消失
        * 成员变量随着对象的创建而存在,随着对象的消失而消失
    * D:调用不同
        * 静态变量可以通过类名调用,也可以通过对象调用
        * 成员变量只能通过对象名调用

    12.面向对象的特征有哪些?

    答:面向对象的特征主要有以下几个方面:

    * 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。 

    * 继承:继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类(超类、基类);得到继承信息的类被称为子类(派生类)。继承让变化中的软件系统有了一定的延续性,同时继承也是封装程序中可变因素的重要手段(如果不能理解请阅读阎宏博士的《Java与模式》或《设计模式精解》中关于桥梁模式的部分)。 

    * 封装:通常认为封装是把数据和操作数据的方法绑定起来,对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装;我们编写一个类就是对数据和数据操作的封装。可以说,封装就是隐藏一切可隐藏的东西,只向外界提供最简单的编程接口(可以想想普通洗衣机和全自动洗衣机的差别,明显全自动洗衣机封装更好因此操作起来更简单;我们现在使用的智能手机也是封装得足够好的,因为几个按键就搞定了所有的事情)。 

    * 多态性:多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务,那么运行时的多态性可以解释为:当A系统访问B系统提供的服务时,B系统有多种提供服务的方式,但一切对A系统来说都是透明的(就像电动剃须刀是A系统,它的供电系统是B系统,B系统可以使用电池供电或者用交流电,甚至还有可能是太阳能,A系统只会通过B类对象调用供电的方法,但并不知道供电系统的底层实现是什么,究竟通过何种方式获得了动力)。方法重载(overload)实现的是编译时的多态性(也称为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事:1). 方法重写(子类继承父类并重写父类中已有的或抽象的方法);2). 对象造型(用父类型引用引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为)。

    13.代码块的面试题

    答:

    复制代码
    class Student {             static {                 System.out.println("Student 静态代码块");             }                          {                 System.out.println("Student 构造代码块");             }                          public Student() {                 System.out.println("Student 构造方法");             }         }              class StudentDemo {             static {                 System.out.println("静态代码块,带你装逼带你飞");             }                          public static void main(String[] args) {                 System.out.println("我是main方法");                                  Student s1 = new Student();                 Student s2 = new Student();             }         }
    复制代码

    分析:
      1.程序运行时,先加载StudentDemo.class到方法区中,同时此类中的static随着类的加载而加载,输出“静态代码块,带你装逼带你飞”,
      2.到main方法,输出“我是main方法”,
      3.执行Student s1 = new Student();---必须先执行 Student.class ,随之加载static代码块,输出“Student 静态代码块”,然后到构造代码块,输出“Student 构造代码块”
      4.创建s1后面的对象,输出“Student 构造方法”
      5.创建s2后面的对象,先输出“Student 构造代码块”,然后输出“Student 构造方法”
      6.结果就为:“静态代码块,带你装逼带你飞”,
        “我是main方法”
        “Student 静态代码块”
        “Student 构造代码块”
        “Student 构造方法”
        “Student 构造代码块”
        “Student 构造方法”

    14. 继承中的面试题

    复制代码
    看程序写结果2         class Fu {             static {                 System.out.println("静态代码块Fu");             }                  {                 System.out.println("构造代码块Fu");             }                  public Fu() {                 System.out.println("构造方法Fu");             }         }              class Zi extends Fu {             static {                 System.out.println("静态代码块Zi");             }                  {                 System.out.println("构造代码块Zi");             }                  public Zi() {                 System.out.println("构造方法Zi");             }         }         class Demo5Extends {             public static void main(String[] ,args) {                 Zi z = new Zi(); 请执行结果。             }         }
    复制代码

    上述代码的执行过程:
            1,Demo5Extends.class加载进内存
            2,主方法进栈
            3,需要执行Zi z = new Zi();这句话,但是在内存还没有加载Zi.class
            4,Zi继承了Fu,所以Fu.class先加载进内存,同时父类的静态代码块也加载进内存
            5,Zi.class加载进内存,同时子类的静态代码块也加载进内存
            6,执行Zi类的构造方法,子类构造方法中隐藏着super,super会访问父类中的构造方法
            7,在父类构造方法执行之前,会先看是否有构造代码块,有先执行构造代码块
            8,执行父类构造方法
            9,执行子类构造方法,在执行之前会看是否有构造代码块,有先执行
            10,执行子类构造方法

    15.方法重写的面试题的面试题

        * Override和Overload的区别?Overload能改变返回值类型吗?
        * 方法重写:子类中出现了和父类中方法声明一模一样的方法。
        * overload 可以改变返回值类型, 与返回值类型无关,只看参数列表,
        * 方法重载:本类中出现的方法名一样,参数列表不同的方法。与返回值无关。
        
        * 子类对象调用方法的时候:
            * 先找子类本身,再找父类。
            * 创建子类对象,先在子类中找,再在父类中找,

     16.访问修饰符public,private,protected,以及不写(默认)时的区别? 

    修饰符当前类同包子类其他包
    public
    protected×
    default××
    private×××

    类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开(public),对于不是同一个包中的其他类相当于私有(private)。受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。Java中,外部类的修饰符只能是public或默认,类的成员(包括内部类)的修饰符可以是以上四种。

     17.String 是最基本的数据类型吗?

    答:不是。Java中的基本数据类型只有8个:byte、short、int、long、float、double、char、boolean;除了基本类型(primitive type)和枚举类型(enumeration type),剩下的都是引用类型(reference type)。

    18.float f=3.4;是否正确?

    答:不正确。3.4是双精度数,将双精度型(double)赋值给浮点型(float)属于下转型(down-casting,也称为窄化)会造成精度损失,因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;。

     19.short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗? 
    答:对于short s1 = 1; s1 = s1 + 1;由于1是int类型,因此s1+1运算结果也是int 型,需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译,因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。

    20.Java有没有goto? 

    答:goto 是Java中的保留字,在目前版本的Java中没有使用。(根据James Gosling(Java之父)编写的《The Java Programming Language》一书的附录中给出了一个Java关键字列表,其中有goto和const,但是这两个是目前无法使用的关键字,因此有些地方将其称之为保留字,其实保留字这个词应该有更广泛的意义,因为熟悉C语言的程序员都知道,在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留字)。

    21.int和Integer有什么区别? 

    答:Java是一个近乎纯洁的面向对象编程语言,但是为了编程的方便还是引入了基本数据类型,但是为了能够将这些基本数据类型当成对象操作,Java为每一个基本数据类型都引入了对应的包装类型(wrapper class),int的包装类就是Integer,从Java 5开始引入了自动装箱/拆箱机制,使得二者可以相互转换。 

    Java 为每个原始类型提供了包装类型: 
    - 原始类型: boolean,char,byte,short,int,long,float,double 
    - 包装类型:Boolean,Character,Byte,Short,Integer,Long,Float,Double

    复制代码
    class AutoUnboxingTest {     public static void main(String[] args) {         Integer a = new Integer(3);         Integer b = 3;                  // 将3自动装箱成Integer类型         int c = 3;         System.out.println(a == b);     // false 两个引用没有引用同一对象         System.out.println(a == c);     // true a自动拆箱成int类型再和c比较     } }
    复制代码

    最近还遇到一个面试题,也是和自动装箱和拆箱有点关系的,代码如下所示:

    复制代码
    public class Test03 {     public static void main(String[] args) {         Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;         System.out.println(f1 == f2);         System.out.println(f3 == f4);     } }
    复制代码

    如果不明就里很容易认为两个输出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用,所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢?当我们给一个Integer对象赋一个int值的时候,会调用Integer类的静态方法valueOf,如果看看valueOf的源代码就知道发生了什么。

    public static Integer valueOf(int i) {         if (i >= IntegerCache.low && i <= IntegerCache.high)             return IntegerCache.cache[i + (-IntegerCache.low)];         return new Integer(i); }

    IntegerCache是Integer的内部类,其代码如下所示:

    复制代码
    /**      * Cache to support the object identity semantics of autoboxing for values between      * -128 and 127 (inclusive) as required by JLS.      *      * The cache is initialized on first usage.  The size of the cache      * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.      * During VM initialization, java.lang.Integer.IntegerCache.high property      * may be set and saved in the private system properties in the      * sun.misc.VM class.      */     private static class IntegerCache {         static final int low = -128;         static final int high;         static final Integer cache[];         static {             // high value may be configured by property             int h = 127;             String integerCacheHighPropValue =                 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");             if (integerCacheHighPropValue != null) {                 try {                     int i = parseInt(integerCacheHighPropValue);                     i = Math.max(i, 127);                     // Maximum array size is Integer.MAX_VALUE                     h = Math.min(i, Integer.MAX_VALUE - (-low) -1);                 } catch( NumberFormatException nfe) {                     // If the property cannot be parsed into an int, ignore it.                 }             }             high = h;             cache = new Integer[(high - low) + 1];             int j = low;             for(int k = 0; k < cache.length; k++)                 cache[k] = new Integer(j++);             // range [-128, 127] must be interned (JLS7 5.1.7)             assert IntegerCache.high >= 127;         }         private IntegerCache() {}     }
    复制代码

    简单的说,如果整型字面量的值在-128到127之间,那么不会new新的Integer对象,而是直接引用常量池中的Integer对象,所以上面的面试题中f1==f2的结果是true,而f3==f4的结果是false。

    提醒:越是貌似简单的面试题其中的玄机就越多,需要面试者有相当深厚的功力。

    22.&和&&的区别?

     答:&运算符有两种用法:(1)按位与;(2)逻辑与。&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的,虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为,如果&&左边的表达式的值是false,右边的表达式会被直接短路掉,不会进行运算。很多时候我们可能都需要用&&而不是&,例如在验证用户登录时判定用户名不是null而且不是空字符串,应当写为:username != null &&!username.equals(""),二者的顺序不能交换,更不能用&运算符,因为第一个条件如果不成立,根本不能进行字符串的equals比较,否则会产生NullPointerException异常。注意:逻辑或运算符(|)和短路或运算符(||)的差别也是如此。

    补充:如果你熟悉JavaScript,那你可能更能感受到短路运算的强大,想成为JavaScript的高手就先从玩转短路运算开始吧。

    23.解释内存中的栈(stack)、堆(heap)和静态区(static area)的用法。 

    答:通常我们定义一个基本数据类型的变量,一个对象的引用,还有就是函数调用的现场保存都使用内存中的栈空间;而通过new关键字和构造器创建的对象放在堆空间;程序中的字面量(literal)如直接书写的100、"hello"和常量都是放在静态区中。栈空间操作起来最快但是栈很小,通常大量的对象都是放在堆空间,理论上整个内存没有被其他进程使用的空间甚至硬盘上的虚拟内存都可以被当成堆空间来使用。

    String str = new String("hello");

    上面的语句中变量str放在栈上,用new创建出来的字符串对象放在堆上,而"hello"这个字面量放在静态区。

    补充:较新版本的Java(从Java 6的某个更新开始)中使用了一项叫"逃逸分析"的技术,可以将一些局部对象放在栈上以提升对象的操作性能。

    24.Math.round(11.5) 等于多少?Math.round(-11.5)等于多少? 
    答:Math.round(11.5)的返回值是12,Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。

    25.swtich 是否能作用在byte 上,是否能作用在long 上,是否能作用在String上? 
    答:在Java 5以前,switch(expr)中,expr只能是byte、short、char、int。从Java 5开始,Java中引入了枚举类型,expr也可以是enum类型,从Java 7开始,expr还可以是字符串(String),但是长整型(long)在目前所有的版本中都是不可以的。

    26.抽象类中的面试题

    * A:面试题1
      * 一个抽象类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
        * 可以。
        * 这样目的只有一个不让其他类对其创建对象。
    * B:面试题2
      * abstract不能和哪些关键字共存
        * 1.private是私有不让子类看到,abstract是抽象,就是让子类重写,他俩矛盾。
        * 2.static的方法可以直接类名.调用,而类名. 调用抽象方法没有意义。
        * 3.final 是最终的,修饰的方法不让子类重写,而abstract修饰的方法就是为了让子类重写。

     27.用最有效率的方法计算2乘以8? 

    答: 2 << 3(左移3位相当于乘以2的3次方,右移3位相当于除以2的3次方)。

     补充:我们为编写的类重写hashCode方法时,可能会看到如下所示的代码,其实我们不太理解为什么要使用这样的乘法运算来产生哈希码(散列码),而且为什么这个数是个素数,为什么通常选择31这个数?前两个问题的答案你可以自己百度一下,选择31是因为可以用移位和减法运算来代替乘法,从而得到更好的性能。说到这里你可能已经想到了:31 * num 等价于(num << 5) - num,左移5位相当于乘以2的5次方再减去自身就相当于乘以31,现在的VM都能自动完成这个优化。

    复制代码
    public class PhoneNumber {     private int areaCode;     private String prefix;     private String lineNumber;      @Override     public int hashCode() {         final int prime = 31;         int result = 1;         result = prime * result + areaCode;         result = prime * result                 + ((lineNumber == null) ? 0 : lineNumber.hashCode());         result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());         return result;     }      @Override     public boolean equals(Object obj) {         if (this == obj)             return true;         if (obj == null)             return false;         if (getClass() != obj.getClass())             return false;         PhoneNumber other = (PhoneNumber) obj;         if (areaCode != other.areaCode)             return false;         if (lineNumber == null) {             if (other.lineNumber != null)                 return false;         } else if (!lineNumber.equals(other.lineNumber))             return false;         if (prefix == null) {             if (other.prefix != null)                 return false;         } else if (!prefix.equals(other.prefix))             return false;         return true;     }  }
    复制代码

    28.数组有没有length()方法?String有没有length()方法? 

    答:数组没有length()方法,有length 的属性。String 有length()方法。JavaScript中,获得字符串的长度是通过length属性得到的,注意这一点。 

    29.在Java中,如何跳出当前的多重嵌套循环?

    答:在最外层循环前加一个标记如A,然后用break A;可以跳出多重循环。(Java中支持带标签的break和continue语句,作用有点类似于C和C++中的goto语句,但是就像要避免使用goto一样,应该避免使用带标签的break和continue,因为它不会让你的程序变得更优雅,很多时候甚至有相反的作用,所以这种语法其实不知道更好)。

    30.构造器(constructor)是否可被重写(override)? 

    答:构造器不能被继承,因此不能被重写,但可以被重载。

    31.Integer的面试题

    复制代码
    看程序写结果                  Integer i1 = new Integer(97);         Integer i2 = new Integer(97);         System.out.println(i1 == i2);//false         System.out.println(i1.equals(i2));//true         System.out.println("-----------");              Integer i3 = new Integer(197);         Integer i4 = new Integer(197);         System.out.println(i3 == i4);//false         System.out.println(i3.equals(i4));//true         System.out.println("-----------");              Integer i5 = 97;         Integer i6 = 97;         System.out.println(i5 == i6);//true         System.out.println(i5.equals(i6));//true         System.out.println("-----------");              Integer i7 = 197;         Integer i8 = 197;         System.out.println(i7 == i8);//false         System.out.println(i7.equals(i8));//true     * 当Integer直接赋值的范围是在-128到127之间,也就是一个byte的取值范围,不会创建多个对象。     * 第一次Integer = -128,会在底层有一个数组存储-128到127之间的Integer对象值,直接从数组中获取Integer对象。     * 第二次Integer = -128,不会重新创建对象,继续从数组中获取。
    复制代码

    32.String,StringBuffer,StringBuilder的区别

    1
    2
    3
    4
    5
    6
    7
    8
    * String,StringBuffer,StringBuilder的区别
            * StringBuffer和StringBuilder的区别
            * StringBuffer是jdk1.0版本的,是线程安全的,效率低
            * StringBuilder是jdk1.5版本的,是线程不安全的,效率高
     
    * String和StringBuffer,StringBuilder的区别
            * String是一个不可变的字符序列
            * StringBuffer,StringBuilder是可变的字符序列<em id="__mceDel" style="font-family: verdana, Arial, Helvetica, sans-serif; font-size: 14px; line-height: 1.5; background-color: #ffffff;"> </em>

    33.两个对象值相同(x.equals(y) == true),但却可有不同的hash code,这句话对不对? 

    答:不对,如果两个对象x和y满足x.equals(y) == true,它们的哈希码(hash code)应当相同。Java对于eqauls方法和hashCode方法是这样规定的:(1)如果两个对象相同(equals方法返回true),那么它们的hashCode值一定要相同;(2)如果两个对象的hashCode相同,它们并不一定相同。当然,你未必要按照要求去做,但是如果你违背了上述原则就会发现在使用容器时,相同的对象可以出现在Set集合中,同时增加新元素的效率会大大下降(对于使用哈希存储的系统,如果哈希码频繁的冲突将会造成存取性能急剧下降)。

    补充:关于equals和hashCode方法,很多Java程序都知道,但很多人也就是仅仅知道而已,在Joshua Bloch的大作《Effective Java》(很多软件公司,《Effective Java》、《Java编程思想》以及《重构:改善既有代码质量》是Java程序员必看书籍,如果你还没看过,那就赶紧去亚马逊买一本吧)中是这样介绍equals方法的:首先equals方法必须满足自反性(x.equals(x)必须返回true)、对称性(x.equals(y)返回true时,y.equals(x)也必须返回true)、传递性(x.equals(y)和y.equals(z)都返回true时,x.equals(z)也必须返回true)和一致性(当x和y引用的对象信息没有被修改时,多次调用x.equals(y)应该得到同样的返回值),而且对于任何非null值的引用x,x.equals(null)必须返回false。实现高质量的equals方法的诀窍包括:1. 使用==操作符检查"参数是否为这个对象的引用";2. 使用instanceof操作符检查"参数是否为正确的类型";3. 对于类中的关键属性,检查参数传入对象的属性是否与之相匹配;4. 编写完equals方法后,问自己它是否满足对称性、传递性、一致性;5. 重写equals时总是要重写hashCode;6. 不要将equals方法参数中的Object对象替换为其他的类型,在重写时不要忘掉@Override注解。

    34.是否可以继承String类?

    答:String 类是final类,不可以被继承。

    补充:继承String本身就是一个错误的行为,对String类型最好的重用方式是关联关系(Has-A)和依赖关系(Use-A)而不是继承关系(Is-A)。

    35.当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递? 

    答:是值传递。Java语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变,但对对象引用的改变是不会影响到调用者的。C++和C#中可以通过传引用或传输出参数来改变传入的参数的值。在C#中可以编写如下所示的代码,但是在Java中却做不到。

    复制代码
    using System;  namespace CS01 {      class Program {         public static void swap(ref int x, ref int y) {             int temp = x;             x = y;             y = temp;         }          public static void Main (string[] args) {             int a = 5, b = 10;             swap (ref a, ref b);             // a = 10, b = 5;             Console.WriteLine ("a = {0}, b = {1}", a, b);         }     } }
    复制代码

    说明:Java中没有传引用实在是非常的不方便,这一点在Java 8中仍然没有得到改进,正是如此在Java编写的代码中才会出现大量的Wrapper类(将需要通过方法调用修改的引用置于一个Wrapper类中,再将Wrapper对象传入方法),这样的做法只会让代码变得臃肿,尤其是让从C和C++转型为Java程序员的开发者无法容忍。

    36.String和StringBuilder、StringBuffer的区别? 

    答:Java平台提供了两种类型的字符串:String和StringBuffer/StringBuilder,它们可以储存和操作字符串。其中String是只读字符串,也就意味着String引用的字符串内容是不能被改变的。而StringBuffer/StringBuilder类表示的字符串对象可以直接进行修改。StringBuilder是Java 5中引入的,它和StringBuffer的方法完全相同,区别在于它是在单线程环境下使用的,因为它的所有方面都没有被synchronized修饰,因此它的效率也比StringBuffer要高。

    复制代码
    面试题1 - 什么情况下用+运算符进行字符串连接比调用StringBuffer/StringBuilder对象的append方法连接字符串性能更好?  面试题2 - 请说出下面程序的输出。 class StringEqualTest {     public static void main(String[] args) {         String s1 = "Programming";         String s2 = new String("Programming");         String s3 = "Program" + "ming";         System.out.println(s1 == s2);         System.out.println(s1 == s3);         System.out.println(s1 == s1.intern());     } }
    复制代码

    补充:String对象的intern方法会得到字符串对象在常量池中对应的版本的引用(如果常量池中有一个字符串与String对象的equals结果是true),如果常量池中没有对应的字符串,则该字符串将被添加到常量池中,然后返回常量池中字符串的引用。

    37.重载(Overload)和重写(Override)的区别。重载的方法能否根据返回类型进行区分? 

     答:方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译时的多态性,而后者实现的是运行时的多态性。重载发生在一个类中,同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则视为重载;重写发生在子类与父类之间,重写要求子类被重写方法与父类被重写方法有相同的返回类型,比父类被重写方法更好访问,不能比父类被重写方法声明更多的异常(里氏代换原则)。重载对返回类型没有特殊的要求。

    面试题:华为的面试题中曾经问过这样一个问题 - "为什么不能根据返回类型来区分重载",快说出你的答案吧!

     38.描述一下JVM加载class文件的原理机制? 

    答:JVM中类的装载是由类加载器(ClassLoader)和它的子类来实现的,Java中的类加载器是一个重要的Java运行时系统组件,它负责在运行时查找和装入类文件中的类。 
    由于Java的跨平台性,经过编译的Java源程序并不是一个可执行程序,而是一个或多个类文件。当Java程序需要使用某个类时,JVM会确保这个类已经被加载、连接(验证、准备和解析)和初始化。类的加载是指把类的.class文件中的数据读入到内存中,通常是创建一个字节数组读入.class文件,然后产生与所加载类对应的Class对象。加载完成后,Class对象还不完整,所以此时的类还不可用。当类被加载后就进入连接阶段,这一阶段包括验证、准备(为静态变量分配内存并设置默认的初始值)和解析(将符号引用替换为直接引用)三个步骤。最后JVM对类进行初始化,包括:1)如果类存在直接的父类并且这个类还没有被初始化,那么就先初始化父类;2)如果类中存在初始化语句,就依次执行这些初始化语句。 
    类的加载是由类加载器完成的,类加载器包括:根加载器(BootStrap)、扩展加载器(Extension)、系统加载器(System)和用户自定义类加载器(java.lang.ClassLoader的子类)。从Java 2(JDK 1.2)开始,类加载过程采取了父亲委托机制(PDM)。PDM更好的保证了Java平台的安全性,在该机制中,JVM自带的Bootstrap是根加载器,其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载,父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对Bootstrap的引用。下面是关于几个类加载器的说明:

    Bootstrap:一般用本地代码实现,负责加载JVM基础核心类库(rt.jar); Extension:从java.ext.dirs系统属性所指定的目录中加载类库,它的父加载器是Bootstrap; System:又叫应用类加载器,其父类是Extension。它是应用最广泛的类加载器。它从环境变量classpath或者系统属性java.class.path所指定的目录中记载类,是用户自定义加载器的默认父加载器。

    39.char 型变量中能不能存贮一个中文汉字,为什么? 

    答:char类型可以存储一个中文汉字,因为Java中使用的编码是Unicode(不选择任何特定的编码,直接使用字符在字符集中的编号,这是统一的唯一方法),一个char类型占2个字节(16比特),所以放一个中文是没问题的。

     

    补充:使用Unicode意味着字符在JVM内部和外部有不同的表现形式,在JVM内部都是Unicode,当这个字符被从JVM内部转移到外部时(例如存入文件系统中),需要进行编码转换。所以Java中有字节流和字符流,以及在字符流和字节流之间进行转换的转换流,如InputStreamReader和OutputStreamReader,这两个类是字节流和字符流之间的适配器类,承担了编码转换的任务;对于C程序员来说,要完成这样的编码转换恐怕要依赖于union(联合体/共用体)共享内存的特征来实现了。

    40.抽象类(abstract class)和接口(interface)有什么异同?

    答:抽象类和接口都不能够实例化,但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现,否则该类仍然需要被声明为抽象类。接口比抽象类更加抽象,因为抽象类中可以定义构造器,可以有抽象方法和具体方法,而接口中不能定义构造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是private、默认、protected、public的,而接口中的成员全都是public的。抽象类中可以定义成员变量,而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类,而抽象类未必要有抽象方法。

     41.静态嵌套类(Static Nested Class)和内部类(Inner Class)的不同? 

     答:Static Nested Class是被声明为静态(static)的内部类,它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化,其语法看起来挺诡异的,如下所示。

    复制代码
    /**  * 扑克类(一副扑克)  * @author 骆昊  *  */ public class Poker {     private static String[] suites = {"黑桃", "红桃", "草花", "方块"};     private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};      private Card[] cards;      /**      * 构造器      *       */     public Poker() {         cards = new Card[52];         for(int i = 0; i < suites.length; i++) {             for(int j = 0; j < faces.length; j++) {                 cards[i * 13 + j] = new Card(suites[i], faces[j]);             }         }     }      /**      * 洗牌 (随机乱序)      *       */     public void shuffle() {         for(int i = 0, len = cards.length; i < len; i++) {             int index = (int) (Math.random() * len);             Card temp = cards[index];             cards[index] = cards[i];             cards[i] = temp;         }     }      /**      * 发牌      * @param index 发牌的位置      *       */     public Card deal(int index) {         return cards[index];     }      /**      * 卡片类(一张扑克)      * [内部类]      * @author 骆昊      *      */     public class Card {         private String suite;   // 花色         private int face;       // 点数          public Card(String suite, int face) {             this.suite = suite;             this.face = face;         }          @Override         public String toString() {             String faceStr = "";             switch(face) {             case 1: faceStr = "A"; break;             case 11: faceStr = "J"; break;             case 12: faceStr = "Q"; break;             case 13: faceStr = "K"; break;             default: faceStr = String.valueOf(face);             }             return suite + faceStr;         }     } }
    复制代码
    复制代码
    class PokerTest {      public static void main(String[] args) {         Poker poker = new Poker();         poker.shuffle();                // 洗牌         Poker.Card c1 = poker.deal(0);  // 发第一张牌         // 对于非静态内部类Card         // 只有通过其外部类Poker对象才能创建Card对象         Poker.Card c2 = poker.new Card("红心", 1);    // 自己创建一张牌          System.out.println(c1);     // 洗牌后的第一张         System.out.println(c2);     // 打印: 红心A     } }
    复制代码
    复制代码
    下面代码编译哪里报错? class Outer {      class Inner {}      public static void foo() { new Inner(); }      public void bar() { new Inner(); }      public static void main(String[] args) {         new Inner();     } }
    复制代码
    注意:Java中非静态内部类对象的创建要依赖其外部类对象,上面的面试题中foo和main方法都是静态方法,静态方法中没有this,也就是说没有所谓的外部类对象,因此无法创建内部类对象,如果要在静态方法中创建内部类对象,可以这样做:     new Outer().new Inner();

    42.Java 中会存在内存泄漏吗,请简单描述。 

    答:理论上Java因为有垃圾回收机制(GC)不会存在内存泄露问题(这也是Java被广泛使用于服务器端编程的一个重要原因);然而在实际开发中,可能会存在无用但可达的对象,这些对象不能被GC回收,因此也会导致内存泄露的发生。例如hibernate的Session(一级缓存)中的对象属于持久态,垃圾回收器是不会回收这些对象的,然而这些对象中可能存在无用的垃圾对象,如果不及时关闭(close)或清空(flush)一级缓存就可能导致内存泄露。下面例子中的代码也会导致内存泄露。

    复制代码
    import java.util.Arrays; import java.util.EmptyStackException;  public class MyStack<T> {     private T[] elements;     private int size = 0;      private static final int INIT_CAPACITY = 16;      public MyStack() {         elements = (T[]) new Object[INIT_CAPACITY];     }      public void push(T elem) {         ensureCapacity();         elements[size++] = elem;     }      public T pop() {         if(size == 0)              throw new EmptyStackException();         return elements[--size];     }      private void ensureCapacity() {         if(elements.length == size) {             elements = Arrays.copyOf(elements, 2 * size + 1);         }     } }
    复制代码

    上面的代码实现了一个栈(先进后出(FILO))结构,乍看之下似乎没有什么明显的问题,它甚至可以通过你编写的各种单元测试。然而其中的pop方法却存在内存泄露的问题,当我们用pop方法弹出栈中的对象时,该对象不会被当作垃圾回收,即使使用栈的程序不再引用这些对象,因为栈内部维护着对这些对象的过期引用(obsolete reference)。在支持垃圾回收的语言中,内存泄露是很隐蔽的,这种内存泄露其实就是无意识的对象保持。如果一个对象引用被无意识的保留起来了,那么垃圾回收器不会处理这个对象,也不会处理该对象引用的其他对象,即使这样的对象只有少数几个,也可能会导致很多的对象被排除在垃圾回收之外,从而对性能造成重大影响,极端情况下会引发Disk Paging(物理内存与硬盘的虚拟内存交换数据),甚至造成OutOfMemoryError。

    43.抽象的(abstract)方法是否可同时是静态的(static),是否可同时是本地方法(native),是否可同时被synchronized修饰? 

    答:都不能。抽象方法需要子类重写,而静态的方法是无法被重写的,因此二者是矛盾的。本地方法是由本地代码(如C代码)实现的方法,而抽象方法是没有实现的,也是矛盾的。synchronized和方法的实现细节有关,抽象方法不涉及实现细节,因此也是相互矛盾的。

    44.阐述静态变量和实例变量的区别?

    答:静态变量是被static修饰符修饰的变量,也称为类变量,它属于类,不属于类的任何一个对象,一个类不管创建多少个对象,静态变量在内存中有且仅有一个拷贝;实例变量必须依存于某一实例,需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。

    补充:在Java开发中,上下文类和工具类中通常会有大量的静态成员。

     45.是否可以从一个静态(static)方法内部发出对非静态(non-static)方法的调用? 

    答:不可以,静态方法只能访问静态成员,因为非静态方法的调用要先创建对象,在调用静态方法时可能对象并没有被初始化。

    46.如何实现对象克隆?

     答:有两种方式: 
      1). 实现Cloneable接口并重写Object类中的clone()方法; 
      2). 实现Serializable接口,通过对象的序列化和反序列化实现克隆,可以实现真正的深度克隆,代码如下。

    复制代码
    import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream;  public class MyUtil {      private MyUtil() {         throw new AssertionError();     }      public static <T> T clone(T obj) throws Exception {         ByteArrayOutputStream bout = new ByteArrayOutputStream();         ObjectOutputStream oos = new ObjectOutputStream(bout);         oos.writeObject(obj);          ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());         ObjectInputStream ois = new ObjectInputStream(bin);         return (T) ois.readObject();          // 说明:调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义         // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源,这一点不同于对外部资源(如文件流)的释放     } }
    复制代码

    测试代码如下:

    复制代码
    import java.io.Serializable;  /**  * 人类  * @author 骆昊  *  */ class Person implements Serializable {     private static final long serialVersionUID = -9102017020286042305L;      private String name;    // 姓名     private int age;        // 年龄     private Car car;        // 座驾      public Person(String name, int age, Car car) {         this.name = name;         this.age = age;         this.car = car;     }      public String getName() {         return name;     }      public void setName(String name) {         this.name = name;     }      public int getAge() {         return age;     }      public void setAge(int age) {         this.age = age;     }      public Car getCar() {         return car;     }      public void setCar(Car car) {         this.car = car;     }      @Override     public String toString() {         return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";     }  }
    复制代码
    复制代码
    /**  * 小汽车类  * @author 骆昊  *  */ class Car implements Serializable {     private static final long serialVersionUID = -5713945027627603702L;      private String brand;       // 品牌     private int maxSpeed;       // 最高时速      public Car(String brand, int maxSpeed) {         this.brand = brand;         this.maxSpeed = maxSpeed;     }      public String getBrand() {         return brand;     }      public void setBrand(String brand) {         this.brand = brand;     }      public int getMaxSpeed() {         return maxSpeed;     }      public void setMaxSpeed(int maxSpeed) {         this.maxSpeed = maxSpeed;     }      @Override     public String toString() {         return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";     }  }
    复制代码
    复制代码
    class CloneTest {      public static void main(String[] args) {         try {             Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));             Person p2 = MyUtil.clone(p1);   // 深度克隆             p2.getCar().setBrand("BYD");             // 修改克隆的Person对象p2关联的汽车对象的品牌属性             // 原来的Person对象p1关联的汽车不会受到任何影响             // 因为在克隆Person对象时其关联的汽车对象也被克隆了             System.out.println(p1);         } catch (Exception e) {             e.printStackTrace();         }     } }
    复制代码

    注意:基于序列化和反序列化实现的克隆不仅仅是深度克隆,更重要的是通过泛型限定,可以检查出要克隆的对象是否支持序列化,这项检查是编译器完成的,不是在运行时抛出异常,这种是方案明显优于使用Object类的clone方法克隆对象。让问题在编译的时候暴露出来总是优于把问题留到运行时。

    47.GC是什么?为什么要有GC? 

    答:GC是垃圾收集的意思,内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的,Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理,因为垃圾收集器会自动进行管理。要请求垃圾收集,可以调用下面的方法之一:System.gc() 或Runtime.getRuntime().gc() ,但JVM可以屏蔽掉显示的垃圾回收调用。 
    垃圾回收可以有效的防止内存泄露,有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行,不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收,程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。在Java诞生初期,垃圾回收是Java最大的亮点之一,因为服务器端的编程需要有效的防止内存泄露问题,然而时过境迁,如今Java的垃圾回收机制已经成为被诟病的东西。移动智能终端用户通常觉得iOS的系统比Android系统有更好的用户体验,其中一个深层次的原因就在于Android系统中垃圾回收的不可预知性。

    补充:垃圾回收机制有很多种,包括:分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式。标准的Java进程既有栈又有堆。栈保存了原始型局部变量,堆保存了要创建的对象。Java平台对堆内存回收和再利用的基本算法被称为标记和清除,但是Java对其进行了改进,采用“分代式垃圾收集”。这种方法会跟Java对象的生命周期将堆内存划分为不同的区域,在垃圾收集过程中,可能会将对象移动到不同区域: 
    - 伊甸园(Eden):这是对象最初诞生的区域,并且对大多数对象来说,这里是它们唯一存在过的区域。 
    - 幸存者乐园(Survivor):从伊甸园幸存下来的对象会被挪到这里。 
    - 终身颐养园(Tenured):这是足够老的幸存对象的归宿。年轻代收集(Minor-GC)过程是不会触及这个地方的。当年轻代收集不能把对象放进终身颐养园时,就会触发一次完全收集(Major-GC),这里可能还会牵扯到压缩,以便为大对象腾出足够的空间。

      与垃圾回收相关的JVM参数:

    • -Xms / -Xmx — 堆的初始大小 / 堆的最大大小
    • -Xmn — 堆中年轻代的大小
    • -XX:-DisableExplicitGC — 让System.gc()不产生任何作用
    • -XX:+PrintGCDetails — 打印GC的细节
    • -XX:+PrintGCDateStamps — 打印GC操作的时间戳
    • -XX:NewSize / XX:MaxNewSize — 设置新生代大小/新生代最大大小
    • -XX:NewRatio — 可以设置老生代和新生代的比例
    • -XX:PrintTenuringDistribution — 设置每次新生代GC后输出幸存者乐园中对象年龄的分布
    • -XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold:设置老年代阀值的初始值和最大值
    • -XX:TargetSurvivorRatio:设置幸存区的目标使用率

     48.String s = new String("xyz");创建了几个字符串对象? 

    答:两个对象,一个是静态区的"xyz",一个是用new创建在堆上的对象。

    49.接口是否可继承(extends)接口?抽象类是否可实现(implements)接口?抽象类是否可继承具体类(concrete class)? 

    答:接口可以继承接口,而且支持多重继承。抽象类可以实现(implements)接口,抽象类可继承具体类也可以继承抽象类。

     50.一个".java"源文件中是否可以包含多个类(不是内部类)?有什么限制? 

    答:可以,但一个源文件中最多只能有一个公开类(public class)而且文件名必须和公开类的类名完全保持一致。

     

    如有需求,请阅读  java 开发面试题小整理(二)

    谢谢……

    待续……


  • 相关阅读:
    golang 数据结构 优先队列(堆)
    leetcode刷题笔记5210题 球会落何处
    leetcode刷题笔记5638题 吃苹果的最大数目
    leetcode刷题笔记5637题 判断字符串的两半是否相似
    剑指 Offer 28. 对称的二叉树
    剑指 Offer 27. 二叉树的镜像
    剑指 Offer 26. 树的子结构
    剑指 Offer 25. 合并两个排序的链表
    剑指 Offer 24. 反转链表
    剑指 Offer 22. 链表中倒数第k个节点
  • 原文地址:https://www.cnblogs.com/wxmdevelop/p/7150777.html
Copyright © 2011-2022 走看看