Java程序员面试题集(1-25)

发布时间 : 2017-12-31 11:15:51 编辑 : 闲城旧人 阅读(270)

Java程序员面试题集(1-50)

一、Java基础部分

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

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

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

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

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

4)多态性:多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务,那么运行时的多态性可以解释为:当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)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。

 

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,从JDK 1.5开始引入了自动装箱/拆箱机制,使得二者可以相互转换。

Java 为每个原始类型提供了包装类型:

原始类型: boolean,char,byte,short,int,long,float,double

包装类型:Boolean,Character,Byte,Short,Integer,Long,Float,Double


[java] view plain copy

  1. package com.lovo;  

  2.   

  3. public class AutoUnboxingTest {  

  4.   

  5.     public static void main(String[] args) {  

  6.         Integer a = new Integer(3);  

  7.         Integer b = 3;              // 将3自动装箱成Integer类型  

  8.         int c = 3;  

  9.         System.out.println(a == b); // false 两个引用没有引用同一对象  

  10.         System.out.println(a == c); // true a自动拆箱成int类型再和c比较  

  11.     }  

  12. }  


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


[java] view plain copy

  1. public class Test03 {  

  2.   

  3.     public static void main(String[] args) {  

  4.         Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;  

  5.           

  6.         System.out.println(f1 == f2);  

  7.         System.out.println(f3 == f4);  

  8.     }  

  9. }  


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


[java] view plain copy

  1. public static Integer valueOf(int i) {  

  2.         if (i >= IntegerCache.low && i <= IntegerCache.high)  

  3.             return IntegerCache.cache[i + (-IntegerCache.low)];  

  4.         return new Integer(i);  

  5.     }  


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


[java] view plain copy

  1. /** 

  2.      * Cache to support the object identity semantics of autoboxing for values between 

  3.      * -128 and 127 (inclusive) as required by JLS. 

  4.      * 

  5.      * The cache is initialized on first usage.  The size of the cache 

  6.      * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option. 

  7.      * During VM initialization, java.lang.Integer.IntegerCache.high property 

  8.      * may be set and saved in the private system properties in the 

  9.      * sun.misc.VM class. 

  10.      */  

  11.   

  12.     private static class IntegerCache {  

  13.         static final int low = -128;  

  14.         static final int high;  

  15.         static final Integer cache[];  

  16.   

  17.         static {  

  18.             // high value may be configured by property  

  19.             int h = 127;  

  20.             String integerCacheHighPropValue =  

  21.                 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");  

  22.             if (integerCacheHighPropValue != null) {  

  23.                 try {  

  24.                     int i = parseInt(integerCacheHighPropValue);  

  25.                     i = Math.max(i, 127);  

  26.                     // Maximum array size is Integer.MAX_VALUE  

  27.                     h = Math.min(i, Integer.MAX_VALUE - (-low) -1);  

  28.                 } catch( NumberFormatException nfe) {  

  29.                     // If the property cannot be parsed into an int, ignore it.  

  30.                 }  

  31.             }  

  32.             high = h;  

  33.   

  34.             cache = new Integer[(high - low) + 1];  

  35.             int j = low;  

  36.             for(int k = 0; k < cache.length; k++)  

  37.                 cache[k] = new Integer(j++);  

  38.   

  39.             // range [-128, 127] must be interned (JLS7 5.1.7)  

  40.             assert IntegerCache.high >= 127;  

  41.         }  

  42.   

  43.         private IntegerCache() {}  

  44.     }  


简单的说,如果字面量的值在-128到127之间,那么不会new新的Integer对象,而是直接引用常量池中的Integer对象,所以上面的面试题中f1==f2的结果是true,而f3==f4的结果是false。越是貌似简单的面试题其中的玄机就越多,需要面试者有相当深厚的功力。


8、&和&&的区别?


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

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


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

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

String str = new String(“hello”);

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

补充:较新版本的Java中使用了一项叫“逃逸分析“的技术,可以将一些局部对象放在栈上以提升对象的操作性能。

 

10、Math.round(11.5) 等于多少? Math.round(-11.5)等于多少?

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

 

11、swtich 是否能作用在byte 上,是否能作用在long 上,是否能作用在String上?

答:早期的JDK中,switch(expr)中,expr可以是byte、short、char、int。从1.5版开始,Java中引入了枚举类型(enum),expr也可以是枚举,从JDK 1.7版开始,还可以是字符串(String)。长整型(long)是不可以的。

 

12、用最有效率的方法计算2乘以8?

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

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

 

[java] view plain copy

  1. package com.loonstudio;  

  2.   

  3. public class PhoneNumber {  

  4.     private int areaCode;  

  5.     private String prefix;  

  6.     private String lineNumber;  

  7.   

  8.     @Override  

  9.     public int hashCode() {  

  10.         final int prime = 31;  

  11.         int result = 1;  

  12.         result = prime * result + areaCode;  

  13.         result = prime * result  

  14.                 + ((lineNumber == null) ? 0 : lineNumber.hashCode());  

  15.         result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());  

  16.         return result;  

  17.     }  

  18.   

  19.     @Override  

  20.     public boolean equals(Object obj) {  

  21.         if (this == obj)  

  22.             return true;  

  23.         if (obj == null)  

  24.             return false;  

  25.         if (getClass() != obj.getClass())  

  26.             return false;  

  27.         PhoneNumber other = (PhoneNumber) obj;  

  28.         if (areaCode != other.areaCode)  

  29.             return false;  

  30.         if (lineNumber == null) {  

  31.             if (other.lineNumber != null)  

  32.                 return false;  

  33.         } else if (!lineNumber.equals(other.lineNumber))  

  34.             return false;  

  35.         if (prefix == null) {  

  36.             if (other.prefix != null)  

  37.                 return false;  

  38.         } else if (!prefix.equals(other.prefix))  

  39.             return false;  

  40.         return true;  

  41.     }  

  42.   

  43. }  



13、数组有没有length()方法?String 有没有length()方法?

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

 

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

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

 

15、构造器(constructor)是否可被重写(override)?

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

 

16、两个对象值相同(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注解。

 

17、是否可以继承String 类?

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

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

 

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

答:是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变,但对象的引用是永远不会改变的。C++和C#中可以通过传引用或传输出参数来改变传入的参数的值。

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

 

19、String 和StringBuilder、StringBuffer 的区别?

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

补充1:有一个面试题问:有没有哪种情况用+做字符串连接比调用StringBuffer / StringBuilder对象的append方法性能更好?如果连接后得到的字符串在静态存储区中是早已存在的,那么用+做字符串连接是优于StringBuffer / StringBuilder的append方法的。

补充2:下面也是一个面试题,问程序的输出,看看自己能不能说出正确答案。


[java] view plain copy

  1. package com.lovo;  

  2.   

  3. public class StringEqualTest {  

  4.   

  5.     public static void main(String[] args) {  

  6.         String a = "Programming";  

  7.         String b = new String("Programming");  

  8.         String c = "Program" + "ming";  

  9.           

  10.         System.out.println(a == b);  

  11.         System.out.println(a == c);  

  12.         System.out.println(a.equals(b));  

  13.         System.out.println(a.equals(c));  

  14.         System.out.println(a.intern() == b.intern());  

  15.     }  

  16. }  


 

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

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

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

 

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

答:JVM 中类的装载是由类加载器(ClassLoader) 和它的子类来实现的,Java中的类加载器是一个重要的Java 运行时系统组件,它负责在运行时查找和装入类文件中的类。


补充:

1.由于Java的跨平台性,经过编译的Java源程序并不是一个可执行程序,而是一个或多个类文件。当Java程序需要使用某个类时,JVM会确保这个类已经被加载、连接(验证、准备和解析)和初始化。类的加载是指把类的.class文件中的数据读入到内存中,通常是创建一个字节数组读入.class文件,然后产生与所加载类对应的Class对象。加载完成后,Class对象还不完整,所以此时的类还不可用。当类被加载后就进入连接阶段,这一阶段包括验证、准备(为静态变量分配内存并设置默认的初始值)和解析(将符号引用替换为直接引用)三个步骤。最后JVM对类进行初始化,包括:1如果类存在直接的父类并且这个类还没有被初始化,那么就先初始化父类;2如果类中存在初始化语句,就依次执行这些初始化语句。

2.类的加载是由类加载器完成的,类加载器包括:根加载器(BootStrap)、扩展加载器(Extension)、系统加载器(System)和用户自定义类加载器(java.lang.ClassLoader的子类)。从JDK 1.2开始,类加载过程采取了父亲委托机制(PDM)。PDM更好的保证了Java平台的安全性,在该机制中,JVM自带的Bootstrap是根加载器,其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载,父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对Bootstrap的引用。下面是关于几个类加载器的说明:

a)Bootstrap:一般用本地代码实现,负责加载JVM基础核心类库(rt.jar);

b)Extension:从java.ext.dirs系统属性所指定的目录中加载类库,它的父加载器是Bootstrap;

c)System:又叫应用类加载器,其父类是Extension。它是应用最广泛的类加载器。它从环境变量classpath或者系统属性java.class.path所指定的目录中记载类,是用户自定义加载器的默认父加载器。


 

22、char 型变量中能不能存贮一个中文汉字?为什么?

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

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

 

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

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

 

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

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


[java] view plain copy

  1. package com.lovo;  

  2.   

  3. /** 

  4.  * 扑克类(一副扑克) 

  5.  * @author 骆昊 

  6.  * 

  7.  */  

  8. public class Poker {  

  9.     private static String[] suites = {"黑桃""红桃""草花""方块"};  

  10.     private static int[] faces = {12345678910111213};  

  11.       

  12.     private Card[] cards;  

  13.       

  14.     /** 

  15.      * 构造器 

  16.      *  

  17.      */  

  18.     public Poker() {  

  19.         cards = new Card[52];  

  20.         for(int i = 0; i < suites.length; i++) {  

  21.             for(int j = 0; j < faces.length; j++) {  

  22.                 cards[i * 13 + j] = new Card(suites[i], faces[j]);  

  23.             }  

  24.         }  

  25.     }  

  26.       

  27.     /** 

  28.      * 洗牌 (随机乱序) 

  29.      *  

  30.      */  

  31.     public void shuffle() {  

  32.         for(int i = 0, len = cards.length; i < len; i++) {  

  33.             int index = (int) (Math.random() * len);  

  34.             Card temp = cards[index];  

  35.             cards[index] = cards[i];  

  36.             cards[i] = temp;  

  37.         }  

  38.     }  

  39.       

  40.     /** 

  41.      * 发牌 

  42.      * @param index 发牌的位置 

  43.      *  

  44.      */  

  45.     public Card deal(int index) {  

  46.         return cards[index];  

  47.     }  

  48.       

  49.     /** 

  50.      * 卡片类(一张扑克) 

  51.      * [内部类] 

  52.      * @author 骆昊 

  53.      * 

  54.      */  

  55.     public class Card {  

  56.         private String suite;   // 花色  

  57.         private int face;       // 点数  

  58.   

  59.         public Card(String suite, int face) {  

  60.             this.suite = suite;  

  61.             this.face = face;  

  62.         }  

  63.           

  64.         @Override  

  65.         public String toString() {  

  66.             String faceStr = "";  

  67.             switch(face) {  

  68.             case 1: faceStr = "A"break;  

  69.             case 11: faceStr = "J"break;  

  70.             case 12: faceStr = "Q"break;  

  71.             case 13: faceStr = "K"break;  

  72.             default: faceStr = String.valueOf(face);  

  73.             }  

  74.             return suite + faceStr;  

  75.         }  

  76.     }  

  77. }  

测试类:



[java] view plain copy

  1. package com.lovo;  

  2.   

  3. class PokerTest {  

  4.   

  5.     public static void main(String[] args) {  

  6.         Poker poker = new Poker();  

  7.         poker.shuffle();            // 洗牌  

  8.         Poker.Card c1 = poker.deal(0);  // 发第一张牌  

  9.         // 对于非静态内部类Card  

  10.         // 只有通过其外部类Poker对象才能创建Card对象  

  11.         Poker.Card c2 = poker.new Card("红心"1);    // 自己创建一张牌  

  12.           

  13.         System.out.println(c1);     // 洗牌后的第一张  

  14.         System.out.println(c2);     // 打印: 红心A  

  15.     }  

  16. }  

 


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

答:理论上Java因为有垃圾回收机制(GC)不会存在内存泄露问题(这也是Java被广泛使用于服务器端编程的一个重要原因);然而在实际开发中,可能会存在无用但可达的对象,这些对象不能被GC回收也会发生内存泄露。一个例子就是Hibernate的Session(一级缓存)中的对象属于持久态,垃圾回收器是不会回收这些对象的,然而这些对象中可能存在无用的垃圾对象。下面的例子也展示了Java中发生内存泄露的情况:


[java] view plain copy

  1. package com.lovo;  

  2.   

  3. import java.util.Arrays;  

  4. import java.util.EmptyStackException;  

  5.   

  6. public class MyStack<T> {  

  7.     private T[] elements;  

  8.     private int size = 0;  

  9.       

  10.     private static final int INIT_CAPACITY = 16;  

  11.       

  12.     public MyStack() {  

  13.         elements = (T[]) new Object[INIT_CAPACITY];  

  14.     }  

  15.       

  16.     public void push(T elem) {  

  17.         ensureCapacity();  

  18.         elements[size++] = elem;  

  19.     }  

  20.       

  21.     public T pop() {  

  22.         if(size == 0)   

  23.             throw new EmptyStackException();  

  24.         return elements[--size];  

  25.     }  

  26.       

  27.     private void ensureCapacity() {  

  28.         if(elements.length == size) {  

  29.             elements = Arrays.copyOf(elements, 2 * size + 1);  

  30.         }  

  31.     }  

  32. }  


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


评论

您的昵称 :
评论内容 :

music cover

燕归巢

许嵩

00:00/00:00

歌名 歌手 时长