本文来自http://blog.csdn.net/liuxian13183/ ，引用必须注明出处！

OO与PO:面向对象(Object Oriented)与面向过程(Procedure Oriented)

前者面向对象，首先构造一个对象，然后设置对象方法，最后由对象来处理任务，只关注结果。

后者面向过程，首先设置对象的方法，然后排序，最后一步步执行下来完成任务，注重顺序。

程序运行时，对象是怎么进行安排的？特别是内存是怎样分配的呢？有五个不同的地方可以存储数据：

1、寄存器。最快存储区，位于处理器内部，数量有限，按需分配，不受控制。使用句柄（引用类型和引用地址）来操作内存。

2、栈。位于RAM(Random Access Memory - 随机访问存储器)，通过指针从处理器获得直接支持，内存分配有效性仅次于寄存器；向下移则分配新内存，向上移则释放内存。

3、堆。一种通用内存池（同上位于RAM中），用于存放所有对象，比前者好处是：编译器不需要知道存储数据在堆的存活时间，性比较高，但存储分配和清理会比前者花费更多时间。

4、常量。通常直接存放在程序代码内部，是安全的，永远不会被改变的。嵌入式系统经常把它放在ROM(Read Only Memory)只读存储器里。

5、非RAM存储。数据完全存活于程序之外，不受程序控制，没有程序也照样可以存在，是一种聚合关系，如写在SD卡上的数据。

BigInteger和BigDecimal主要用来表示任意高精度的integer和double数据，商业大数据如阶乘。转化最后用String来表示原始数字，否则会损失精度，而且比较大小也要用compareTo而非equals。由于计算一次就生成一个对象，所以一般的计算建议还用基本数据类型来做。

一个方法里面如String s=new String("str");在方法结束后，s是要消失的，但它声明的对象还留在内存中，由垃圾回收器进行集中管理。

javac编译生成.class文件，java执行让classloader加载class输入执行结果

注意引用与数据是两个概念，不能划等号

位操作符，&同为1则为1否则为0，|有一个为1则为1，同为0才为0

移位操作符，“<<”左移低位补0；“>>"右移 符号为正则高位插入0，为负高位插入1；">>>"无符号右移，无论正负高位插入0；移动赋值如">>="。所以">>与">>>"的区别仅在于负数。

Enum枚举类型，jdk1.5出现，本身是一个类，内部值均为public final static 的，可以方便的用来存储基本数据类型的键值。

匿名内部类的两种实现方式，一种定义抽象类，一种定义接口。

同时注意，内部类中使用的形参必须是final的，因为要跟主类数据同步。

	public static void main(String[] args) {
		Goose goose = new Goose() {

			@Override
			void eat() {
				// TODO Auto-generated method stub
				System.out.println("抽象类goose");
			}
		};
		goose.eat();

		IGoose goose2 = new IGoose() {

			@Override
			public void eat() {
				// TODO Auto-generated method stub
				System.out.println("接口goose");
			}
		};
		goose2.eat();
	}

	static abstract class Goose {
		abstract void eat();
	}

	interface IGoose {
		void eat();
	}

升级排序的应用，Comparable和Comparator，以及Collections.sort和Arrays.sort的使用。

Comparable：应用于类内部，实现此接口，可以直接使用Collections.sort(list)

Comparator：应用于类外部，声明接口，使用Collections.sort(list,comparator)

Arrays.sort应用于数组排序。

	static class Student {
		public int age;
		public String name;

		public Student(int age, String name) {
			super();
			this.age = age;
			this.name = name;
		}

		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return name + "\t" + age + "岁";
		}
	}

	static class Teacher implements Comparable<Teacher> {
		public int age;
		public String name;

		public Teacher(int age, String name) {
			super();
			this.age = age;
			this.name = name;
		}

		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return name + "\t" + age + "岁";
		}

		@Override
		public int compareTo(Teacher teacher) {
			// TODO Auto-generated method stub
			if (this.age > teacher.age) {
				return 1;
			}
			if (this.age < teacher.age) {
				return -1;
			}
			return 0;
		}
	}

	private static void testStudent() {
		System.out.println("testStudent");
		List<Student> list = new ArrayList<>();
		list.add(new Student(18, "A"));
		list.add(new Student(11, "B"));
		list.add(new Student(18, "C"));
		list.add(new Student(19, "D"));
		Collections.sort(list, new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				// TODO Auto-generated method stub
				if (o1.age > o2.age) {
					return 1;
				} else if (o1.age < o2.age) {
					return -1;
				}
				return 0;
			}
		});
		list.forEach(stu -> {
			System.out.println(stu.toString());
		});
	}

	private static void testArray() {
		System.out.println("testArray");
		String[] array = { "BB", "CC", "AA" };
		Arrays.sort(array);
		for (String str : array) {
			System.out.println(str);
		}
	}

	private static void testTeacher() {
		System.out.println("testTeacherList");
		List<Teacher> list = new ArrayList<>();
		Teacher a = new Teacher(118, "AA");
		list.add(a);
		Teacher c = new Teacher(119, "CC");
		list.add(c);
		Teacher b = new Teacher(111, "BB");
		list.add(b);

		Collections.sort(list);

		System.out.println("a 大于 b:" + (a.compareTo(b) == 1));

		list.forEach(stu -> {
			System.out.println(stu.toString());
		});
	}

	public static void main(String[] args) {
		testStudent();
		testArray();
		testTeacher();
	}

testStudent
B 11岁
A 18岁
C 18岁
D 19岁
testArray
AA
BB
CC
testTeacherList
a 大于 b:true
BB 111岁
AA 118岁
CC 119岁