面向对象高级

继承；

	继承是Java面向对象技术的一块基石，因为它允许创建分等级层次的类;
	继承就是子类继承父类的特征和行为，使得子类对象(实例)具有父类的实例和方法，或子类从父类继承方法，使得子类具有父类相同的行为;

继承的限制：

	 Java中只有单继承、多重继承，没有多继承;

super：

 在一个类里面，通过super来操作它的父类;

	 通过super：可以访问父类的构造方法；
			调用构造方法的的代码，必须写在子类构造方法的第一行；	这时，super就表示被自动创建的父类对象；
	 通过super：可以访问父类的属性；
	 通过super：可以访问父类的方法

重写与重载：

	重写用于子类调用父类方法时，因为这个方法不适用，需要子类重新编写这个方法；在调用时，直接使用重写的方法；

重写与重载的区别：

	*发生位置
		重写发生在子父类中，
		重载发生在一个类中；
	
	*参数列表、返回值类型
		重写的参数列表、返回类型必须相同；
		重载的参数列表必须不同，与返回类型无关；
	
	*访问权限
		重写的子类访问权限不能低于父类访问权限
		重载与访问权限无关；

	*异常处理
		重载：与异常无关
		重写：异常范围可以更小，但不能抛出新的异常

Final关键字：

final 用于修饰属性、变量
	
	* 变量成为了常量，无法对其再次进行赋值；
	
	* final修饰的局部变量，只能赋值一次（可以先声明再赋值）
	
	* final修饰的成员变量，必须先赋值
	
	* 全局变量（public static final）

常量的命名规范：

	由一个或多个单词组成，单词之间必须使用下划线隔开，单词中所有字母大写
 	例如：“SOL_INSERT”

final用于修饰类：

	final 修饰的类不能被继承

final用于修饰方法：

	final修饰的方法，不能被子类重写

抽象类：

	必须使用abstract class 声明；

	一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或者接口中；

	格式：

		abstract class 类名{

		}

抽象方法：

	只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体），抽象方法必须使用abstract 关键字声明；

	格式：

		abstract class 类名{    //抽象类

		public abstract void 方法名();   // 抽象方法，只声明而未实现

		}

不能被实例化：

	抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。

	一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须重写抽象类中的所有抽象方法。

常见问题：

	1. 抽象类能否使用final声明？

		不能，因为final属修饰的类是不能有子类的，而抽象类必须有子类才有意义；

	2. 抽象类能否有构造方法？

		能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是先调用父类中的构造方法（默认为无参的），之后再调用子类自己的构造方法；

抽象类与普通类的区别：

	1. 抽象类必须使用public 或 protected 修饰（如果private 修饰，则子类无法继承，无法实现其抽象方法）；
	
	2. 抽象类不可以使用new关键字创建对象，但是子类创建对象时，抽象父类也会被JVM实例化；
	
	3. 如果一个子类继承抽象类，name必须实现其所有的抽象方法，如果未实现的抽象方法，那么子类必须定义为abstract 类；

接口：

	如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。

	格式：

		interface 接口名称{

			全局常量；	

			抽象方法；

		}

面向接口编程思想：

	1. 降低了程序的粘合性；
	2. 易于程序的扩展；
	3. 有利于程序的维护；

接口的实现 implements ：

接口可以多实现：

	格式1：

		class 子类 implements 父接口1 ， 父接口2 ...{

		}

	如果一个类既要实现接口，又要继承抽象类的话，则按照以下格式：

	格式2：

		class  子类 extends 父类 implements 父接口1 ， 父接口2 ...{

		}

	接口的继承：

	接口因为是抽象部分，不存在具体的实现，所以允许多继承，例如：

		interface C extends A,B{

		}

注意：

	如果一个接口想要使用，必须依靠子类，子类（不是抽象类的话）要实现接口中的所有抽象方法；

接口与抽象类的区别：

	1. 抽象类要被子类继承，接口要被类实现;
	
 	2. 接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法;
 	
	3. 接口里定义的变量只能是公共的静态的常量（public static final),抽象类中的变量时普通变量;
	
	4. 抽象类使用继承（extends) 来使用，无法多继承；接口使用实现 (implement) 来使用，可以多实现;
	
 	5. 抽象类中可以包含static方法，但是接口中不允许。（静态方法不能被子类重写，因此接口中不能声明静态方法）;
 	
	6. 接口中不能有构造方法，但是抽象类可以有;

多态：

	就是对象的多种形态；
	
	对象的多态。在子、父类中，子类就是父类的一种形态;
	
	方法的重载 和 重写 也是多态的一种：不过是方法的多态，相同方法名的多种形态。

		重载：一个类中的方法的多态性体现
		重写：子父类中的方法的多态性体现

instanceof 使用：

	用来判断传入值的类型；

Object类

	Object 类是所有类的父类，如果一个类没有的继承某一个具体的类，则将默认继承Object类。

	例如：

	我们定义的一个类：

		public class Person{

		}

	其实被使用时，是这样的：

		public class Person extends Object{

		}

	Object 可以接收任意的引用数据类型；

tostring方法：

	建议重写Object 的 tostring 方法，

	作用：返回对象的内存地址（内存内容）；

eqauls( ) 区别：

	对于equals方法，建议重写Object 的equals 方法，

	作用：两个对象是否相等；

注意：

	如果没有重写equals 方法，则比较的是双方的对象的地址；

	如果对equals 方法进行了重写，比较的是 所指向的对象的内容；

相比较于“=“：

	对于 = ，当作用于基本数据类型的变量，则直接比较“值”是否相等；如果作用于引用类型的变量，则比较的是所指向的对象的地址；

内部类：

	定义在一个类内部的另一个类里面或者一个方法里面，这样的类称为内部类；

成员内部类：

	最普通的内部类，定义为另一个类的内部。成员内部类可以无条件访问外部类的所有成员属性和成员方法。（包括private 成员 和 静态成员 ）

局部内部类：

	定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
	局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private、static修饰符的；

匿名内部类：

	格式：

		new 父类构造器（参数列表） |实现接口（）{

		//匿名内部类的类体部分

		}

匿名内部类：

	特殊：使用一次，创建一次对象

静态内部类：

	静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。

	静态内部类是不需要依赖外部类对象的，与静态成员属性类似，并且他不能使用外部类的非static成员变量或者方法。

包装类：

	int：对象存放在栈中；

	integer :是一个类，存放在堆中，相当于里面存在了一个int类型的整数；

字符串转换：

	例如：

		int x = Integer.parseInt(text); // 将文本类型的text 转换成为int类型的数字；

	还有：

		public static int parseInt（String s)：将 String 变为 int 型数据

		public static float parseInt (String s ): 将String 变为 Float 

可变参数：

格式：

	int ... nums ：
	表示的是可变参数，调用时可以传递 0 — n 个数字；

	在方法内部，可变参数以数组作为载体体现；

	可变参数必须写在参数列表的最后；

递归：

	方法自身调用自身；