第八章

第八章 多态

一般方法都是用基类做参数，然后在方法体内实例化成子类，但是当调用的是父类的域和静态方法时，就不是多态了。eg：

Class Super{
   public int filed = 0;
}
class Sub{
	public int filed = 1;
}
class FA{
	public static void main(String[] args){
	Super sup = new Sub();
	syso(sup.i);//print:0
}
}

在调用类构造器之前，类中的所有对象都初始化为默认初始值。eg：

public class A {
	A(int i){
		method1();//这里调用的是b中的method1
		System.out.println("A");
	}
	public void method1(){
		System.out.println("method1 in A");
	}
}

public class B extends A {
	Test t;
	final int i;
	int n = 3;
	
	B(){
		super(11);
		i=1;
		System.out.println("B");
	}
	
	@Override
	public void method1() {
		// TODO Auto-generated method stub
		System.out.println(t);
                System.out.println("n="+n);
	}

	public static void main(String[] args) {
		B b = new B();
                //syso:null ,n = 0,A,B 注意：这里t还没被初始化，n也是默认初始值0而不是3
	}
	
}

第九章接口

抽象类：包含一个活多个抽象方法的类。抽象类的导出类可以不实现基类的抽象方法，但是此导出类必须定义为抽象。定义没有任何抽象方法的抽象类也是可以的。抽象的目的只是为了让这个类不能被实例化。

接口不仅仅是一个极度抽象的抽象类，它还允许人们通过创建一个能够被向上转型为多种基类的类型来实现多重继承的特性。接口的域都是final和static的。接口中的类都是public的，即使不声明为public。接口继承接口用extends关键字而不是implement，这时候，extends后面可以用“，”分隔多个接口。

第十章内部类

如果想在外部类的非静态方法之外的任意位置创建某个内部类对象，那么必须具体地指明这个内部类的对象的类型：OuterClassName.InnerClassName x = getInstence();

第十一章持有对象

Arrays.aslist()方法可接收数组、用逗号分隔的对象等参数，返回一个list。但是返回的这个list不能调用add()方法添加元素，这样会报运行时错误，编译器检查不出来。eg：

public static void test() {
		List<Integer> list1 = Arrays.asList(1,2,3,4);
		list1.add(9);//运行时错误
		list1.set(1, 3);//right  can modify
 for(int i : list1){System.out.println(i);}}public static void main(String[] args) {test();}

通过此方法初始化一个list时，里面的元素必须是泛型或者其直接子类型，间接子类型是不能加入的，这时候必须在asList()前面加入泛型说明，eg：

public class ArraysasList {
	public static void main(String[] args) {
                //List<A> listA = Arrays.asList(new B(),new D());  编译时错误，因为D不是A的直接子类
		List<A> listA = Arrays.<A>asList(new B(),new D());//加入泛型说明后正常编译
	}
}
class A{}
class B extends A{}
class C extends A{}
class D extends B{}
class E extends B{}

List普通容器，按添加顺序插入对象；Set插入对象不能重复；HashXXX(XXX为Map、Set等容器)是获取元素最快的方式，TreeXXX是按对象顺序排列后的容器

ArrayList和LinkedList优劣：ArrayList，长于随机访问，但是在List中间插入和移除元素比较慢；LinkedList，在List中间插入和移除对象的代价很低，但随机访问对象比较慢。

迭代器可以对方法屏蔽掉容器的具体类型，也就是在方法中用迭代器代替容器类型，客户端程序员就不必知道容器的类型，这样的方法更加通用。迭代器统一了对容器的访问方式，都是通过itor.next()方法访问。

第十三章字符串

string对象是不可变对象:即string类中任何看起来会修改string值得方法，实际上都是创建了一个新的string对象，最初的string对象丝毫没变。eg：

public static String upcast(String s){
		return s.toUpperCase();
	}
	public static void main(String[] args) {
		String s = "fxh love ssy";
		String s1 = upcast(s);
		System.out.println(s);//out.print:fxh love ssy;
		System.out.println(s1);//out.print:FXH LOVE SSY;
	}

jvm对字符串的简单“+”操作进行了优化 eg:

String mango = "mango";
String s = "abc" + mango + "def" + 47;

我们使用javap -c命令能够看到jvm自动为我们创建了一个stringbuilder对象，然后调用append方法将后面的mango、def、47等字符进行连接，返回的是stringbuilder的tostring。但是当我们在循环中调用字符串的“+”操作时，jvm的优化就不如直接使用stringbuilder那么高效了 eg

public String implicit(String[] fields){
		String result = "";
		for(int i = 0;i < fields.length;i ++){
			result += fields[i];
		}
		return result;
	}
	public String explicit(String[] fields){
		StringBuffer result = new StringBuffer();
		for(int i = 0;i < fields.length;i ++){
			result.append(fields[i]);
		}
		return result.toString();
	}

使用javap -c可以看到，implicit方法中，当每次进入for循环时，jvm都创建了一个新的stringbuilder，所以在涉及到字符串拼接时，最好直接使用stringbuffer或者stringbuilder