一切都是对象

一、java存储在什么地方
程序运行时，内存是怎么分配，对象存储的位置，这些了解有助于学习java编程。
1、寄存器，最快速的存储区，因为位于处理器内部，但其数量有限，而且不能直接控制，所以java对象不会在这一区域。
2、堆栈，位于RAM中，但通过堆栈指针可以从处理器获得直接支持，java系统必须知道存储在堆栈内所以项的确切生命周期，以便于移动堆栈指针。堆栈指针向上移动，释放内存，向下移动分配内存，其效率仅此于寄存器。（java对象的引用、基本数据类型存储在此区域）
3、堆，位于RAM中，一种通用的内存池，用于存放所以的java对象。当使用new的时候便会在此区域分配需要大小的内存空间。
4、常量存储。常量值通常直接存储于程序代码内部，因为他永远不会被改变。
5、非RAM存储，把数据存储在外部，不受程序控制，程序没有运行也是可以存在。（持久化对象、流对象）
二、基本类型
因为通过new将对象存储在堆中，因为创建简单变量不是非常有效，对于这些简单类型，java不是采用new的方式，而是创建一个并非引用的“自动”变量，这个变量直接存储“值”，并且位于堆栈中，以提高效率。

package com.javabase.study.javaBaseType;
/**
 * java 基本数据类(值存储位置为堆栈)，每个基本类型都有对应的包装类型
 * 其中boolean和void没有定义大小空间，boolean仅定义可以存储false和true的大小
 * 类的基本类型变量创建对象时候会自动初始化默认值，防止错误产生。局部变量则可能得到任何值，不会进行初始化，因此必须初始化在使用。
 * BigInteger和BigDecimal为高精度数字，这个两个数字类可以保证数据的准确性，其余以损失精度换取速度
 * @author shining
 *
 */
public class BaseDataType {
	private int i;//0
	private boolean b;//false
	private char c;//'\u0000'(null)
	private byte by;//(byte)0
	private long l;//0l
	private short s;//(short)0
	private float f;//0.0f
	private double d;//0.0d
	public static void main(String[] args) {
		BaseDataType base=new BaseDataType();
		System.out.println(base.i);
		System.out.println(base.b);
		System.out.println(base.c);
		System.out.println(base.by);
		System.out.println(base.l);
		System.out.println(base.s);
		System.out.println(base.f);
		System.out.println(base.d);
	}
}

三、类复用

package com.javabase.study.extend;
/**
 * java类复用有两种形式：1、组合(导出类好引用基类)2、继承
 * 继承：初始化基类分为两种：1、默认构造器2、有参构造器，此时必须通过super来调用。初始化顺序为基类到导出类。
 * @author shining
 *
 */
public class JavaExtends extends BoardGame {

	JavaExtends(int i) {
		super(i);
		System.out.println("JavaExtends Constructor");
	}
	public static void main(String[] args) {
		new JavaExtends(0);
	}

}
class Game{
	Game(int i){
		System.out.println("Game Constructor"); 
	}
}
class BoardGame extends Game{

	BoardGame(int i) {
		super(i);
		System.out.println("BoardGame constructor");
	}
}

四、final关键字

package com.javabase.study.finalKeyWord;

import java.util.Random;
/**
 * final数据：1、一个永不改变的编译时常量2、一个在运行时被初始化的值，而不希望它改变。
 * 编译期常量必须是基本数据类型，且关键字是final。
 * java允许空白final，声明为final但未给定初始化值，但编译器确保空白final在使用前必须被初始化。
 * @author shining
 *
 */
@SuppressWarnings("unused")
public class FinalData {
	private static Random random=new Random();
	private final int one=10;//编译期常量
	private static final int TOW=12;//编译期常量
	private final int three=random.nextInt();//运行期常量
	public static final int FOUR=random.nextInt();//运行期初始化常量(加载时初始化)
	private final int blankFinal;//空白final
	public FinalData(int blankFinal) {
		this.blankFinal = blankFinal;//对象创建时初始化
	}
	public FinalData() {
		this.blankFinal=0;//对象创建时初始化
	}
}

五、java多态特性
多态(动态绑定、后期绑定、运行时绑定)：发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。
绑定：将一个方法调用同一个方法主体关联起来。
前期绑定：在程序执行前进行绑定（由编译器进行绑定）。
动态绑定：运行时会传递某种类型信息，已便运行时候能找到对应的方法体。
java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。
JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针：　　一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）；　　另一个指针指向一块从java堆中为分配出来内存空间。　　The Java Virtual Machine does not require any particular internal structure for objects. In Sun 's current implementation of the Java Virtual Machine, a reference to a class instance is a pointer to a handle that is itself a pair of pointers: one to a table containing the methods of the object and a pointer to the Class object that represents the type of the object, and the other to the memory allocated from the Java heap for the object data. （jvm规范中关于对象内存布局的说明）
六、ListIterator

package com.javabase.study.lists;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.ListIterator;

/**
 * List迭代器，与Iterator不同的是，只能作用于List，并且可以双向迭代。
 * @author shining
 *
 */
public class ListIterators {
	public static void main(String[] args) {
		List<Integer> list=new ArrayList<Integer>(Arrays.asList(1,2,3,4,5,6,7,8,9,0));
		ListIterator<Integer> it=list.listIterator();
		while(it.hasNext()){//
			System.out.println("向后1："+it.next());
		}
		while(it.hasPrevious()){
			System.out.println("向前2："+it.previous());
		}
		it=list.listIterator(3);//从第四个元素开始迭代，并且只能使用一次
		while(it.hasNext()){
			System.out.println("向后3："+it.next());
		}
		//it=list.listIterator(5);如果没有重新给it确定迭代起始位置，那么将会是list全部元素。
		while(it.hasPrevious()){
			System.out.println("向前4："+it.previous());
			it.set(10);
		}
		System.out.println(list);
	}

}

七、Foreach

package com.javabase.study.lists;

import java.util.Iterator;

/**
 * 通常for each作用于数组和Collection。
 * Java SE5中添加一个Iterable接口，该接口包含产生Iterator的iterator(),
 * 并且Iterable被foreach用来在序列中移动。因此实现Iterable的类，都能使用for each。
 * 数组可以用for each，但是其不是Iteable实现。
 * @author shining
 *
 */
public class ForEach implements Iterable<String>{
	private String[] words={"and","that","is","how","we","know","the","earth","to","be"};

	public Iterator<String> iterator() {
		return new Iterator<String>(){//匿名类
			private int index=0;
			public boolean hasNext() {
				return index<words.length;
			}

			public String next() {
				return words[index++];
			}

			public void remove() {

			}

		};
	}
	public static void main(String[] args) {
		for(String s: new ForEach()){
			System.out.println(s);
		}
	}
}

八、Exception中finally的使用
finally无论程序正常执行，还是遇到异常，return，break，continue都会被执行。

package com.javabase.study.Exception;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * Throwable表示任何可以作为异常被抛出，分为两种类型：
 * 1、Error用来表示编译时和系统错误
 * 2、Exception代表可以抛出异常的基本类型。
 * 构造器异常处理基本规则：在创建需要清理对象之后，立即进入一个try-finally语句块。
 * @author shining
 *
 */
public class ConstructorException {
	public static void main(String[] args) {
		try {
			//构造器可能抛出异常，此时不用关闭流
			BufferedReader reader=new BufferedReader(new FileReader("D:\\text.jav"));
			try {
				//business deal with
			} catch (Exception e) {
				System.out.println("other exception");
			}finally{
				try {
					reader.close();//此时流是已经打开了必须关闭。
				} catch (Exception e) {
					System.out.println("close unsuccess");
				}
			}
		} catch (Exception e) {
			System.out.println("FileNotFound");
		}
	}

}

九、Class对象

package com.javabase.study.classLoader;

import java.util.Random;

/**
 * 类是程序的一部分，每个类都有一个Class对象（在编译时期产生Class对象，保存在同名的.class文件中）
 * 构造方法都static方法。
 * 类加载过程：
 * 1、加载：由类加载器执行，查找字节码，并且创建一个Class对象。
 * 2、链接：验证字节码，为静态域分配空间，解析类创建对其他类的所有引用。
 * 3、初始化：如果具有超类，则对其初始化，执行静态初始化器和静态初始化块。
 * .class的引用不会初始化Class对象，forname()会进行初始化。
 * 使用newInstance创建对象，必须带有默认构造器(可用)。
 * 编译期常量无需进行类初始化就能直接访问，但是如果仅是静态变量，就会对类进行初始化Initable2.STATIC_FINAL
 * @author shining
 *
 */
@SuppressWarnings({"unused","unchecked"})
public class ClassLoaders {
	public static Random rand=new Random(47);

	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		Class initable=Initable.class;//不会进行初始化，因此不会输出静态块中的语句
		//initable.newInstance();如果默认构造器是private的就无法进行创建。
		System.out.println("After creating Initable ref");
		System.out.println(Initable.STATIC_FINAL);
		System.out.println(Initable.STATIC_FINAL2);
		System.out.println(Initable2.staticFinal);
		Class initable3=Class.forName("com.javabase.study.classLoader.Initable3");//进行初始化，输出静态块中的语句
		System.out.println("After creating initable3 ref");
		System.out.println(Initable3.STATIC_FINAL);
	}

}
class Initable{
	static final int STATIC_FINAL=47;
	static final int STATIC_FINAL2=ClassLoaders.rand.nextInt(1000);
	static{
		System.out.println("Initalizing Initable");
	}
	//Exception in thread "main" java.lang.IllegalAccessException: 
	//Class com.javabase.study.classLoader.ClassLoaders can not 
	//access a member of class com.javabase.study.classLoader.Initable with modifiers "private"
//	private Initable() {
//	}
}
class Initable2{
	static  int staticFinal=147;
	static{
		System.out.println("Initalizing Initable2");
	}
}
class Initable3{
	static final int STATIC_FINAL=74;
	static{
		System.out.println("Initalizing Initable3");
	}
}