1. 初始化

public class testclass {

	private static int count = 0;

	public testclass() {
		System.out.println(count++);

	}

}

public static void main(String[] args) {

		for (int i = 0; i < 10; i++) {
			testclass aa = new testclass();
		}

	}

打印结果为：0~9。这样可以做对象创建计数器。

9.尽量构造器只做初始化工作，避免调用其他方法。

比如一个继承类，父类初始化的时候调用了一个自身的方法，这个方法子类覆盖重写了并且使用了子类的成员变量。这是调用这个方法由于多态就调用到子类去了，在这个父类初始化时子类的成员变量并没有初始化，所以可能导致出现不是预料的效果。

         10.垃圾回收。

         1.对象可能不被垃圾回收。2.垃圾回收并不等于c++的"析构"。3.垃圾回收也是需要开销的，不使用就不需要这部分开销。

2.复用类

1.组合语法。

将对象引用置于新类中。其实就是通过引用对象组合成新类的某个功能，其实感觉没啥意思，用过都明白。

2.继承语法：

每创建一个新类总是在继承，最基础是集成Objcet。只有protected方法与public方法可以继承。

2.1 为了继承，一般规则是将所有数据成员变量设置为private，将所有方法设置为public。protected权限的方法只能子类使用，private权限的方法只能给当前类使用。没有任何权限修饰的，默认是包访问权限。

2.2 super关键字表示超类的意思。

2.3 当创建一个子类的时候，该子类对象包含了一个基类的子对象。该子对象与你用基类对象创建的对象的一样的。二者区别在于，后者来自内部，而基类的子对象被包装在子类的对象内部。构建可以看成由内到外扩散，所以先调用父类构造器再调用子类构造器。

2.4 在子类的构造器做的第一件事就是调用父类的构造器，现在如果不写也可以，默认调用了。

2.5 is-a 关系是用继承来表达，has-a关系是用组合来表达。如果需要向上转型那么继承是必要的，否则要好好考虑清楚是否需要继承。

2.6 允许向上转型的原因：导出类是基类的一个超集，它可能比基类含有更多的方法 ，但它必须具备基类中所含有的方法。在向上转型的过程中，接口类中唯一可能发生的事情是丢失方法，而不是获取它们。

2.7  final关键字：1.在对常量进行定义时必须要对其进行赋值。2.对于基数类型，final使数值 恒定不变，而对于对象引用，final使引用恒定不变，就是无法将其改为指向另一个引用，但是对象自身却是可以被修改的。3.允许空白final，就是定义了却没有初始化，但是使用前必须初始化final。 4.final参数，意味着无法在方法中更改参数引用所指向的对象。 final方法，用于禁止覆盖。 5.类中所有的private方法都隐式的指定为final的。由于无法取用private方法，所以也就无法覆盖它。可以对private方法添加final修饰，但并不能给该方法增加任何额外意义。 6.final类，用于禁止被继承。

2.8  继承类满足协变返回类型，就是比如子父类的一个方法中返回的是一个父类A类型，那么子类覆盖这个方法后可以返回的是那个父类A的子类类型。

2.9 向上转型导致导出类中的拓展部分不能被基类使用。 向下转型如果转型失败就会抛出异常。

3.0代理：其实也是通过组合的形式，通过代理对象获取到控制对象引用实现指定功能，好处是只需要跟代理沟通，不需要暴露控制对象。

3.1protected权限，子类以及同一个包内的类都可以访问。

3.2多态性是指允许不同类的对象对同一消息作出响应，多态性存在的必要条件：要有继承、要有重写、父类引用指向子类对象。将一个方法与方法主体关联起来称为绑定，java中的所有方法都是通过动态绑定实现多态的，面向过程语言默认的是前期绑定，在多态中同一个对象主体调用方法，如何知道是调用子类的方法还是父类的方法，解决方法就是动态绑定（后期绑定），除了static与final方法，其他都是动态绑定，所以final方法不能实现重写。动态绑定的调用只在运行时才知道。

构造器都是隐式static，所以不具有多态性，构造器初始化是从内到外也就是从父类到子类，所以一般都在自己的构造器初始化自己的成员变量。每个类必须有构造器，至少有默认一个，编辑器会强制子类必须调用基类构造器。。

public class Parent {

    public Parent() {

        changeNum();
    }
    public void changeNum(){
    }
}

public class Child extends Parent{
    public int num = 10;
    @Override
    public void changeNum() {
        super.changeNum();
        num = 100;
        System.out.println("changeNum in child ,num = "+num);
    }
    public void see(){
        System.out.println("num = "+num);
    }
}

public class JavaTest {
    public static void main(String[] s) {
        Child child = new Child();
        child.see();
    }
}

changeNum in child ,num = 100
num = 10

3.接口

1.抽象类的作用：希望通过这个通用接口操纵一系列类。包含抽象方法的类叫抽象类，如果一个类包含一个或者多个抽象方法，该类必须限定为抽象的。

2.如果两个接口有完全相同的方法或者方法名称相同但是参数不同，完全相同的方法时，implement他们时只创建一个方法，如果参数不同的就所有方法都创建。如果两个接口有相同方法名与参数但是返回值不同，这样是不能通过编译的，不允许这样。

3.接口都是隐式static的。

4.接口方法都是默认public的，不加public也行。

5.接口允许创建一个能够被向上转型为多种基类的类型，来实现某种类似多继承的特性，因为接口可以多实现。

6.

4.内部类

1.实例化

内部类的意义：1.弥补不能多继承的不足。2.通过内部类实现闭包会更灵活更安全（让内部类实现通用接口，然后引用将内部类对象向上转型为接口类型，避免了具体实现接触），实现更好的封装。

如果想从外部类的非静态方法之外的任意位置创建某个内部类对象，那么必须具体的指明这个对象的类型，比如外部类类里面有一个内部类,实例化一个内部类类的时候，这样做：

public class OutClass  {
	public  class InnerClass{//内部类
		
	}

}

	OutClass outclass = new OutClass();
	OutClass.InnerClass innerclass = outclass. new InnerClass();

如果没有外部类的实例就不能创建内部类实例，这是因为内部类对象会暗暗地连接到创建它的外部类对象上，这是为什么它能够访问到外部类的方法与字段。但是如果是静态内部类，那么就不需要对外部类的引用。

public class OutClass  {
	public static  class InnerClass{//静态内部类
		
	}

}

OutClass outclass = new OutClass();
	OutClass.InnerClass innerclass =  new  OutClass.InnerClass();

方法或者域里面也可以创建内部类，这个比较有意思，比较避免其他使用。

3.嵌套类

public class OutClass {

	public void methode1() {// 外部类已经有一个方法，所以不好直接实现接口Ia,可以使用内部类的方式

	}

	private class IaImp implements Ia {

		@Override
		public void methode1() {
		}

	}

	public Ia getIa() {// 通过一个钩子获取对这个接口的引用
		return new IaImp();
	}

}

5.持有对象

1.集合的关系图以及集合的区别。

1.1  List：

定义：A List is a collection which maintains an ordering for its elements. Every element in the List has an index. Each element can thus be accessed by its index, with the first index being zero. Normally, Lists allow duplicate elements, as compared to Sets, where elements have to be unique.

特点：1.有序

    2.每个元素有下标index

    3.可以通过index获取到元素

    4.开始index为0

    

说明：ArrayList is an implementation of List, backed by an array. All optional operations including adding, removing, and replacing elements are supported. All elements are permitted, including null.

 

特点：1.允许空元素

说明：LinkedList可以看做为一个双向链表，所有的操作都可以认为是一个双向链表的操作，因为它实现了Deque接口和List接口。同样，LinkedList也是线程不安全的，如果在并发环境下使用它，同样用Colletions类中的静态方法synchronizedList()对LinkedList进行调用即可。

特点：1.允许空元素

    2.线程不安全

    3.中间插入与删除是廉价的

    4.可以当成queue，queue也是在它的基础上增加了一些方法而已

   

特点：1.访问速度快

            2.线程不安全

注：Hashtable与 HashMap类似,它继承自Dictionary类，不同的是:它不允许记录的键或者值为空;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了 Hashtable在写入时会比较慢

  保存了记录的插入顺序、在用Iterator遍历LinkedHashMap时、先得到的记录肯定是先插入的.也可以在构造时用带参数、按照应用次数排序、在遍历的时候会比HashMap慢，不过有种情况例外，当HashMap容量很大，实际数据较少时，遍历起来可能会比LinkedHashMap慢，因为LinkedHashMap的遍历速度只和实际数据有关，和容量无关，而HashMap的遍历速度和他的容量有关

TreeMap：

能够把它保存的记录根据键排序,默认是按键值的升序排序、也可以指定排序的比较器、当用Iterator 遍历TreeMap时、得到的记录是排过序的

如下例子：

public static void main(String[] args) {

		TreeMap<Integer, Integer> treeMap = new TreeMap<>(new Comparator<Integer>() {

			@Override
			public int compare(Integer arg0, Integer arg1) {

				return arg0 - arg1;
			}

		});

		Random random = new Random();

		for (int i = 0; i < 20; i++) {

			treeMap.put(random.nextInt(100), i);
		}
		System.out.println(treeMap.toString());

	}

打印结果如下：

{0=0, 10=7, 15=2, 19=19, 21=6, 23=9, 24=3, 27=5, 28=12, 35=16, 36=13, 46=15, 50=17, 65=4, 66=18, 72=1, 83=8, 88=10, 97=14}

1.3 set:

  特点：1.不允许重复元素   2.运行有null但只允许一个  

 Hashset提供最快的访问速度，TreeSet保持元素处于排序状态，LinkedHashSet以插入顺序保存元素。set中最常用被使用的是测试归属性，查询某个对象是否在某个set中。也可以用set来去除重复元素。

      先进先出容器，队列在并发编程中特别重要。Linkedlist、hashset、treeset实现了queue接口，可以向上转型为queue。

PriorityQueue：优先级队列是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。可以通过comparator修改顺序。

转载务必注明出处：http://blog.csdn.net/u014614038/article/details/51939413