8、java面试题三

1、序列化接口的id有什么用？

 

• 对象经常要通过IO进行传送，让你写程序传递对象，你会怎么做？
• 把对象的状态数据用某种格式写入到硬盘，Person->“zxx,male,28,30000”?Person，既然大家都要这么干，并且没有个统一的干法，
• 于是，sun公司就提出一种统一的解决方案，它会把对象变成某个格式进行输入和输出，
• 这种格式对程序员来说是透明（transparent）的，但是，我们的某个类要想能被sun的这种方案处理，必须实现Serializable接口。
• ObjectOutputStream.writeObject(obj);
• Object obj = ObjectInputStream.readObject();
• 假设两年前我保存了某个类的一个对象，这两年来，我修改该类，删除了某个属性和增加了另外一个属性，
• 两年后，我又去读取那个保存的对象，或有什么结果？未知！sun的jdk就会蒙了。
• 为此，一个解决办法就是在类中增加版本后，每一次类的属性修改，都应该把版本号升级一下，
• 这样，在读取时，比较存储对象时的版本号与当前类的版本号，如果不一致，则直接报版本号不同的错!

2、编写一个函数将一个十六进制数的字符串参数转换成整数返回

import java.util.*;
import java.math.*;

class  Demo
{
	public static void main(String[] args) 
	{
		Scanner scan = new Scanner(System.in);
		String num = scan.next();
		int i = parseInt(num);
		System.out.println(i);
	}
	public static int parseInt(String num){
		//return Integer.parseInt(num,16);
		char c;
		int d;
		int sum = 0;
		for(int i=0;i<num.length();i++){
			c = num.charAt(num.length()-1-i);
			d = Character.digit(c,16);
			sum += d<<(4*i);
		}
		return sum;
	}
}

 

3、super.getClass()方法调用

import java.util.*;

class Demo extends Date
{
	public static void main(String[] args) 
	{
		new Demo().print();
	}
	public void print()
	{
		System.out.println(super.getClass().getName());
	}
}

•  结果是Demo,
• getClass()在Object类中定义成了final，子类不能覆盖该方法
• 所以，getClass在哪个类中调用，就返回哪个运行时类,与super无关
• 因为可以这样想：Demo的getClass方法是从Date继承来的，调用this.getClass时返回的是Demo
• 而getClass是final的不能被重写，所以上述调用，就相当于是super.getClass
• 所以，在子类中：super.getClass()任然返回的是子类类型
• 想要获得父类的类型，应该这样：getClass().getSuperclass().getName();

4、 jdk中哪些类是不能继承的？

 

• 不能继承的是类是那些用final关键字修饰的类。
• 一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是final的，
• 比如System,String,StringBuffer等就是这样的类

5、String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？

 

• 没有。
• 因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。
• 在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。
• 这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
• 通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。
• 因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。
• 这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
• 同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。
• 例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：

• public class Demo {
  private String s;
  	...
  	public Demo {
  		s = "Initial Value";
  	}
  	...
  }

   
• 而非 s = new String("Initial Value");
• 后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。
• 也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
• 上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。
• 而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。
• 至于为什么要把String类设计成不可变类，是它的用途决定的。
• 其实不只String，很多Java标准类库中的类都是不可变的。
• 在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。
• 不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。
• 当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即 StringBuffer。

6、String s = new String("xyz");

创建了几个String Object? 二者之间有什么区别？

 

• 两个或一个，
• ”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。
• New String每写一遍，就创建一个新的对象，它用常量”xyz”对象的内容来创建出一个新String对象。
• 如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。

7、String 和StringBuffer的区别

 

• JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。
• String类表示内容不可改变的字符串。
• 而StringBuffer类表示内容可以被修改的字符串。当字符数据要改变的时候可以使用StringBuffer。
• 典型地，可以使用StringBuffers来动态构造字符数据。
• 另外，String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。
• 接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。

StringBuffer sbf = new StringBuffer();

for(int i=0;i<100;i++)

{

sbf.append(i); 

}

• 上面的代码效率很高，因为只创建了一个StringBuffer对象，而下面的代码效率很低，因为创建了101个对象。

String str = new String();

for(int i=0;i<100;i++)

{

str = str + i;

}

• 在讲两者区别时，应把循环的次数搞成10000，然后用endTime-beginTime来比较两者执行的时间差异，
• 当循环10000次时，很明显，用StingBuffer的时间最多就100毫秒，大多数情况下是0毫秒
• 而String用的时间多在1700毫秒，由此可见二者区别之大
• 最后还要讲讲StringBuilder与StringBuffer的区别

class Demo
{
	public static void main(String[] args) 
	{
		String str = "";
		StringBuffer sb = new StringBuffer();
		long beginTime = System.currentTimeMillis();
		for(int i=0;i<10000;i++)
			sb.append(i);
		long endTime = System.currentTimeMillis();
		System.out.println("StringBuffer 耗时："+(endTime-beginTime));
		beginTime = System.currentTimeMillis();
		for(int i=0;i<10000;i++)
			str += i;
		endTime = System.currentTimeMillis();
		System.out.println("String 耗时："+(endTime-beginTime));
	}
}

 

8、StringBuffer与StringBuilder的区别

 

• StringBuffer和StringBuilder类都表示内容可以被修改的字符串，
• StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。
• 如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用，那么最好用StringBuffer。

9、下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";

 

• 答：对于如下代码：
• String s1 = "a";
• String s2 = s1 + "b";
• String s3 = "a" + "b";
• System.out.println(s2 == "ab");
• System.out.println(s3 == "ab");
• 第一条语句打印的结果为false，第二条语句打印的结果为true，
• 这说明javac编译可以对字符串常量直接相加的表达式进行优化，
• 不必要等到运行期去进行加法运算处理（其他常量的运算也是一样），而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。
• 题目中的第一行代码被编译器在编译时优化后，相当于直接定义了一个”abcd”的字符串，所以，上面的代码应该只创建了一个String对象。写如下两行代码，
• String s = "a" + "b" + "c" + "d";
• System.out.println(s == "abcd");
• 最终打印的结果应该为true。