面向对象三大特征中封装继承，多态的总体理解

二.继承

通过extends 关键字来对父类进行继承，继承后的子类拥有父类所有非私有化的属性和方法，并且可以对继承的方法在子类中进行重写。

重写时要注意：方法名和父类的原方法名，参数列表，返回都要相同，而且不能使用比原方法更严苛的访问权限。

子类在重写方法后，就不能在使用父类中的原方法了，这时可以使用super关键字来在子类中使用父类的构造器，非私有属性和非私有方法了。

格式：

调用属性：super.属性名；

调用非私有方法：super.方法(参数1,参数2)；

调用构造器：super(参数1,参数2)；

final关键字可以修饰类，方法和变量。

1.被final修饰的类不能被继承

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

3.被final修饰的变量作为全局常量，不可二次赋值

抽象类

abstract class 类名{}

抽象方法

abstract 返回值类型 方法名(参数列表)；

抽象方法无方法体 

注意：含有抽象方法的类一定是抽象类，但抽象类不一定都含有抽象方法。抽象方法只需要声明，而不需要实现。抽象类中定义的抽象方法，在非抽象子类继承后要把抽象类中的所有抽象方法重写。抽象方法不可用private修饰，否则无法被重写。

接口（interface）

接口克服了单继承的限制

[public] interface 接口名 [extends 接口1] [extends 接口2] {

        [public] [static] [final] 数据类型 常量名 = 常量； //全局常量

        [public] [abstract] 返回值类型 方法名(参数列表) ；//抽象方法

        [public] static 返回值类型 方法名(参数列表)；//静态方法

        [public] default 返回值类型 方法名(参数列表)；//默认方法

}

接口本身不能实例化，只能通过接口实现类来调用，即implements 关键字，且实现类必须重写接口中的所有抽象方法，这时一个实现类可以实现多个接口，即实现了多继承

定义接口实现类：

        修饰符 class 类名 implements 接口1，接口2，...{

}

实现类可以同时实现接口，又继承抽象类

        修饰符 class 类名 extends 父类名 implements 接口1，接口2，...{

}

接口不允许继承类，但是接口可以继承接口，也可以同时继承多个接口。

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

三.多态

由于参数类型不同，导致执行结果不同，就是多态，多态的两种表现形式是方法的重载和方法的重写。

对象类型的转换：

        向上转型：父类对象可以调用子类中重写的方法，对象发生向上转型后，调用的一定是被子类重写过的方法。不能调用父类中没有，子类中独有的方法

        父类类名 父类对象 = 子类实例；

        向下转型：为了重新获得因向上转型失去的子类特性，向下转型前必须先向上转型。

        父类类名 父类对象 = 子类实例；

        子类类名 子类对象 = （子类）父类对象；

instanceof关键字

对象 instanceof 类（或接口）；当对象是指定类或接口的实例化对象，则返回true，否则返回false。

Object类

是所有类的父类，常用方法有equals，hashCode，toString

四.内部类

内部类分为成员内部类，局部内部类，静态内部类，匿名内部类。

成员内部类：在类中定义的类，成员内部类可以访问外部类的所有属性和方法，通过外部类访问内部类，则需要在外部类创建内部类对象。

               外部类名 外部类对象 = new 外部类名（）；

               外部类名.内部类名 内部类对象 = 外部类对象.new 内部类名（）；

局部内部类：定义在方法中，有效范围仅限于方法内部。局部内部类可以访问外部类的所有属性和方法，外部类要访问局部内部类的成员，只能在局部内部类所属的方法中创建局部内部类对象，通过对象访问属性和方法。

静态内部类：用static修饰，静态内部类只能访问外部类的静态成员，访问静态内部类时可以在外部类创建静态内部类对象来访问。

                外部类名.静态内部类名 变量名 = new 外部类名.静态内部类名（）；

匿名内部类：没有名称的内部类，其类体作为new语句的一部分

new 继承的父类或实现的接口名（）{

        继承内部类的类体

}

这个匿名内部类作为参数。

例如定义了animalShout（）方法，该方法的参数是Animal接口类型的对象，在调用该方法时，会在参数位置定义一个实现Animal接口的匿名内部类。

即animalShout（new Animal（）{}）；

此时animalShout（new Animal（）{}）相当于创建一个匿名内部类对象，然后将该对象作为参数，传给animalShout()方法，最后在匿名内部类中重写了Animal的Shout方法