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

——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");
    }
}

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

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