java基础知识回顾

一.作用域public,private,protected,以及不写时（friendly）的区别

答：区别如下：
作用域           当前类       同一package  子孙类       其他package
public            √                             √                  √             √
protected        √                           √                  √             ×
friendly          √                             √                   ×            ×
private           √                              ×                   ×            ×

二.内部类

分为成员内部类(member inner class)、静态成员内部类(static)、局部内部类(local)、匿名内部类(anonymous)

A、成员内部类

1.在类内定义接口时，事实上是一个静态成员类，static对于内部接口是内含的(implicit)

2.想要获得所属外部类

OutClass.this

B、静态成员内部类

1.不能从静态内部类中一个对象访问另外一个外部类对象

2.只能访问外部类静态对象

3.生成一个静态内部类不需要外部类。如：

Outer.Inner in = new Outer.Inner();

4.当同时继承、实现同一个方法名时

package Inner;

public class StaticTest {
class People{
	public void run(){
		System.out.println("People run~~");
		
	}
}

interface Machine{
	void run();
}

class Robot extends People{
	private class MachineHeart implements Machine{

		@Override
		public void run() {
			System.out.println("Machine run~~~");
		}
		
	}
	
	public void run() {
		System.out.println("People extends run~~");
	}
	Machine getMachine(){
		return new MachineHeart();
	}
}
public static void main(String[] args) {
	StaticTest.Robot robot = new StaticTest().new Robot();
	robot.run();
	robot.getMachine().run();
}
}

结果显示：People extends run~~
Machine run~~~

C、局部类

1.对于一个成员类,将定义移入其外部类的实例方法或实例初始化代码中就成了局部成员。

2.内部类只在定义它的代码段中可见，不能在它所属代码段之外代码中使用

3.没有public/private/default权限修饰符(无意义)

package Inner;

public class LocalTest {
private int instaceField=0;
private static int staticField=1;
{
	int localValue1=0;
	final int localValue2=1;
	class Inner1{
		public Inner1(){
		instaceField=1;
		LocalTest.this.staticField=2;
//		System.out.println(localValue1);//不能调用非final字段
		System.out.println(localValue2);
		}
	}
//	public class inner2{}//不能被修饰

}
 
static{
	class Inner2{
		public Inner2(){
			
//			instaceField=1;//不能调用实例级
			staticField=2;
			
			
		}
	}
	
}

public void instanceMethod(){
	class Inner3{
		
	}
//	LocalTest.Inner2 inner2//只能被所包含块可见
}

public static void staticMethod(){
	class Inner4{
		public Inner4(){
			
			staticField=2;
		}
	}
//	interface l{}
}


}

D、匿名内部类

无类名的局部类

1.只需要一个实例，代码紧凑的时候使用

package Inner;

public class AnonymousTest {
	interface Action{
		void doAction();
	};
public void instanceMethod(){
	Action action=new Action(){
		@Override
		public void doAction(){
			System.out.println("inner");
		}
		
	};
}
}

三、什么时候用assert

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

四、ceil和floor

package Math;

public class floor {
public static void main(String[] args) {
	System.out.println(Math.floor(11.5)+"  " +Math.floor(-11.5));
	System.out.println(Math.ceil(11.5)+"  " +Math.ceil(-11.5));
	System.out.println(Math.round(11.5)+"  " +Math.round(-11.5));
}
}

结果：

11.0  -12.0
12.0  -11.0
12  -11

五、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;（可以正确编译）

六、给我一个你最常见到的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

七、error和exception有什么区别

答：error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况
    exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况

八、抽象类是否可继承实体类(concrete class)？

抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数

九、是否可以继承String类

答：String类是final类故不可以继承

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

答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的

十一、ArrayList和Vector的区别,HashMap和Hashtable的区别

答：就ArrayList与Vector主要从二方面来说.
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value 

十二、谈谈final, finally, finalize的区别

final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）

finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的

十三、HashMap和Hashtable的区别

答：HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。 
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。 
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

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

答：当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

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

答：不可以,如果其中包含对象的method()；不能保证对象初始化.

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

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

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

答：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

ps：

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

十八、简述synchronized和java.util.concurrent.locks.Lock的异同 ？

答：主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。