java学习笔记，自己有时间就整理的，有错的地方请指出来

虽然自己非常喜欢C++，但是发现现在好像单单会C++还不够，而且自己有对移动应用开发很感兴趣，所以想做android开发，所以java还是得学习好的，就此设立此笔记一篇，不间断整理。。。。。。。

1.System.out.println()是会打出来一个回车的

2.接口和抽象类的区别：

         接口和抽象类是非常相像的,但它们之间是有区别的,主要区别有以下几方面。一个类可以实现众多个接口,但是只能继承一个抽象类。可以说接口是取消程序语言中的多继承机制的一个衍生物,但它不完全如此。

         抽象类可以有非抽象方法,即可以有已经实现的方法,继承它的子类可以对方法进行覆写;而接口中定义的方法必须全部为抽象方法。

         在抽象类中定义的方法,它们的修饰符可以是 public、protected、private,也可以是默认值;但是在接口中定义的方法全是 public 的。

         抽象类可以有构造函数,接口不能。两者都不能实例化,但是都能通过它们来存放子类对象或是实现类的对象。可以说它们都可以实现多态。

3.内部类只共宿主类使用，内部类分为静态内部类和非静态内部类，非静态内部类可以调用其宿主类的所有变量和方法,并且像宿主类的其他非静态成员那样直接引用它们。静态内

部类不能直接访问其宿主类的成员,而必须通过对象来访问。对于宿主类访问内部类的成员变量,静态内部类的静态变量可以直接用“类名.变量名”来调用,对于静态内部类的非静态变量则要生成它的对象,利用对象来访问。非静态内部类中不包含静态变量,所以必须用非静态内部类的对象来访问。

4.//对象克隆的方法

public Object clone() {
Human h=null;
try {
h= (Human)super.clone();//此处要有强制类型转换
}
catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return h;
}

4.成员变量的继承，4种修饰符

      对于 public 的成员变量,它的任何子类都可以继承它。

      对于protected 类型的变量它的子类可以访问,不管该子类与父类是否处于同一个包内

      对于默认修饰符,包外的子类是不能访问它的,包内类可以继承

      对于 private 类型的成员变量,任何子类都是不能继承的,它是类私有的。      

5。printStackTrace()方法是一个很有用的方法，该方法将在 Throwable 类中定义,它的作用是把 Throwable 对象的堆栈信息输出至输出流。举个例子

public class DBDemo {

      public static void main(String[ ] args) {

      Class.forName("");

       }

}

程序在编译的时候会发生如下错误。DBDemo.java:4: 未报告的异常 java.lang.ClassNotFoundException;必须对其进行捕捉或声明以便抛出

                                                      Class.forName("");

                                                                               ^

1 错误

ClassNotFoundException 是检查异常,必须对其进行捕获异常,示例如下。

public class DBDemo {
public static void main(String[ ] args) {
try
{
Class.forName("");
}
catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}

程序编译通过,运行时屏幕显示如下。

java.lang.ClassNotFoundException:

at java.lang.Class.forName0(Native Method)

at java.lang.Class.forName(Unknown Source)

at DBDemo.main(DBDemo.java:5)

catch 语句捕获了产生的异常,并把异常信息打印出来。

6.Java 线程并不能按调用顺序执行,而是并行执行的单独代码。

所以调用集成Thread类，并且重写run()方法后，新建超过两个线程，并且调用start方法开始运行线程，这几个线程的执行顺序是不确定的

顺便介绍一下两种创建线程的方法，继承Thread类和实现Runnable接口：

继承Thread类：



实现Runnable接口：



7.synchronized，notify和wait的使用方法

参照博客：http://blog.csdn.net/zyplus/article/details/6672775

8.

当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：

class Foo implements Runnable
{
private byte[] lock = new byte[0];  // 特殊的instance变量
Public void methodA()
{
synchronized(lock) { //… }
}
//…..
}

一个知识点：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

9.程序运行时,对象是怎么进行放置安排的呢?特别是内存是怎样分配的呢?对这些方面的了解会对你有很大的帮助。有六个不同的地方可以存储数据:

1. 寄存器(register)。这是最快的存储区,因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量极其有限,所以寄存器由编译器根据需求进行分配。你不能直接控制,也不能在程序中感觉到寄存器存在的任何迹象。

2. 堆栈(stack)。位于通用 RAM(random-access memory,随机访问存储器)中,但通过它的“堆栈指针”可以从处理器那里获得直接支持。堆栈指针若向下移动,则分配新的内存;若向上移动,则释放那些内存。这是一种快速有效的分配存储方法,仅次于寄存器。创建程序时,Java 编译器必须知道存储在堆栈内所有数据的确切大小和生命周期,因为它必须生成相应的代码,以便上下移动堆栈指针。这一约束限制了程序的灵活性,所以虽然某些 Java 数据存储于堆栈中——特别是对象引用,但是 Java 对象并不存储于其中。

3. 堆(heap)。一种通用性的内存池(也存在于 RAM 区),用于存放所有的 Java 对象。堆不同于堆栈的好处是:编译器不需要知道要从堆里分配多少存储区域,也不必知道存储的数据在堆里存活多长时间。因此,在堆里分配存储有很大的灵活性。当你需要创建一个对象时,只需用 new 写一行简单的代码,当执行这行代码时,会自动在堆里进行存储分配。当然,为这种灵活性必须要付出相应的代价。用堆进行存储分配比用堆栈进行存储存储需要更多的时间(如果确实可以在 Java 中像在 C++中一样用栈保存对象)。

4. 静态存储(static storage)。这里的“静态”是指“在固定的位置”(尽管也在 RAM 里)。静态存储里存放程序运行时一直存在的数据。你可用关键字 Static 来标识一个对象的特定元素是静态的,但 Java 对象本身从来不会存放在静态存储空间里。

5. 常量存储(constant storage)。常量值通常直接存放在程序代码内部,这样做是安全的,因为它们永远不会被改变。有时,在嵌入式系统中,常量本身会和其它部分隔离开,所以在这种情况下,可以选择将其存放在 ROM(read-only memory,只读存储器)中。

6. 非 RAM 存储(non-RAM storage)。如果数据完全存活于程序之外,那么它可以不受程序的任何控制,在程序没有运行时也可以存在。其中两个基本的例子是“流对象(streamed object)”和“持久化对象(persistent object)。在“流对象”中,对象转化”成字节流,通常被发送给另一台机器。在“持久化对象”中,对象被存放于磁盘上,因此,即使程序终止,它们仍可以保持自己的状态。这种存储方式的技巧在于:把对象转化成可以存放在其它媒介上的事物,在需要时,可恢复成常规的、基于 RAM
的对象。Java 提供对轻量级持久化(lightweight persistence)的支持,未来的 Java 版本可能会为持久化提供更全面的解决方案。

10. protected方法对同包中的类是可见的,这点很多人都不知道