实战,让学习更简单     全国咨询热线:400-009-1906

秒速飞艇彩票开奖网: 秒速飞艇计划app

北京 切换校区

全国24小时免费热线

400-009-1906

Java经典面试题

时间:2018-06-22   来源:尚学堂   阅读:503
题目一

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

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

1.抽象:

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

2.继承:

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

3. 封装:

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

4.多态性:

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

题目二

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

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

题目三

String 是最基本的数据类型吗?
答:不是。Java中的基本数据类型只有8个:byte、short、int、long、float、double、char、boolean;除了基本类型(primitive type),剩下的都是引用类型(reference type),Java 5以后引入的枚举类型也算是一种比较特殊的引用类型。

题目四

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

题目五

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

题目六

Java有没有goto?

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

题目七

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。

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

题目八

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

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

题目九

解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法。
通常我们定义一个基本数据类型的变量,一个对象的引用,还有就是函数调用的现场保存都使用JVM中的栈空间;而通过new关键字和构造器创建的对象则放在堆空间,堆是垃圾收集器管理的主要区域,由于现在的垃圾收集器都采用分代收集算法,所以堆空间还可以细分为新生代和老生代,再具体一点可以分为Eden、Survivor(又可分为From Survivor和To Survivor)、Tenured;方法区和堆都是各个线程共享的内存区域,用于存储已经被JVM加载的类信息、常量、静态变量、JIT编译器编译后的代码等数据;程序中的字面量(literal)如直接书写的100、"hello"和常量都是放在常量池中,常量池是方法区的一部分,。栈空间操作起来最快但是栈很小,通常大量的对象都是放在堆空间,栈和堆的大小都可以通过JVM的启动参数来进行调整,栈空间用光了会引发StackOverflowError,而堆和常量池空间不足则会引发OutOfMemoryError。

String?str?=?new?String("hello");

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

补充1:较新版本的Java(从Java 6的某个更新开始)中,由于JIT编译器的发展和"逃逸分析"技术的逐渐成熟,栈上分配、标量替换等优化技术使得对象一定分配在堆上这件事情已经变得不那么绝对了。

补充2:运行时常量池相当于Class文件常量池具有动态性,Java语言并不要求常量一定只有编译期间才能产生,运行期间也可以将新的常量放入池中,String类的intern()方法就是这样的。

看看下面代码的执行结果是什么并且比较一下Java 7以前和以后的运行结果是否一致。

String?s1?=?new?StringBuilder("go")
.append("od").toString();
System.out.println(s1.intern()?==?s1);
String?s2?=?new?StringBuilder("ja")
.append("va").toString();
System.out.println(s2.intern()?==?s2);

题目十

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

题目十一

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

题目十二

用最有效率的方法计算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;
}

}

题目十三

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

题目十四

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

题目十五

构造器(constructor)是否可被重写(override)?
答:构造器不能被继承,因此不能被重写,但可以被重载。

题目十六

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

题目十七

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

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

题目十八

当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递?
答:是值传递。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程序员的开发者无法容忍。

题目十九

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";
String?s4?=?"ming";
String?s5?=?"Program"?+?"ming";
String?s6?=?s3?+?s4;
System.out.println(s1?==?s2);
System.out.println(s1?==?s5);
System.out.println(s1?==?s6);
System.out.println(s1?==?s6.intern());
System.out.println(s2?==?s2.intern());
}
}

补充:解答上面的面试题需要清除两点:1. String对象的intern方法会得到字符串对象在常量池中对应的版本的引用(如果常量池中有一个字符串与String对象的equals结果是true),如果常量池中没有对应的字符串,则该字符串将被添加到常量池中,然后返回常量池中字符串的引用;2. 字符串的+操作其本质是创建了StringBuilder对象进行append操作,然后将拼接后的StringBuilder对象用toString方法处理成String对象,这一点可以用javap -c StringEqualTest.class命令获得class文件对应的JVM字节码指令就可以看出来。

题目二十

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

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

题目二十一

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

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

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

题目二十三

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

题目二十四

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

/**
*?扑克类(一副扑克)
*[email protected]?骆昊
*
*/
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;
}
}

/**
*?发牌
*[email protected]?index?发牌的位置
*
*/
public?Card?deal(int?index)?{
return?cards[index];
}

/**
*?卡片类(一张扑克)
*?[内部类]
*[email protected]?骆昊
*
*/
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();
题目二十五

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。

题目二十六

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

题目二十七

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

补充:在Java开发中,上下文类和工具类中通?;嵊写罅康木蔡稍?。

题目二十八

是否可以从一个静态(static)方法内部发出对非静态(non-static)方法的调用?
答:不可以,静态方法只能访问静态成员,因为非静态方法的调用要先创建对象,在调用静态方法时可能对象并没有被初始化。

题目二十九

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

import?java.io.ByteArrayInputStream;
import?java.io.ByteArrayOutputStream;
import?java.io.ObjectInputStream;
import?java.io.ObjectOutputStream;
import?java.io.Serializable;

public?class?MyUtil?{

private?MyUtil()?{
throw?new?AssertionError();
}

@SuppressWarnings("unchecked")
public?static?<T?extends?Serializable>?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;

/**
*?人类
*[email protected]?骆昊
*
*/
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?+?"]";
}
}

/**
*?小汽车类
*[email protected]?骆昊
*
*/
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方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时。

题目三十

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:设置幸存区的目标使用率

相关资讯

  • 北京校区
  • 山西校区
  • 郑州校区
  • 武汉校区
  • 四川校区
  • 长沙校区
  • 深圳校区
  • 上海校区
  • 广州校区
  • 保定招生办

北京海淀区校区(总部):北京市海淀区西三旗街道建材城西路中腾建华商务大厦东侧二层尚学堂
北京京南校区:北京亦庄经济开发区科创十四街6号院1号楼 赛蒂国际工业园
咨询电话:400-009-1906 / 010-56233821
面授课程: JavaEE培训、 大数据就业班培训、 大数据云计算周末班培训、 零基础大数据连读班培训、 大数据云计算高手班培训、 人工智能周末班培训、人工智能+Python全栈培训、 H5+PHP全栈工程师培训

山西学区地址:山西省晋中市榆次区大学城大学生活广场万科商业A1座702
咨询电话:0354-3052381 / 18903441162

郑州学区地址:金水区东风路经三路北100米注协大厦10楼
咨询电话:0371-55177956 

武汉学区地址:湖北省武汉市江夏区江夏大道26号 宏信悦谷创业园4楼
咨询电话:027-87989193

四川学区地址:成都市高新区锦晖西一街99号布鲁明顿大厦2栋1003室
咨询电话:028-65176856 / 13880900114

长沙学区地址:长沙市岳麓区麓源路湖南电子商务基地5楼(公交车站:六沟垅)
咨询电话:0731-83072091

深圳校区地址:深圳市宝安区航城街道航城大道航城创新创业园A4栋210(固戍地铁站C出口)
咨询电话:0755-23061965 / 18898413781

上海尚学堂松江校区地址:上海市松江区荣乐东路2369弄45号绿地伯顿大厦2层
咨询电话:021-67690939

广州校区地址:广州市天河区元岗横路31号慧通产业广场B区B1栋6楼尚学堂(地铁3号线或6号线到“天河客运站”D出口,右拐直走约800米)
咨询电话:020-2989 6995

保定招生办公室

地址:河北省保定市竞秀区朝阳南大街777号鸿悦国际1101室

电话:15132423123

Copyright 2006-2018 北京尚学堂科技有限公司  京ICP备13018289号-19  京公网安备11010802015183  
媒体联系:18610174079 闫老师  

有位老师想和您聊一聊

860| 190| 760| 902| 72| 327| 22| 463| 799| 104|