经典完整java面试题大全

2020年05月10日 阅读数:143
这篇文章主要向大家介绍经典完整java面试题大全,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

http://www.dev26.com/blog/article/404

Java面向对象

1.       super()与this()的区别?

This():当前类的对象,super父类对象。html

Super():在子类访问父类的成员和行为,必须受类继承规则的约束前端

而this他表明当前对象,固然全部的资源均可以访问.java

在构造函数中,若是第一行没有写super(),编译器会自动插入.可是若是父类没有不带参数的构造函数,或这个函数被私有化了(用private修饰).此时你必须加入对父类的实例化构造.而this就没有这个要求,由于它自己就进行实例化的构造.
而在方法中super和this使用的方法就差很少了.只不过super 要考虑是否能访问其父类的资源.程序员

2.       做用域public,protected,private,以及不写时的区别?

Ø        Public:不一样包、同一包、类内均可用web

Ø        Private:类内算法

Ø        Protected: 不一样包的子类、同一包、类内均可用spring

Ø        不写时:同一包内、类内sql

3.       编程输出以下图形。

* * * * *数据库

* * * *apache

* * *

* *

*

代码以下:

1
2
3
4
5
6
7
8
9
10
public  class  Print {
     public  static  void  main(String[] args) {
        for  ( int  i =  0 ; i <  5 ; i++){
            for  ( int  j =  5 ; j > i; j--) {
               System.out.print( "*" );
            }
            System.out.println();
        }
     }
}


4.       JAVA的事件委托机制和垃圾回收机制

java 事件委托机制的概念,一个源产生一个事件并将它送到一个或多个监听器那里。在这种方案中,监听器简单的等待,直到它收到一个事件。一旦事件被接受,监听器将处理这个事件,而后返回。

垃圾回收机制 垃圾收集是将分配给对象但再也不使用的内存回收或释放的过程。若是一个对象没有指向它的引用或者其赋值为null,则次对象适合进行垃圾回收

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

用break; return 方法。

6.       什么是java序列化,如何实现java序列化?(写一个实例)

序列化:

处理对象流的机制,所谓对象流也就是将对象的内容进行流化。能够对流化后的对象进行读写操做,也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操做时所引起的问题。

序列化的实现:

将须要被序列化的类实现Serializable接口,该接口没有须要实现的方法,implements Serializable只是为了标注该对象是可被序列化的,而后使用一个输出流(如:FileOutputStream)来构造一个ObjectOutputStream(对象流)对象,接着,使用ObjectOutputStream对象的writeObject(Object obj)方法就能够将参数为obj的对象写出(即保存其状态),要恢复的话则用输入流。

7.       一个".java"源文件中是否能够包括多个类(不是内部类)?有什么限制?

能够。若是这个类的修饰符是public,其类名与文件名必须相同。

8.       排序都有哪几种方法?请列举。用JAVA实现一个快速排序?

排序的方法有:插入排序(直接插入排序、希尔排序),交换排序(冒泡排序、快速排序),选择排序(直接选择排序、堆排序),归并排序,分配排序(箱排序、基数排序)

快速排序的伪代码。

9.       Overload和Override的区别。Overloaded的方法是否能够改变返回值的类型?

方法的

重写Override,子类覆盖父类的方法,将子类传与父类的引用调用的仍是子类的方法。

重载Overloading 一个类多个方法,名称相同,参数个数类型不一样。

二者都是Java多态性的不一样表现。

Overloaded的方法是能够改变返回值的类型。

1
2
3
4
5
6
7
8
1 ,  public  class  Ctest()
{
     Public  static  void  main()
{
System.out.prinln( 8 + 8 +” 88 ”+ 8 + 8 );
}
}
168888


10.  Final类有什么特色?

      属性常量

      方法不能够overridding

      类不能够继承

11.  继承时候类的执行顺序问题,通常都是选择题,问你将会打印出什么?

答:父类:

1
2
3
4
5
6
7
8
package  test;
public  class  FatherClass
{
public  FatherClass()
{
System.out.println( "FatherClassCreate" );
}
}


子类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package  test;
import  test.FatherClass;
public  class  ChildClass  extends  FatherClass
{
public  ChildClass()
{
System.out.println( "ChildClass Create" );
}
public  static  void  main(String[] args)
{
FatherClass fc =  new  FatherClass();
ChildClass cc =  new  ChildClass();
}
}


输出结果:

C:>java test.ChildClass

FatherClass Create

FatherClass Create

ChildClass Create

12. 内部类的实现方式?

答:示例代码以下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package  test;
public  class  OuterClass
{
private  class  InterClass
{
Public Interlass()
{
System.out.println( "InterClass Create" );
}
}
public  OuterClass()
{
InterClass ic =  new  InterClass();
System.out.println( "OuterClassCreate" );
}
public  static  void  main(String[] args)
{
OuterClass oc =  new  OuterClass();
}
}


输出结果:

C:>java test/OuterClass

InterClass Create

OuterClass Create

13.   用JAVA实现一种排序,JAVA类实现序列化的方法(二种)?

14.    如在COLLECTION框架中,实现比较要实现什么样的接口?

15. 用插入法进行排序代码以下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package  test;
import  java.util.*;
class  InsertSort{
ArrayList al;
public  InsertSort( int  num, int  mod)
{
al =  new  ArrayList(num);
Random rand =  new  Random();
System.out.println( "The ArrayList Sort Before:" );
for  ( int  i= 0 ;i<num ;i++ )
{
al.add( new  Integer(Math.abs(rand.nextInt()) % mod +  1 ));
System.out.println( "al[" +i+ "]=" +al.get(i));
}
}
public  void  SortIt()
{
Integer tempInt;
int  MaxSize= 1 ;
for ( int  i= 1 ;i<al.size();i++)
{
tempInt = (Integer)al.remove(i);
if (tempInt.intValue()>=((Integer)al.get(MaxSize- 1 )).intValue())
{
al.add(MaxSize,tempInt);
MaxSize++;
System.out.println(al.toString());
else  {
for  ( int  j= 0 ;j<MaxSize ;j++ )
{
if
    
(((Integer)al.get(j)).intValue()>=tempInt.intValue())
{
al.add(j,tempInt);
MaxSize++;
System.out.println(al.toString());
break ;
}
}
}
}
System.out.println( "The ArrayList Sort After:" );
for ( int  i= 0 ;i<al.size();i++)
{
System.out.println( "al[" +i+ "]=" +al.get(i));
}
}
public  static  void  main(String[] args)
{
InsertSort is =  new  InsertSort( 10 , 100 );
is.SortIt();
}
}


JAVA类实现序例化的方法是实现java.io.Serializable接口

Collection框架中实现比较要实现Comparable 接口和 Comparator 接口

16.  编程:编写一个截取字符串的函数,输入为一个字符串和字节数,输出为按字节截取的字符串。 可是要保证汉字不被截半个,如"我ABC"4,应该截为"我AB",输入"我ABC汉DEF",6,应该输出为"我ABC"而不是"我ABC+汉的半个"。

答:代码以下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public  static  void  split(String source, int  num)  throws  Exception
     {
        int  k= 0 ;
        String temp= "" ;
        for  ( int  i =  0 ; i<source.length(); i++)
        {
            byte []b=(source.charAt(i)+ "" ).getBytes();
            k=k+b.length;
            if (k>num)
            {
               break ;
            }
            temp=temp+source.charAt(i);     
        }
        System.out.println(temp);
     }


15、Java编程,打印昨天的当前时刻

1
2
3
4
5
6
7
public  class  YesterdayCurrent{
public  void  main(String[] args){
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, - 1 );
System.out.println(cal.getTime());
}
}


16、文件读写,实现一个计数器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public  int  getNum(){
int  i = - 1 ;
try {
String stri= "" ;
BufferedReader in =  new  BufferedReader( new  FileReader(f));
while ((stri=in.readLine())!= null ){
i = Integer.parseInt(stri.trim());
}
in.close();
} catch (Exception e){
e.printStackTrace();
}
return  i;
}
public  void  setNum(){
int  i = getNum();
i++;
try {
PrintWriter out= new  PrintWriter( new  BufferedWriter(newFileWriter(f, false )));
out.write(String.valueOf(i));  //多是编码的缘由,若是直接写入int的话,将出现java编码和windows编码的混乱,所以此处写入的是String
out.close() ;
} catch (Exception e){
e.printStackTrace();
}
}


17、指出下面程序的运行结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class  A{
static {
System.out.print( "1" );
}
public  A(){
System.out.print( "2" );
}
}
class  extends  A{
static {
System.out.print( "a" );
}
public  B(){
System.out.print( "b" );
}
}
public  class  Hello{
public  static  void  main(String[] ars){
A ab =  new  B();  //执行到此处,结果: 1a2b
ab =  new  B();  //执行到此处,结果: 1a2b2b
}
}


  注:类的static 代码段,能够看做是类首次加载(被虚拟机加载)执行的代码,而对于类的加载,首先要执行其基类的构造,再执行其自己的构造

18、抽象类和接口的区别?

(1)接口能够被多重implements,抽象类只能被单一extends

(2)接口只有定义,抽象类能够有定义和实现

(3)接口的字段定义默认为:public static final, 抽象类字段默认是"friendly"(本包可见)

当功能须要累积时用抽象类,不须要累积时用接口。

19、什么是类的返射机制?

经过类(Class对象),能够得出当前类的fields、method、construtor、interface、superClass、modified等,同是能够经过类实例化一个实例、设置属性、唤醒方法。Spring中一切都是返射、struts、hibernate都是经过类的返射进行开发的。

20、类的返射机制中的包及核心类?

  java.lang.Class

  java.lang.refrection.Method

  java.lang.refrection.Field

  java.lang.refrection.Constructor

  java.lang.refrection.Modifier

  java.lang.refrection.Interface

21、获得Class的三个过程是什么?

对象.getClass()

      类.class或Integer.type(int)  Integer.class(java.lang.Integer)

      Class.forName();

22、如何唤起类中的一个方法?

产生一个Class数组,说明方法的参数

经过Class对象及方法参数获得Method

经过method.invoke(实例,参数值数组)唤醒方法

23、如何将数值型字符转换为数字(Integer,Double)?

Integer.parseInt(“1234”)

Double.parseDouble(“123.2”)

24、如何将数字转换为字符?

1+””

1.0+””

25、如何去小数点前两位,并四舍五入。

double d=1256.22d;

d=d/100;

System.out.println(Math.round(d)*100);

26、如何取得年月日,小时分秒?

Calendar c=Calendar.getInstance();

      c.set(Calendar.YEAR,2004);

      c.set(Calendar.MONTH,0);

      c.set(Calendar.DAY_OF_MONTH,31);

      System.out.println(c.get(Calendar.YEAR)+"  "+(c.get(Calendar.MONTH)+1)+"  "+c.get(Calendar.DAY_OF_MONTH));

27、如何取得从1970年到如今的毫秒数

Java.util.Date dat=new Date();

long now=dat.getTime();

28、如何获取某个日期是当月的最后一天?

当前日期加一天,若当前日期与结果的月份不相同,就是最后一天。

取下一个月的第一天,下一个月的第一天-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public  static  void  main(String[] args)
     {
        Calendarc=Calendar.getInstance();
        c.set(Calendar.YEAR, 2004 );
        c.set(Calendar.MONTH, 0 );
        c.set(Calendar.DAY_OF_MONTH, 30 );
        Calendarc1=(Calendar)c.clone();
        System.out.println(c.get(Calendar.YEAR)+ "  " +(c.get(Calendar.MONTH)+ 1 )+ "  " +c.get(Calendar.DAY_OF_MONTH));
         
        c.add(Calendar.DAY_OF_MONTH, 1 );
        if (c.get(Calendar.MONTH)!=c1.get(Calendar.MONTH))
        {
            System.out.println( "是最后一天" );
        }
        else
        {
            System.out.println( "不是取后一天" );
             
        }
     }


29、如何格式化日期?

Import java.text. SimpleDateFormat;

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-ddhh:mm:ss");

Date dat=new Date();

//把日期转化为字符串

String str=sdf.format(dat);

System.out.println(str);

//将字符串转化为日期

Java.util.Date d1=sdf.parse(“yyyy-mm-dd”);

30、编码转换,怎样实现将GB2312编码的字符串转换为ISO-8859-1编码的字符串。

String a=new String("中".getBytes("gb2312"),"iso-8859-1");

String a=new String("中".getBytes("iso-8859-1"));

32、String s = new String("xyz");建立了几个StringObject?

New了一个,”XYZ”原本又是一个

两个

33、float型floatf=3.4是否正确?

  报错,应当是float f=3.4f

  若是是float f=3(整数)正确

35、说出一些经常使用的类,包,接口,请各举5个

经常使用的类:BufferedReader BufferedWriter  FileReader  FileWirter String  Integer

经常使用的包:java.lang  java.awt  java.io java.util  java.sql javax.xmljavax.sevlet javax.ejb.  java.net  javax.faces

经常使用的接口: List  Map  Document NodeList EjbObject EjbHome SessionBean EntityBean

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

会。如:int i,i2;  return (i-i2);   //when i为足够大的正数,i2为足够大的负数。结果会形成溢位,致使错误。

37、java中实现多态的机制是什么?

      静态的多态:方法名相同,参数个数或类型不相同。(overloading)

      动态的多态:

             子类覆盖父类的方法,将子类的实例传与父类的引用调用的是子类的方法

             实现接口的实例传与接口的引用调用的实现类的方法。      

38、垃圾回收器的基本原理是什么?垃圾回收器能够立刻回收内存吗?有什么办法主动通知虚拟机进行垃圾回收?

动态内存

      存放类实例

静态内存

类自己

垃圾收集主要针对的是动态内存,通常当内存不够用时会进行垃圾收集。

或经过System.gc()手动收集,但不保证必定执行。

39、静态变量和实例变量的区别?

static i = 10; //常量

 class A a;  a.i =10;//可变

静态方法能够调用静态变量。

实现方法能够调用静态变量、实例变量

41、是否能够从一个static方法内部发出对非static方法的调用?

不能够,若是其中包含对象的method();不能保证对象初始化.

42、写clone()方法时,一般都有一行代码,是什么?

Clone 有缺省行为,super.clone();他负责产生正确大小的空间,并逐位复制。

43、JAVA语言如何进行异常处理,关键字:throws,throw,try,catch,finally分别表明什么意义?在try块中能够抛出异常吗?

Try:执行部分,产生异常

Catch:捕捉异常

Finally:无论有没有异常都执行

Throws:在方法声明处声明要抛出的异常,调用者必须对其进行处理。

Throw:抛出一个异常

在try中能够抛出异常,通常与声明的异常相同。

自定义异常要继承于Exception或Exception的子类

45、冒泡排序法

//相邻两个数比较,将最小或最大的放到后面,最后面数的不参与比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public  class  BubbleSort {
     private  static  int  al[] =  new  int [ 10 ];
     publicBubbleSort() {
        al[ 0 ]= 2 ;
        al[ 1 ]= 3 ;
        al[ 2 ]= 23 ;
        al[ 3 ]= 45 ;
        al[ 4 ]= 1 ;
        al[ 5 ]= 67 ;
        al[ 6 ]= 23 ;
        al[ 7 ]= 80 ;
        al[ 8 ]= 35 ;
        al[ 9 ]= 72 ;
     }
     public  static  void  main(String[] args) {
        BubbleSort bs =  new  BubbleSort();
        System.out.println( "排序前:" );
        display(al);
         
        for ( int  i= 0 ;i<al.length;i++) {
         
            for  ( int  j =  0 ; j < al.length-i- 1 ; j++) {
                
               if (al[j]>al[j+ 1 ]) {
                   swap(j,j+ 1 );
               }
            }
        }
        System.out.println();
        System.out.println( "排序后:" );
        display(al);
     }
     private  static  void  display( int [] al2) {
        for  ( int  i =  0 ; i < al2.length; i++) {
            System.out.print(al2[i]+ "  " );
        }
     }
     private  static  void  swap( int  i, int  j) {
        int  temp = al[i];
        al[i]= al[j];
        al[j] = temp;
     }
}


46、String and StringBuffer的区别?

String:长度给定不可变,当多个字符串联合时要先转为StringBuffer,再联合,速度慢。

StringBuffer:长度可变,能够将多个字符串值直接联合,效率高

47、用java代码编写堆栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public  class  Stack {
    
     int [] data;
     int  maxSize;
     int  top;
     public  Stack( int  maxSize) {
        this .maxSize = maxSize;
        data =  new  int [maxSize];
        top = - 1 ;
     }
      
     /**
      * 依次加入数据
      * @param data 要加入的数据
      * @return 添加是否成功
      */
     public  boolean  push( int  data) {
        if (top+ 1 == maxSize) {
            System.out.println( "栈已满!" );
            return  false ;
        }
        this .data[++top] = data;
        return  true ;
     }
      
     /**
      * 从栈中取出数据
      * @return 取出的数据
      */
     public  int  pop()  throws  Exception{
        if (top==- 1 ) {
            throw  new  Exception( "栈已空!" );
        }
        return  this .data[top--];
     }
      
     public  static  void  main(String[] args) throwsException {
        Stack stack= new  Stack( 1000 );
        stack.push( 1 );
        stack.push( 2 );
        stack.push( 3 );
        stack.push( 4 );
        stack.push( 5 );
        while (stack.top>= 0 )
        {
            System.out.println(stack.pop());
        }   
     }
}


48、集合的做用是什么?

数据的传送 增、删、改、查、constainsAll,能够存放不一样类型的对象。

49、集合的通用方法有那些?通用方法是什么?(操做)

集合List 的遍历方法有:

Iterator:

Enumeration

For

Get

set

Collection的通用方法有:

   Iterator()

   Add()

   Clear();

   remove()

 

50、说出ArrayList,Vector, LinkedList的存储性能和特性HashMap和Hashtable的区别

ArrayList Vector:以数组的方式存储,增、删慢,查、改快

   ArrayList:线程不安全,速度快

   Vector:线程安全,速度慢(synchoronized)

LikedList:以单链表的方式存储,增、删快,查、改慢

HashMap与Hashtable都实现的Map接口,HashTable线程安全,HashMap线程不安全。

51、Collection 和Collections的区别。

Collection是集合的根接口,其下有set及list

Collections是集合的算法。

52、Set里的元素是不能重复的,那么用什么方法来区分重复与否呢? 是用==仍是equals()? 它们有何区别?用contains来区分是否有重复的对象。仍是都不用。

在比较时先调用hashCode方法,若是不相同,证实不相等。

若是相同,再调用equals方法,若是equals方法相同,证实相等,不相同,证实不相等。

==:主要用在基本数据类型及引用

Equals:主要是对象或对象引用的比较。

集合中是否包含某一个元素用contains来判断。

53、List, Set, Map是否继承自Collection接口?

List,set继承于Collection

Map没有继承于Collection,其相对是独立的。

属于Collection类型的对象,能够经过构造函数将一个集合构形成另一个集合。

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

1.抽象:

   找共性,将共有的属性、方法放到父类中

2.继承:

   子类继承于父类,具备父类的全部属性与方法,能够重用,也能够覆盖。

3.封装:

   一个类包括多个属性及方法。

4. 多态性:

   动态:

   静态:

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

基本数据类型包括byte、int、char、long、float、double、boolean和short。

java.lang.String类是final类型的,所以不能够继承这个类、不能修改这个类。为了提升效率节省空间,咱们应该用StringBuffer类

56、int 和 Integer 有什么区别?

      Int是基本数据类型,不是对象,占一个内存空间,没有方法。与其同类的有long,char,doble

      Integer是封装类,具备方法及属性。与其同类的有Long,Double.Float

57、运行时异常与通常异常有何异同?

   运行时异常:java JVM抛出的异常,代码中不用处理。

   通常异常:用户抛出的异常,若是用throws 声明了,调用这个方法的代码必须对其处理。

58、&和&&的区别?

      &:与: 左边若为false右边还执行。

      &&:短路与,左边若为false右边不执行。

59、final, finally, finalize的区别?

final 用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。

finally是异常处理语句结构的一部分,表示老是执行。

finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,能够覆盖此方法提供垃圾收集时的其余资源回收,例如关闭文件等。

算符能够用来决定某对象的类是否实现了接口。

62、heap和stack有什么区别?

栈是一种线形集合,其添加和删除元素的操做应在同一段完成。栈按照后进先出的方式进行处理。

堆是栈的一个组成元素

63、Static Nested Class 和Inner Class的不一样?

Static Nested Class是被声明为静态(static)的内部类,它能够不依赖于外部类实例被实例化。而一般的内部类须要在外部类实例化后才能实例化。

64、何时用assert?

assertion (断言)在软件开发中是一种经常使用的调试方式,不少开发语言中都支持这种机制。在实现中,assertion就是在程序中的一条语句,它对一个boolean表达式进行检查,一个正确程序必须保证这个boolean表达式的值为true;若是该值为false,说明程序已经处于不正确的状态下,系统将给出警告或退出。通常来讲,assertion用于保证程序最基本、关键的正确性。assertion检查一般在开发和测试时开启。为了提升性能,在软件发布后,assertion检查一般是关闭的。

65、GC是什么? 为何要有GC?

GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会致使程序或系统的不稳定甚至崩溃,Java提供的GC功能能够自动监测对象是否超过做用域从而达到自动回收内存的目的,Java语言没有提供释放已分配内存的显示操做方法。

66、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

short s1 = 1; s1 = s1 + 1; (s1+1运算结果是int型,须要强制转换类型) short s1 = 1; s1 +=1;(能够正确编译)

67、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

Math.round(11.5)==12 Math.round(-11.5)==-11round方法返回与参数最接近的长整数,参数加1/2后求其floor.

68、Java有没有goto?

java中的保留字,如今没有在java中使用。

69、给我一个你最多见到的runtime exception

ArithmeticException, ArrayStoreException, BufferOverflowException,BufferUnderflowException, CannotRedoException, CannotUndoException,ClassCastException, CMMException, ConcurrentModificationException,DOMException, EmptyStackException, IllegalArgumentException,IllegalMonitorStateException, IllegalPathStateException, IllegalStateException,ImagingOpException, IndexOutOfBoundsException, MissingResourceException,NegativeArraySizeException, NoSuchElementException, NullPointerException,ProfileDataException, ProviderException, RasterFormatException,SecurityException, SystemException, UndeclaredThrowableException,UnmodifiableSetException, UnsupportedOperationException

通常异常:

   IOException

   FileNotFoundException

   SqlException

 

70、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

接口能够继承接口。抽象类能够实现(implements)接口,抽象类是否可继承实体类,但前提是实体类必须有明确的构造函数。任何抽象类都是实际类Object的子类。

71、abstract的method是否可同时是static,是否可同时是native,是否可同时是synchronized?

   都不能

72、数组有没有length()这个方法?String有没有length()这个方法?

      数组没有length()这个方法,有length这个属性

String有length()这个方法.

73、构造器Constructor是否可被override?

构造器Constructor不能被继承,所以不能重写Overriding,但能够被重载Overloading。

74、是否能够继承String类?

String类是final类故不能够继承。

75、swtich是否能做用在byte上,是否能做用在long上,是否能做用在String上?

switch(expr1)中,expr1是一个整数表达式。所以传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string都不能做用于swtich。

76、try {}里有一个return语句,那么紧跟在这个try后的finally {}里的code会不会被执行,何时被执行,在return前仍是后?

会执行,在return前执行。

77、编程题: 用最有效率的方法算出2乘以8等於几?

2 << 3

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

不对,有相同的hash code。

79、当一个对象被看成参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里究竟是值传递仍是引用传递?

是引用传递

基本数据类型:值

对象: 引用

80、四种会话跟踪技术

Cookie

Session

Hidden

url 重写

81、编程题: 写一个Singleton出来。

Singleton模式主要做用是保证在Java应用程序中,一个类Class只有一个实例存在。

通常Singleton模式一般有几种种形式:

第一种形式: 定义一个类,它的构造函数为private的,它有一个static的private的该类变量,在类初始化时实例话,经过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton {

private Singleton(){}

      //在本身内部定义本身一个实例,是否是很奇怪?

      //注意这是private 只供内部调用

      private static Singletoninstance = new Singleton();

      //这里提供了一个供外部访问本class的静态方法,能够直接访问  

      public static SingletongetInstance() {

        return instance;   

      }

   }

   第二种形式:

public class Singleton {

  private static Singleton instance = null;

  public static synchronized Singleton getInstance() {

  //这个方法比上面有所改进,不用每次都进行生成对象,只是第一次     

  //使用时生成实例,提升了效率!

  if (instance==null)

    instance=new Singleton();

return instance;   }

}

其余形式:

定义一个类,它的构造函数为private的,全部方法为static的。

通常认为第一种形式要更加安全些

83、Java中的异常处理机制的简单原理和应用。

原理

   有错直接转到异常处理部分或向上抛出。

应用:

JAVA的异常就是错误,有两种一种是运行时,编码能够不用捕捉。一种是通常异常,若是throws声明了,必须进行处理。

84、垃圾回收的优势和原理。并考虑2种回收机制。

优势:

   程序员不用管内存,jvm自动完成,开发方便。运行优先很是低,程序没法清楚实例何时被消毁。

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

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

86、char型变量中能不能存贮一个中文汉字?为何?

可以定义成为一个中文的,由于java中以unicode编码,一个char占16个字节,因此放一个中文是没问题的

88、写一个程序,从文件(c:\test.txt)中查出字符串”mobnet”出现的次数?

java基础类库(io流,集合类,线程,Socket,AWT,Swing,sql)

1、java中有几种类型的流?JDK为每种类型的流提供了一些抽象类以供继承,请说出他们分别是哪些类?

字节流,字符流。字节流继承于InputStream OutputStream,字符流继承于Reader Writer。在java.io包中还有许多其余的流,低层流与调层流,高层流主要是为了提升性能和使用方便。

2、启动一个线程是用run()仍是start()?

启动一个线程是调用start()方法,启动线程并调用run方法。

3、线程的基本概念、线程的基本状态以及状态之间的关系

线程是进程内的并发,没有自已内存空间,共享进程的,线程间的通讯成本较低。

Java中的线程有四种状态分别是:运行、就绪、挂起、结束。

4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么? 用什么关键字修饰同步方法? stop()和suspend()方法为什么不推荐使用?

1
2
3
4
5
6
7
8
9
10
11
12
Extends Thread
Implements Runnable
同步
Public  synchronized  aa()
{
}
Public  void  cc(object aa)
{
     synchronized (aa)
{
}
}


synchoronized修饰同步方法。

答:多线程有两种实现方法,分别是继承Thread类与实现Runnable接口

同步的实现方面有两种,分别是synchronized,wait与notify

反对使用stop(),是由于它不安全。它会解除由线程获取的全部锁定,并且若是对象处于一种不连贯状态,那么其余线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候,目标线程会停下来,但却仍然持有在这以前得到的锁定。此时,其余任何线程都不能访问锁定的资源,除非被"挂起"的线程恢复运行。对任何线程来讲,若是它们想恢复目标线程,同时又试图使用任何一个锁定的资源,就会形成死锁。因此不该该使用suspend(),而应在本身的Thread类中置入一个标志,指出线程应该活动仍是挂起。若标志指出线程应该挂起,便用wait()命其进入等待状态。若标志指出线程应当恢复,则用一个notify()从新启动线程。

5、集合框架有什么?

Collection                                                     Map

   List             set                                     HashMap

ArrayList  linkedList  HashSet TreeSet

12、设计4个线程,其中两个线程每次对j增长1,另外两个线程对j每次减小1。写出程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
public  class  TestThread
{
     private  int  j;
     public  synchronized  void  inc()
     {
        j++;
        System.out.println(Thread.currentThread().getName()+  "-inc:"  + j);
     }
     public  synchronized  void  dec()
     {
        j--;
        System.out.println(Thread.currentThread().getName()+  "-dec:"  + j);
     }
     public  static  void  main(String[]args)
     {
        TestThread t= new  TestThread();
        for  ( int  i =  0 ; i <  2 ; i++)
        {
            Thread inc= new  Thread(newInc(t));