黑马程序员——抽象类，接口总结

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

一抽象类
(1)多个具体的事物具备相同的方法声明，而方法体不同，我们就只抽取方法声明，然后定义到一个类中。
而一个没有方法体的方法是一个抽象方法，一个类中有抽象方法，该类必须定义为抽象类。

(2)抽象类的特点：
A:抽象类或者抽象方法用abstract修饰。
B:抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
C:抽象类不能被实例化。
D:子类继承抽象类，要么是抽象类，要么重写所有父类抽象方法。

(3)抽象类的几个小问题
A:不能被实例化，要构造方法干啥?
B:一个类中没有抽象方法，居然定义抽象类，有什么意义?
C:抽象关键字不能和哪些关键字共存
a:private
b:final
c:static

(4)抽象类的成员：
A:成员变量 有变量，也有常量
B:构造方法 有构造方法，用于子类访问父类数据的初始化
C:成员方法 有抽象方法，也有非抽象的方法

(5)抽象类的案例
A:老师案例
B:学生案例
C:员工案例

(6)抽象方法：
多个对象都具备相同的功能，但是功能具体内容有所不同，
那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

抽象类与抽象方法均需要使用abstract关键字。

抽象类：
包含抽象方法的类就是抽象类
(7)代码实现

class Demo1_Abstract {    public static void main(String[] args)     {        //抽象类通过子类对象，多态地方式完成实例化        Animal c = new Cat();        Animal d = new Dog();        method(c);        method(d);    }    public static void method(Animal animal) {        animal.eat();    }}abstract class Animal{    //父类的方法，一般就是为了规定，该种类型应该有某个方法    public abstract void eat();}class Cat extends Animal{    //子类必须重写抽象父类的抽象方法，才能创建对象    public void eat(){        System.out.println("喵，吃了");    }}class Dog extends Animal{    //子类必须重写抽象父类的抽象方法，才能创建对象    public void eat(){        System.out.println("汪汪，吃了");    }}

注意：
不包含抽象方法的类，也有可能是抽象类
抽象类中可以包含非抽象方法
抽象类当中可以有没有抽象方法
任意类中可以一个方法都没有

!抽象类本身无法实例化
抽象类通过子类对象，多态地方式完成实例化
子类需要将抽象父类的抽象方法均覆盖才可以实例化，否则依然是抽象类。 抽象类强制子类必须实现抽象方法

二多态后的成员特点：
成员变量：
编译时检测父类是否有该变量
运行时访问的是父类的该变量

成员方法：
编译时检测父类是否有该方法
运行时调用的是子类的重写的方法

成员变量：
编译看左边父类类型是否有该属性
运行时访问的左边父类类型的属性
成员方法：
编译看左边父类类型是否有该方法
运行时看右边子类是否重写了该方法，如果重写，调用重写后的方法，否则使用从父类继承过来的方法
所有情况均看引用类型，只有在调用方法时，检查子类是否重写。

代码实例

class  Demo07_Object{    public static void main(String[] args)     {        Animal a = new Cat();        //System.out.println(a.name);        a.method();    }}//定义动物类class Animal{    //String name = "动物";    public void method() {        System.out.println("动物的方法");    }}//定义猫类class Cat extends Animal{    //String name = "Tom";    public void method() {        System.out.println("Tom的方法");    }}   

三向上向下转型
子类自动向上转型成父类
向上向下转型

向下转型: 如果使用多态的方式，父类引用指向子类对象，则该对象是可以转回子类的。
如果是用父类引用指向父类对象时，是无法转成子类的。
类型转换异常在运行时报错，属于运行时异常。编译时不报错。

class Demo08_Object{    public static void main(String[] args)     {        //父类引用指向子类对象，多态        Animal a = new Cat();        //创建一个单纯的Animal对象，用来作为参数        Animal canshuAnimal = new Animal();        //调用多态形式的a的method2方法：        a.method2(canshuAnimal);        //父类引用指向子类对象，多态        Animal a2 = new Cat();        //创建一个单纯的多态Cat对象，用来作为参数        Cat cat = new Cat();        //调用多态形式的a2的method2方法：        a2.method2(cat);    }}//定义动物类class Animal{     public void method() {        System.out.println("动物的方法被调用了1");    }     public void method2(Animal a) {        System.out.println("动物的方法被调用了2");    } }//定义猫类class Cat extends Animal{     public void method() {        System.out.println("猫的方法被调用了1");    }     //当参数为父类类型时，可以传入子类对象，子类对象会自动提升成父类    public void method2(Animal a) {        System.out.println("猫的方法被调用了2");        a.method();    } }   

四接口

(1)当一个抽象类中的方法都是抽象的时候，java就提供了一种更抽象的表达方式，叫接口。

(2)接口的成员特点：
A:成员变量 是常量 默认修饰符 public static final
B:成员方法 抽象方法 默认修饰符 public abstract

(3)接口的特点：
A:接口用interface定义
B:实现类实现接口用implements标识
C:接口不能被实例化

(4)接口和类的关系
A:类与类的关系
继承关系,只能单继承，可以多层继承。
B:类与接口的关系
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口。
class A extends B implements C，D

C:接口与接口的关系
继承关系，可以单继承，也可以多继承。

(5)接口的思想特点(理解)
A:对外暴露的规则(USB接口)
B:程序的扩展功能(多态)
C:降低程序的耦合性(多态)
D:让类可以多实现

(6)接口和抽象类的区别
共性：都是不断抽取出来的抽象的内容。

A:成员特点
抽象类：
成员变量 可以变量，也可以常量
成员方法 可以抽象，也可以非抽象
构造方法 有
接口：
成员变量 只能是常量
成员方法 只能是抽象
构造方法 无
B:继承或者实现关系特点
a:类与类的关系
继承关系,只能单继承，可以多层继承。
b:类与接口的关系
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口。
c:接口与接口的关系
继承关系，可以单继承，也可以多继承。
C:设计区别
抽象类中定义的是体系的共性内容。表达的是：is a的关系。
接口中定义的是体系的扩展功能。表达的是：like a的关系。

代码实例

class Demo1_Interface {    public static void main(String[] args)     {        MyClass mc = new MyClass();        mc.method();        mc.method2();        //接口多态，同样编译时，判断接口是否有该方法，运行时，运行子类对象重写的方法        MyInterface mi = new MyClass();        mi.method();        //mi.method2();        MyInterface2 mi2 = new MyClass();        //mi2.method();        mi2.method2();    }}//定义一个接口interface MyInterface{    //定义接口静态常量(必须赋值)    public static final String name = "AngelaBaby";    //定义抽象方法method，强制要求子类实现    public abstract void method();}   //定义一个接口interface MyInterface2{    //定义抽象方法method2，强制要求子类实现    public abstract void method2();}   //接口多继承接口interface MyInterface3 extends MyInterface,MyInterface2 {}class MySuperClass{}//定义一个类实现两个接口(相当于继承了两个抽象类)，要么重写所有的抽象方法，要么自己也是抽象类class MyClass extends MySuperClass implements MyInterface,MyInterface2{    //重写接口1的方法    public void method(){        System.out.println("hello world");    }    //重写接口2的方法    public void method2() {        System.out.println("hello world2");    }}

五如何实现一个继承体系
分析：由具体到抽象
实现：由抽象到具体

学习：抽象的内容,因为它定义的是共性内容。
使用：具体的内容,因为它才是具体实现，才具备更多的功能。