7.txt

该部分主要使关于corejava的基础知识

包装类：
	1）解决一些  基本类型取值问题 	：例如缺考的学生成绩不能处理为0（null）
	2）解决基本类型不能使用场合	：例如Collection中只允许放置引用类型
	3）实现基本类型和字符串的转换

			"" + (int)i + (float)f
		--------------------------------------------------------------------------->
		Integer.valueOf(int i)
		new Integer(int i)					toString()
	int------------------------------>Integer--------------------------------->String
	    <-------------------------------	      <-----------------------------------
	      (new Integer)intValue()                Integer.valueOf(String s) new Integer(String s) 
         
	    <-----------------------------------------------------------------------------
		  		Integer.parseInt(String i)


内部类：
	1）静态内部类 －》静态变量
		声明位置：类里面，方法外面；类前面有 static 修饰
		实例化形式： A.B b ＝ new A.B();A为外部类  B为内部类
		访问外部类：	a 直接访问静态变量静态方法
				b 先实例化外部类对象，再通过对象引用访问外部类实例变量，普通方法
		外部类访问内部类：通过类名直接访问静态变量。先实例化内部类对象，
				再通过对象引用访问内部类实例变量实例化形式：
		所允许内容：静态变量，静态方法，实例变量，实例方法
		

	2）成员内部类 －》实例变量
		声明位置：类里面，方法外面；类前面没有 static 修饰
		实例化形式：	A.B b = new A().new B();
				A.B b = this.new B();
		访问外部类：直接访问静态变量，静态方法；实例变量，普通方法
				注意：如内部类与外部类中变量同名
					访问形式：外部类名.this.变量名  或者 (new 外部类()).变量名
		外部类访问内部类：先实例化内部类，然后再访问
		所允许内容：实例变量，实例方法
		成员内部类不允许有静态变量和方法

	3）局部内部类 －》局部变量
		声明位置：方法里面
		实例化形式：在方法中 new 内部类名( )；
		访问外部类：直接访问静态变量(static 只能修饰实例变量)，静态方法；实例变量，普通方法
				访问 final 修饰的局部变量，方法参数
		外部类访问外部类：不能访问

	4）匿名内部类 －》只实例化一次     一般用来 重写类 或者 实现接口
		声明位置：方法中；只要能放变量的位置就能声明匿名内部类
		实例化形式：new 接口／抽象／类( ) ｛ ｝；{ }放类的内容
				new 接口（）｛｝；对接口的实现，new 的是接口的实现类，只是没类名而已

		Calendar c = Calendar.getInstance();
		System.out.println(c.getTime());//***********
		System.out.println(new Date());//***********
		//上面两行代码功能相同，都是获得系统当前时间

	接口			子接口		  具体实现类	
       Collection ---------->  set----------HashSet
		    |			  	  TreeSet
		    |				  LinkedHashSet
		    |			  	  SortedSet
		     |				  
		    ---------->  List---------ArrayList
						  Vector
	接口			具体实现类
	Map    --------------HashMap
	Map	

	set:	无序（放入的顺序和取值的顺序不相同），唯一；
	List:	有序，重复；
	Map:	按键值对形式存取内容；值可空，但键不可空

Collection接口中一些共有方法：
	public boolean add(E o);
	Iterator iterator();
		boolean hasNext();
		Object next();
	remove();
	int size();
	boolean remove(Object o);
	void clear();
	int size();

Map:	接口中一些共有方法：
	Object put(Object key,Object value)
	V remove(Object key)
	Collection<V> values()
	Set<K> keySet()
	Set entrySet()	
	//Map.Entry组成的 Set 集合  (Map.Entry) getValue()  getKey()

	V get(Object key)
	boolean containsKey(Object key)
	boolean containsValue(Object value)

	Set se = map.entrySet();//返回的是键值对 组成的 Set
		Iterator it = se.iterator();
		while(it.hasNext()) {
			Object o = it.next();//Map.Entry
			Map.Entry entry = (Map.Entry) o;
			System.out.println("key:" + entry.getKey()
					+ "\tvalue:" + entry.getValue());
		}

List:	有序，重复；    
	具体实现类 
	ArrayList 	线程不安全，效率比Vector高(一般使用ArrayList)
	Vector		（线程安全（同一时刻只能有一个线程访问），效率较差）

Set:	无序（放入的顺序和取值的顺序不相同），唯一；
	具体实现类 
	HashSet:按哈希算法决定对象在Set中存放的位置；
		先按hashCode()方法判断hash码值；
		进一步按 equals()方法判断
	LinkedHashSet:
	TreeSet:

	public interface List<E> extends Collection<E>
	public interface Set<E>  extends Collection<E>
	public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>

	//自然排序
	java.lang.Comparable (接口)
		abstract int compareTo(Object o);
		0  this == o
		1  this >  o
		-1 this <  o

	人工排序：
	java.util.Comparator(接口)
		abstract int compare(Object x,Object y);
			0  x==y
			1  x >y
			-1 x <y



反射：	（一般用来编写系统软件）
	（类加载的时候 －－堆区）获得类对应的 类对象（类的属性和构造方法） 的过程：（其中类对象的类型是：Class）
	以及通过类对象进一步获得属性，方法，构造方法并调用方法，获得属性值的过程
	例如：多个String 对象共享一个 String 类对象
	获得类对象：
	1）：Class c = Class.forName("java.lang.String");
	2）: 	String s = new String("acb");
		String s2 = new String("dfdf");
		Class c1 = s.getClass();
		Class c2 = s2.getClass();
		Class c3 = int.Class;//任何类型都有相应的类对象
		c2 == c2; //true 多个String 对象共享一个 String 类对象
	3）: Class c = String.class;
		Class c = Integer.class;
	实验：（Reflection.ClassTest.java）

	Class.getConstructors();获得所有访问权限为public 的构造方法

	Class.getDeclaredConstructors();获得所有构造方法

多层继承：
	interface A{}
	interface B{}
	interface C{}

	class MyClass implements A,B,C {
	}
	//多态的表现形式	
	class Test {
		A test = new MyClass();
		B b = (B)test;
		C c = (C)test;
	}

	String s1 = new String("abc");	//永久字符串
	String s2 = new String("abc");	
	String s3 = "abc";			//规范字符串
	String s4 = "abc";
	如果两个String对象是通过快捷初始化用相同的字符串直接构造的，JVM为了提高效率
	将它们存储在同一对象中。这样的字符串称为规范字符串。可以使用String对象的intern方法
	返回一个规范字符串，这种字符串与使用快捷初始化创建的字符串相同

	public final class String

	System.out.println(s1 == s2);//false  s1 , s2指向两个不同内存的引用
	System.out.println(s3 == s4);//true   s3 , s4这种初始化方式，
		虚拟机在内存池中找是否有相同的内容，如果有，则允许多个对象共享那片内存	

interface Map {
	........................
	static interface Entry {
		Object getKey();
		Object getValue();
	}
}