阶段回顾

继承：
	1，提高了代码的复用性。
	2，类与类之间产生了关系，关系的出现，就是多态的由来。

	java只支持单继承，不支持不多继承。
	原因：当出现多个类中有相同方法时，子类不确定调用的是哪一个。
		其实就是父类中的方法有方法体。
	
	但是java支持多层继承。在多层继承中，父类定义都是共性成员。
	所体现的内容：
	  1，父类是不断向上抽取而来的。
	  2，既然父类体现的共性内容，那么在使用一个继承体系时，
		只需要查阅最顶层父类即可了解该体系的基本功能。(查阅API技巧之一)
	  3，只要建立最子类的对象即可对该继承体系进行应用。

	子父类的出现，子类因为持有一个父类引用super，可以获取到父类中非私有的成员。
	如同子类中也有一个份一样。

	覆盖（复写）override.  
	对于成员函数，当子父类中出现了一模一样的函数时，会出现一个覆盖操作。
	在运行时，会运行子类中的方法。
	覆盖注意：
	   1，子类覆盖父类方法，必须权限大于等于父类。
	   2，静态覆盖静态。
	   3，覆盖只发生在函数上。

	什么时候使用覆盖呢？
	   可以通过覆盖的形式对父类的功能进行重新定义。
	   比如：对功能进行修改或者对功能进行升级。
	注意：不要在子类中定义新功能。还要以父类中的声明为主。


	class Demo
	{
		void show()
		{
			System.out.println("Demo show");
		}
	}


	main()
	{
		//Demo d = new Demo();
		SubDemo d = new SubDemo();
		d.show();

	}

	二年后。
	为了提高可维护性。
	建立一个子类继承Demo，复写其中的某些需要修改的功能即可。
	class SubDemo extends Demo
	{
		void show()
		{
			System.out.println("subdemo show");
		}
	}


	super关键字:代表的父类应用。super的应用和this的使用完全一样。

	子类的实例化过程：
	子类中所有的构造函数回去访问父类中的空参数构造函数。
	那是因为：每一个子类构造函数中的第一行都有一个句隐式super()语句。
	原理：子类继承父类，获取获取到了父类中的成员，所以子类必须要先明确父类是如何对这些成员进行初始化的。
	如何父类中没有了空参数构造函数，需要在子类的构造函数通过super,或者this语句指定要访问的构造函数。

	
	什么时候使用继承呢？
		当类与类之间出现所属(is a)关系时，就使用继承。
		类中的所有成员是否可以被另一个类所以拥有.
		如果是继承.
		如果不是,看是否具备向上抽取的可能.
	
	class A
	{
		void method(){}
		void function(){}
	}

	有了一个B类，B中也需要一个method()方法。
	这时，是否可以用B继承A来获取这个方法呢？因为这样不是可以提高复用性吗？

	那么判断，B和A之间有所属关系吗？不会判断。
	这时，可以通过另一个方式，B是否应用具备A中所有功能？
	不是。B只需一个method()方法即可。不需要function()。这样就不需要继承。
	但是B中就会重复定义method()方法。
	那么A和B出现了共性的内容，就具备了向上抽取的内容。这时A和B就又出现一个父类C。

	class B
	{
		void method(){}
		void show(){}
	}

	所以最终设计：
	class C
	{
		void method(){}
	}
	class A extends C
	{
		void function(){}
	}
	class B extends C
	{
		void show(){}
	}

----------------------------------------------

final 关键字
	1，final可以修饰类，方法，变量。
	2，final修饰类不可以被继承，但是可以继承其他类。
	3，final修饰的方法不可以被覆盖，但可以覆盖父类方法。
	4，final修饰的变量包括成员变量，类变量，局部变量，这些变量只能赋值一次。
	5，内部类在局部时，只可以访问被final修饰的局部变量。
	通常规范中，被final修饰的变量是一个常量，常量名称所有字母大写。

-----------------------------------------------

抽象类：
	
	分析事物时，发现了共性内容，就出现向上抽取。
	会有这样一种特殊情况，就是功能声明相同，但功能主体不同。
	那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。
	那么该方法就是一个抽象方法。
	抽象方法的表现形式：abstract 返回值类型 函数名称(参数列表);
	抽象方法一定要存放在抽象类中。

	特点：
	抽象类不能用new进行实例化。
	想要创建对象，必须通过子类复写父类中所有的抽象方法后，该子类才可以创建对象。


	抽象类定义时，和一般类一样，都是在描述事物，只不过抽象类可以存放抽象方法，不可以建立对象。

	抽象方法的出现可以强迫子类去做某些事。

	例：学员类的例子。
	学员类的出现其实分析了现实生活中的学生而来的。
	张三：躺着睡觉，学习(总结式)
	李四：躺着睡觉，学习(机械式)

	abstract class 学员
	{
		void 睡觉(){躺着睡觉;}
		abstract void 学习();
	}

--------------------------------------------
接口：
	简单的理解成抽象类的特殊表现形式，当抽象类的方法全都是抽象的，那么这时就用接口来表示。

	特点：
	-- 接口是对外暴露的规则。
	-- 接口是功能的扩展。
	-- 接口的出现降低了耦合性。
	-- 在java中，多继承的机制被java通过另一种形式来体现，就是多现实。
	-- 在java中，一类可以继承一个类的同时，实现多个接口。
	例子：主板的pci接口。插座。笔记本电脑的usb接口。

	interface 抽烟
	{
		抽烟方法；
	}
	class 张三 extends 学员 implements 抽烟
	{
		void 睡觉(){躺着睡觉;}
		 void 学习(){}
		抽烟方法{}
	}


	接口中通常的定义的内容：
	1，全局常量。public static final 
	2，公有的抽象方法。 public abstract


	类与类之间是继承关系。
	类与接口之间是实现关系。
	接口与接口之间是继承关系，而且，接口之间存在多继承。