java小知识点--面试很有用

1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？.

可以，但是只能有一个public类 而且如果有public类的话，这个文件的名字要和这个类的名字一样

2、Java有没有goto?.

Goto—java中的保留字，现在没有在java中使用

3、&和&&的区别？

       &和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。

&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str != null && !str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException如果将&&改为&，则会抛出NullPointerException异常。&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。

4、在JAVA中如何跳出当前的多重嵌套循环?

//种方式采用自定义的变量(Boolean值),并配合break使用

boolean flag = false;
for (int j = 0; j < 2 && !flag; j++)
for (int i = 0; i < 100; i++) {
if (i == 10) {
flag = true;
break;
} else
System.out.print(i + " ");
}
}
}

 

5、switch语句能否作用在byte上，能否作用在long上，能否作用在String上?.
byte可以

long不行

jdk1.7中String可以

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

前面一个需要类型转换是s1+1类型成为int了  后面一个没有错误（1.7）

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

CHAR类型变量时能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

8、用最有效率的方法算出2乘以8等於几?

用移位法2 左移3位 就是乘以8 即  2<<3

9、请设计一个一百亿的计算器.

首先要明白这道题目的考查点是什么，一是大家首先要对计算机原理的底层细节要清楚、要知道加减

法的位运算原理和知道计算机中的算术运算会发生越界的情况，二是要具备一定的面向对象的设计思想。

首先，计算机中用固定数量的几个字节来存储的数值，所以计算机中能够表示的数值是有一定的范围

的，为了便于讲解和理解，我们先以byte 类型的整数为例，它用1个字节进行存储，表示的最大数值范围

为-128到+127。-1在内存中对应的二进制数据为11111111，如果两个-1相加，不考虑Java运算时的类型提

升，运算后会产生进位，二进制结果为1,11111110，由于进位后超过了byte 类型的存储空间，所以进位部

分被舍弃，即最终的结果为11111110，也就是-2，这正好利用溢位的方式实现了负数的运算。-128 在内存

中对应的二进制数据为10000000，如果两个-128相加，不考虑Java运算时的类型提升，运算后会产生进位，

二进制结果为1,00000000，由于进位后超过了byte类型的存储空间，所以进位部分被舍弃，即最终的结果

为00000000，也就是0，这样的结果显然不是我们期望的，这说明计算机中的算术运算是会发生越界情况

的，两个数值的运算结果不能超过计算机中的该类型的数值范围。由于Java中涉及表达式运算时的类型自

动提升，我们无法用byte类型来做演示这种问题和现象的实验，大家可以用下面一个使用整数做实验的例

子程序体验一下：

int a = Integer.MAX_VALUE;
int b = Integer.MAX_VALUE;
int sum = a + b;
System.out.println(“a=”+a+”,b=”+b+”,sum=”+sum);

 

先不考虑long类型，由于int的正数范围为2的31次方，表示的最大数值约等于2*1000*1000*1000，

也就是20亿的大小，所以，要实现一个一百亿的计算器，我们得自己设计一个类可以用于表示很大的整数，

并且提供了与另外一个整数进行加减乘除的功能，大概功能如下：

（）这个类内部有两个成员变量，一个表示符号，另一个用字节数组表示数值的二进制数

（）有一个构造方法，把一个包含有多位数值的字符串转换到内部的符号和字节数组中

（）提供加减乘除的功能

public class BigInteger
{
int sign;
byte[] val;
public Biginteger(String val)
{
sign = ;
val = ;
}
public BigInteger add(BigInteger other)
{
 
}
public BigInteger subtract(BigInteger other)
{
}
public BigInteger multiply(BigInteger other)
{
}
public BigInteger divide(BigInteger other)
{
}
}

 

备注：要想写出这个类的完整代码，是非常复杂的，如果有兴趣的话，可以参看jdk 中自带的

java.math.BigInteger 类的源码。面试的人也知道谁都不可能在短时间内写出这个类的完整代码的，他要的

是你是否有这方面的概念和意识，他最重要的还是考查你的能力，所以，你不要因为自己无法写出完整的

最终结果就放弃答这道题，你要做的就是你比别人写得多，证明你比别人强，你有这方面的思想意识就可

以了，毕竟别人可能连题目的意思都看不懂，什么都没写，你要敢于答这道题，即使只答了一部分，那也

与那些什么都不懂的人区别出来，拉开了距离，算是矮子中的高个，机会当然就属于你了。另外，答案中

的框架代码也很重要，体现了一些面向对象设计的功底，特别是其中的方法命名很专业，用的英文单词很

精准，这也是能力、经验、专业性、英语水平等多个方面的体现，会给人留下很好的印象。

10、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

是指引用变量不能变。引用变量所指向的对象的内容还是可以变的。

例如下面代码编译通不过

final StringBuffer a = new StringBuffer("immutable");
                   a = new StringBuffer("");

  11、"=="和equals方法究竟有什么区别？

== 操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只 能用==操作符。如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如 Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量 是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。

equals()方法是用 于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。

12、静态变量和实例变量的区别？

类的静态变量在内存中只有一个，java虚拟机在加载类的过程中为静态变量分配内存，静态变量位于方法区，被类的所有实例共享。静态变量可以直接通过类名进行访问，其生命周期取决于类的生命周期。

而实例变量取决于类的实例。每创建一个实例，java虚拟机就会为实例变量分配一次内存，实例变量位于堆区中，其生命周期取决于实例的生命周期

13、是否可以从一个static方法内部发出对非static方法的调用？

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部发出对非static方法的调用。

14、Integer与int的区别.

int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。

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

12  -11  -12

16、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型? 构造器Constructor是否可被override?.

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。Overloaded的方法是可以改变返回值的类型。构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

17、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？.

接口可以继承接口。抽象类可以实现(implements)接口，抽象类是可以继承具体类。抽象类中可以有静态的main方法。

记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法

18、写clone()方法时，通常都有一行代码，是什么？.

clone 有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

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

1.抽象：

抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

2.继承：

继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

3.封装：

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

4. 多态性：

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

20、java中实现多态的机制是什么？

方法的重写Overriding和重载Overloading是Java多态性的不同表现.，重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现.

21、abstract class和interface有什么区别?

  含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。

含有abstract方法的类必须定义为abstract class，abstract class类中的方

法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)

子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有

实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须

是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量

类型默认为public static final。

下面比较一下两者的语法区别：

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，

   不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public，protected和默认类型，但接口中的抽象方法只能是public类型的，

    并且默认即为public abstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问

     类型可以任意，但接口中定义的变量只能是public static final类型，并且默认

     即为public static final类型。

7. 一个类可以实现多个接口，但只能继承一个抽象类。

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

抽象方法不可被上述三个中的任意一个修饰，抽象方法只能被public或protected修饰，其他修饰符皆不可以。

 

23、什么是内部类？Static Nested Class 和 Inner Class的不同。

 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象 

package my;

/**  
*  
* 普通内部类持有对外部类的一个引用， 静态内部类却没有  
*  
* @author howard  
*/
public class Test {

	/*
	 * this is static nested class
	 */
	private static class StaticNestedClass {
		private void yell() {
			System.out.println(this.toString());
			// OutterClass.this.yell();//静态内部类实例没有外部类实例的引用
		}
	}

	/*
	 * this is inner class
	 */
	private class InnerClass {
		private void yell() {
			System.out.println(this.toString());
			Test.this.yell();// 内部类实例显式使用外部类实例的方式
		}
	}

	private void yell() {
		System.out.println(this.toString());
	}

	private void run() {
		/*
		 * this is local class
		 */
		class LocalClass {
			public void yell() {
				System.out.println(this.toString());
			}
		}
		/*
		 * this is anonymous class
		 */
		new Object() {
			public void yell() {
				System.out.println(this.toString());
			}
		}.yell();
		LocalClass lc = new LocalClass();
		InnerClass ic = new InnerClass();
		StaticNestedClass sc = new StaticNestedClass();
		lc.yell();
		ic.yell();
		sc.yell();
	}

	public static void main(String[] args) {
		StaticNestedClass sc = new StaticNestedClass();
		sc.yell();
		Test oc = new Test();
		oc.run();
	}
}

 仔细分析如上代码，可以得出一个结论，所有的内部类，Local内部类，匿名内部类都可以直接访问外面的封装类的实例变量和方法。而静态嵌套类则不能。

　　调试代码可以发现，内部类，Local内部类，匿名内部类的实例都持有一个外部封装类实例的隐式引用;

　　而java对象序列化要求对象里所有的对象成员都实现序列化接口。

　　所以，如果只有内部类实现序列化，而外部封装类没有实现序列化接口，就会在对内部类进行序列化的时候报出异常。

24、内部类可以引用它的包含类的成员吗？有没有什么限制？

 

完全可以。如果不是静态内部类，那没有什么限制！ 
	如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员

25、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)？

不可以继承其他类

 

package my;

public class Test {

  
    public static void main(String[] args){
        InnerTest it = new InnerTest();
        TestEntity te = it.getTestEntity(2);
        System.out.println(te.getI());
    }
    
}

class TestEntity {// 超类
    private int i ;
    
    public TestEntity(int i ){
        this.i = i;
    }
    
    
    public int getI(){
        return i;
    }
}

class InnerTest{//用于测试内部类
    
    public TestEntity getTestEntity(int i){
        return new TestEntity(i){//创建Anonymous Inner Class 调用父类的构造方法
            //虽然不能继承其他类 但是实际这个TestEntiy的子类
            @Override
            public int getI(){//重写父类方法
                return super.getI()*10;
                
            }
        };
    }
    
}

 26、运行时异常与一般异常有何异同？

Java提供了两类主要的异常:运行时异常runtime exception和一般异常checked exception。checked 异常。对于后者这种异常，JAVA要求程序员对其进行catch。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常

运行时异常我们可以不处理。这样的异常由虚拟机接管。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

27、error和exception有什么区别?....

Error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

Exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

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

Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。

  Java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常

29、请写出你最常见到的5个runtime exception。

ClassCastException  ArithmeticException NullPointerException StringIndexOutOfBoundsException  NegativeArraySizeException

30、Java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？

有两种实现方法，分别是继承Thread类与实现Runnable接口

用synchronized关键字修饰同步方法

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

31、sleep() 和 wait() 有什么区别?

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。   

31、同步和异步有何异同，在什么情况下分别使用他们？举例说明。

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

32当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法? 

1.其他方法前是否加了synchronized关键字，如果没加，则能。

2.如果这个方法内部调用了wait，则可以进入其他synchronized方法。

3.如果其他个方法都加了synchronized关键字，并且内部没有调用wait，则不能。

4.如果其他方法是static，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是this

33、HashMap和Hashtable的区别.

1、 继承和实现区别

　　Hashtable是基于陈旧的Dictionary类，完成了Map接口；HashMap是Java 1.2引进的Map接口的一个实现（HashMap继承于AbstractMap,AbstractMap完成了Map接口）。

　　2、 线程安全不同

　　HashTable的方法是同步的，HashMap是未同步，所以在多线程场合要手动同步HashMap。

　　3、 对null的处理不同

　　HashTable不允许null值(key和value都不可以),HashMap允许null值(key和value都可以)。即 HashTable不允许null值其实在编译期不会有任何的不一样，会照样执行，只是在运行期的时候Hashtable中设置的话回出现空指针异常。 HashMap允许null值是指可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。

　　4、 方法不同

　　HashTable有一个contains(Object value)，功能和containsValue(Object value)功能一样。

　　5、HashTable使用Enumeration，HashMap使用Iterator。

6、HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。

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

Java 语言是一种具有动态性的解释型编程语言，当指定程序运行的时候， Java 虚拟机就将编译生成的 . class 文件按照需求和一定的规则加载进内存，并组织成为一个完整的 Java 应用程序。 Java 语言把每个单独的类 Class 和接口 Implements 编译成单独的一个 . class 文件，这些文件对于 Java 运行环境来说就是一个个可以动态加载的单元。正是因为 Java 的这种特性，我们可以在不重新编译其它代码的情况下，只编译需要修改的单元，并把修改文件编译后的 . class 文件放到 Java 的路径当中， 等到下次该 Java 虚拟机器重新激活时，这个逻辑上的 Java 应用程序就会因为加载了新修改的 .class 文件，自己的功能也做了更新，这就是 Java 的动态性

35、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？.

对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。