java小笔记(一）

1. 对象的引用存放在堆栈中，对象本身存放在堆中；常量代码通常存放在程序代码内部；有时，在嵌入式系统中，常量部分和其它部分隔离开，此时，可选择存放在ROM中；基本数据类型的变量直接存储值，并置于堆栈中，这样更高效。
2. 类库是一组类文件，其中每个文件都有一个public类，以及任意数量的非public类。
3. 一个Java源文件可以包含多个类文件，但至多只有一个public类，可以没有public类，如果有public类的话，public类必须与该源文件名一致。如果源文件内无public修饰的类，则该源文件可以任意命名，但此时该类里面的main方法会失效。
4. 使用package语句时，它必须是程序中除注释以外的第一句程序代码。
5. final关键字
   对于基本数据类型，final使其数值不变，而对于引用，final使该引用不变，但该引用指向的对象本身可以改变。
   final域：被final修饰的成员变量，该成员变量在声明的时候被初始化，或是在每个构造方法中为该成员变量初始化。
   空白final：被final修饰的字段未被初始化称其为空白final，此时必须在每个构造方法中为该成员变量初始化。
   final参数：参数列表中的参数被指明为final，此时无法在方法中更改参数引用指向的对象。
   final方法：被final修饰的方法无法被覆盖。
   final类：被final修饰的类无法被继承。
   类的private方法也是隐式的指定为final的，所以private方法无法被覆盖。
6. 重载（overload）与重写（覆盖、覆写override）：重载发生在一个类内，指一个方法名字可以有多个方法体，但是方法的参数必须不同；重写指父类和子类之间的关系，子类重新写了父类的一个方法称为重写。
   
7. 将一个方法调用和方法主体联系起来被称为绑定。若在程序执行之前绑定叫做前期绑定。对应的叫做后期绑定，它的含义是运行是根据对象的类型进行绑定，后期绑定也叫做动态绑定、运行时绑定或晚绑定。Java中除了static方法和final方法为前期绑定，其他所有方法都是后期绑定。
8. 只有普通的方法调用可以是多态的，域和静态方法都不具有多态性。

   public class Test
   {
   	public static void main(String[] args)
   	{
   		Super sup = new Sub();
   		System.out.println("sup.field = " + sup.field + "; sup.getField() = "
   				+ sup.getField());
   		Sub sub = new Sub();
   		System.out.println("sub.field = " + sub.field + "; sub.getField() = "
   				+ sup.getField() + "; sub.getSuperField() = "
   				+ sub.getSuperField());
   	}
   }
   
   class Super
   {
   	public int field = 0;
   
   	public int getField()
   	{
   		return field;
   	}
   }
   
   class Sub extends Super
   {
   	public int field = 1;
   
   	public int getField()
   	{
   		return field;
   	}
   
   	public int getSuperField()
   	{
   		return super.field;
   	}
   }
   //输出结果
   sup.field = 0; sup.getField() = 1
   sub.field = 1; sub.getField() = 1; sub.getSuperField() = 0

9. 构造方法是隐式的static方法。
10. 接口里面的域是public static final的，方法是public的。
11. 一个类可以extends一个类（java是单继承的）implements多个接口（先extends，后implements）。一个接口可以extends多个接口。
12. 内部类有四种：嵌套类（静态内部类）、成员内部类（像成员变量一样）、局部内部类（在方法内定义，不能有修饰符public，protected,private,static，像局部变量一样，在局部内部类中要想访问方法中的变量，该变量必须是final的）和匿名内部类。
13. 当生成一个内部类的对象的时候，此对象与生成它的外围类的对象之间就有了某种联系，所以它能访问外围对象的所有成员，而不需要任何特殊条件。内部类拥有其外部类的所有元素的访问权限。所以一个内部类嵌套多少层不重要，它能透明的访问所有它所嵌入的外围类的所有成员而不需要任何特殊条件。
14. 在内部类里访问外部类对象与对本身的对象的访问（假设外部类Outer，内部类Inner）：访问外部类的对象Outer.this；访问内部类对象this。
15. 匿名内部类一定没有构造器。
16. 如果一个匿名内部类希望它使用一个在其外部定义的对象，那么必须要求其参数引用是final的。对于非匿名的内部类没有此要求。如下：

    interface A{};
    
    class TestA{
           //s必须加final修饰，因为在匿名内部类里面使用了它
          public A createA(final String s){
                 return new A(){
                          String str = s;
                    };
          }
    }

17. 普通内部类与嵌套类的区别：
    普通内部类隐式的保存了一个指向创建它的外围类的对象的引用，而嵌套类（也叫静态内部类）就没有此引用。
    嵌套类对象不能访问外围类的对象，也不能从嵌套对象中访问非静态的外围类对象。
    普通内部类不能有static成员变量，也不能有static方法，更不能有嵌套类，但是嵌套类可以包含这些东西。
18. 正常情况下，不能在接口中放置任何代码，但嵌套类可以作为接口的一部分，放在接口中的任何类都是public static的。可以在嵌套类中实现接口中的方法。

    interface A
    {
    	void method();
    	class Test implements A
    	{
    		@Override
    		public void method()
    		{
    			System.out.println("method.");
    		}
    		public static void main(String[] args)
    		{
    			new Test().method();
    		}
    	}
    }

19. 内部类使得一个类可以“多继承”，在外围类继承一个类，在内部类中继承其他想要继承的类。
20. 内部类的构造必须连接到外围类的引用，在继承内部类的时候，那个指向外围类的引用必须被初始化。
    

    class WithInner
    {
    	class Inner
    	{
    	}
    }
    class InheritInner extends WithInner.Inner
    {
    	//InheritInner(){}，这个构造器无效
    	InheritInner(WithInner wi)
    	{
    		wi.super();//必须有引用指向外围类的对象的引用，这样程序才能通过编译
    	}
    }

21.  对于异常处理的finally语句，无论涉及continue、break还是return语句，都会进入到finally语句。