疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

20道常见初级Java面试题!


 

   

  大家都应该知道Java是目前最火的计算机语言之一,连续几年蝉联最受程序员欢迎的计算机语言榜首,因此每年新入职Java程序员也数不胜数。究竟这些新入职的Java程序员是入坑还是入行呢?那就要看他们对于Java这门语言的看法了。不管如何,在入职之前,问题会要经过面试,那么Java面试题是怎么出的呢?下面罗列了20道常见初级Java面试题,简直是入职者必备!

  1、面向对象的特征有哪些方面?

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

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

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

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

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

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

  答:

  修饰符当前类同 包子 类其他包

  public√√√√

  protected√√√×

  default√√××

  private√×××

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

  3、String 是最基本的数据类型吗?

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

  4、float f=3.4;是否正确?

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

  5、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);其中有隐含的强制类型转换。

  6、Java有没有goto?

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

  7、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=} 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。

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

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

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

  String str = new String("hello");

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

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

  答:是值传递。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程序员的开发者无法容忍。

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

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

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

  11、描述一下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所指定的目录中记载类,是用户自定义加载器的默认父加载器。

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

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