面向对象主要特征
继承（inheritance）
继承也称泛化，继承性是子类自动共享父类属性和方法的机制。
是类之间的的一种关系，一般类与特殊类之间的关系。关键字extends
*被继承的类称为父类（超类，基类），继承的类叫子类（派生类）。
*子类继承父类的所有属性和方法，同时也可以增加自己的属性和方法。
语法为：【修饰符】class 子类名 extends 父类名
继承的含义
*java中只支持单继承，就是每个类只能有一个父类，不允许有多重继承。
*一个父类可以有多个子类
*子类继承父类的所有属性和方法。
*子类是父类的一种，也可以说“子类就是父类”。
类的继承
子类实例化的过程
*子类实例化时先实例化其父类，然后实例化子类。
*要先调用父类的构造器，父类构造器运行完毕，才调用子类的构造器。
调用构造方法
在构造方法中，可以使用this或super调用其他的构造方法
*super（）
作用：调用父类构造器
只能出现在子类的构造器中，且必须是第一行。
super（）中的参数，决定了调用父类的哪个构造器。
如果子类构造器中没有出现super，那么编译器会默认加上super（），即调用父类的空构造器，如果父类没有空构造器，编译器提示错误。
（父类出现多个构造器，即重载使用super）
*this（）
作用：调用本类的构造器。
只能写在构造器的第一行。
在同一个构造器中super（）和this（）不能同时出现。
-子类实例化过程
*使用默认构造器
*在子类中创建构造器
*在子类中创建构造器时，必须调用父类构造器
1.子类可以在自己的构造器中使用super关键字来调用父类构造器
例：super（参数1，参数2，）
2.如调用的是父类无参的构造器，那不可用super（）
3.如果子类中调用了父类无参的构造器，而父类中没有无参构造器则系统出错。
super和this关键字
super.
指向父类的引用。
通过关键字super我们可以指定子类在构造时调用父类的哪个构造器
，达到先实例化父类然后实例化子类的目的。
子类的构造器默认的调用父类无参构造器，即子类构造器中没有用
super指明调用父类哪个构造器的话，实际上编译器会自动的在子类
构造器第一行加入代码super( );
this.
指向本类的引用。
我们知道子类在实例化时必须调用父类的构造器，实际上有的子类
构造器也可以先调用本类的其他构造器，然后再通过那个构造器调
用父类的构造器
无论是调用父类的构造器还是子类的构造器，最终都是找到最顶级
的父类自上而下的实例化。只要中间环节有一个构造器没找到，这
个子类就无法完成实例化。
封装（encapsulation）
所谓封装是把对象的属性和行为结合在一个独立的系统单位内部。
尽可能隐蔽对象的内部细节，只向外部提供接口。
封装的重要意义：
使对象能够集中而完整地描述并对应一个具体事物
体现了事物的相对独立性，使对象外部不能随意存取对象的内部数据
权限修饰符
使用访问修饰符对类的成员进行控制，在java中称为“封装”。
用来控制类的成员和类的使用范围。
权限修饰符包括：
封装的常用设置：
*构造器和类的权限通常为public
*private权限最小，限制类外访问，一般把属性设为private，让其他类不能直接访问属性，达到保护属性的目的。
*不使用权限符时即default的成员在类内以及在同一个包内的其他类可以访问。
*protected所修饰的成员在类内，同一个包中，所在类的子类中都可以访问。
方法的覆盖（override）
也可称为重写（rewrite），是对父类中继承来的方法进行改造，只有在子类继承父类时发生。
方法覆盖规则
在子类中的覆盖方法与父类中被覆盖的方法应具有
相同的方法名
相同的参数列表（参数数量、参数类型、参数顺序都要相同）
相同的返回值类型
子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限
abstract和final
在Java中使用abstract关键字定义抽象方法
例：abstract int method1(int a, int b);
abtract class A {
String name;
abstract int method1(int a, int b);
void sayHi( ){
System.out.println(“Hello!”);
}；
抽象方法
只有方法声明，没有方法实现的方法
抽象方法需要子类重写该方法，因此不能用private、final修饰
抽象类是抽象方法和非抽象方法的集合，包含特殊情况如下：
*抽象类中可以全部是抽象对象
*抽象类中可以全部为非抽象方法
抽象类
抽象类规则
注意：
*抽象类不能被实例化
*包含的抽象方法必须在其子类中被实现，否则子类只能声明为abstract；
*抽象方法不能为static；
final关键字
final可以修饰的元素：
类：不能被继承
变量(属性和局部变量)：不能被重新赋值
– 在声明时赋值，或在构造器中赋值
– 系统不会对final属性默认的赋初始值
方法：不能在子类中被覆盖，即不能修改。
接口（interface）
接口意义
java继承时一个类只有一个直接父类，也就是单继承，但是一个类可以实现多个接口，接口弥补了类的不能多继承缺点，继承和接口的双重设计即保持了类的数据安全也变相实现了多继承。
接口的概念
*接口中只包含常量和抽象方法，而没有变量和方法的实现。
*接口对类来说是一套规范，是一套行为协议。
接口不是一个类，不能实例化。
语法格式：
接口的成员：常量（字段），抽象方法
注意：接口不是一个类，没有构造器，不能被实例化。
*接口用interface关键字来定义，而不是class。
接口默认：
-常量：public static final
-抽象方法：public abstract
接口与接口的继承
可实现多继承
接口和类的关系
类实现接口-implements
为了使用一个接口，你要编写实现接口的类
如果一个类要实现一个接口，那么这个类就必须实现接口中所有抽象方法。
否则这个类只能声明为抽象类
多个无关的类可以实现一个接口，一个类可以实现多个无关的接口
一个类可以在继承一个父类的同时，实现一个或多个接口
接口可以实现多继承：用接口可以实现混合类型（主类型，副类型）在java中可以通过接口分出主次类型；主类型使用继承，副类型使用接口实现。
JDK8接口默认方法
在JDK8之前，接口不能定义任何实现，这意味着之前所有的JAVA版本中
，接口制定的方法是抽象的，不包含方法体。
从JKD8开始，添加了一种新功能-默认方法。默认方法允许接口方法定义
默认实现，而所有子类都将拥有该方法及实现。
默认方法是可选的，子类可以根据不同的需求Override默认实现。
接口与抽象类的对比
接口不能含有任何非抽象方法，而抽象类可以。
从JKD8开始，接口可以有默认方法。
类可以实现多个接口，但只能有一个父类。
接口和接口之间可以多继承
如：public interface A extends B,C
其中B,C也是接口.
抽象类可以理解为抽象方法和非抽象方法的混合体，而接口中的方法
完全是抽象方法，是一套纯粹的规范。一般来说，有关系的类才能继
承同一个抽象类，而无关的类不可能有同一个抽象父类，但是无关的
类可以实现同一个接口。
final常用方式
把常量设置为静态static，多个实例共享该常量，没有必要每个对象保
存一份；
常量设置为final类型，赋值以后不能再改变；
最后注意遵守常量命名规范，所有字母大写、单词之间用下划线。
引用数据类型的转换
上溯造型
向上转型（uppcasting）-子类转换为父类，自动转换。
前提-具有实现和继承关系
向上转换损失了子类的新扩展的属性和方法，仅可以使用从父类中继承的属性和方法。
下溯造型
向下转型（Downcasting）：强制转换
将父类对象显示的转换成子类类型。
曾经向上转换过的对象，才能再向下转换。对象不允许不经过上溯造型而直
接下溯造型。
如下写法是会出现运行期错误：
– Person p = new Person();
– Student s = (Student)p;
instanceof运算符
通过instanceof来判断该经过上溯转型后是哪一个子类的。
判断一个实例对象是否属于一个类
– object instanceof class 对象 instanceof 类
判断一个类是否实现了某个接口
– object instanceof interface 对象 instanceof 接口
返回值都是boolean类型
例如：
Animal a = new Cat( );
boolean b= a instanceof Cat;
class Animal{}
class Cat extends Animal{}
多态（polymorphism）
指同一个命名可具有不同的语义。对于子类可用不同的方法替代实现父类的服务的方法（用父类创建子类的对象）
多态存在的三个必要条件：
*要有继承，或实现。
*要有重写。
*父类引用指向子类对象。
一旦满足以上3个条件，当调用父类中被重写的方法后，运行时创建的是
哪个子类的对象，就调用该子类中重写的那个方法。
在执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际
类型调用相应的方法。
内部类
内部类就是定义在另一个类内部的类。
内部类对于同一包中的其他类来说，内部类能够隐藏起来。
**注意：
内部类可以访问其外部类中所有的属性和方法，无需创建外部类的对象。
必须创建内部类的对象，否则无法从外部类访问内部类的变量和方法。
如果内部类中有和外部类同名的变量或方法，则内部类的变量和方法将获
得比外部类的变量和方法更高的优先级。
不能定义static变量
一个类只会被这个类所调用，其他类不会使用他，你可以把它定义成
一内部类，这样可以隐藏实现细节，避免错误的调用。
