java之抽象类介绍

什么抽象方法和抽象类　

　　抽象方法　　

　　在类里面定义的没有方法体且用关键字“abstract”来修饰的方法就是抽象方法，所谓的没有方法体指的是在方法声明的时候没有大括号以及其中的内容，而是直接在声明时在方法名后加上分号结束。

　　抽象类

　　抽象类是相同概念实体的一种抽象,也就是规范对象是什么。Java中用关键字abstract来定义抽象类和抽象方法。　　

　　只要一个类里面有一个方法是抽象方法，那么这个类就要定义为抽象类，抽象类也要使用“abstract”关键字来修饰；在抽象类里面可以有不是抽象的方法和成员属性，但只要有一个方法是抽象的方法，这个类就必须声明为抽象类，使用“abstract”来修饰。

抽象类和抽象方法的关系及特点

抽象类和抽象方法必须用abstract关键字来修饰，抽象方法没有方法体，即不能有{};
抽象类中不一定要有抽象方法，即也可以都是非抽象方法或两者并存，但是拥有抽象方法的类一定要定义为抽象类；
抽象类不能被实例化，但是抽象类依然有构造方法，抽象类的构造方法用于子类访问父类数据的初始化。
抽象类的子类可以是抽象类，但如果不是抽象类，必须重写抽象类中定义的所有抽象方法。
抽象类不能用final修饰，因为被final修改不能被继承，而抽象类是一定要被继承的，因为抽象类是不能被示例化的
成员变量：可以为常量（例如final修饰的常量），也可以为变量；
静态成员变量：可以有，可以被继承，但是不会被重写
成员方法：可以是抽象的成员方法（子类必须要实现重写的），也可以是非抽象的成员方法
静态成员方法：抽象类中可以有静态成员方法，可以被继承但不能被子类重写

　那么抽象类不能产生实例对象我们声明抽象类有什么用呢？

　我们是将抽象方法做为子类重写的模板使用的，定义抽象类就相当于定义了一种规范，这种规范要求子类去遵守，子类继成抽象类之后，把抽象类里面的抽象方法按照子类的需要实现。

抽象关键字abstract和其他关键字的冲突关系

不能和private一起使用：private修饰的方法不被继承，而抽象的方法必须要继承，所以会冲突报错。
和static一起使用无意义：static修饰的方法可以通过类名去访问，而抽象的方法没有实现方法体，所以无意义。
不能和final一起使用：final修饰的方法不被重写，而抽象的方法必须被非抽象子类重写，所以会报错

抽象类和普通类的区别

抽象类不能被实例化。
抽象类可以有构造函数，被继承时子类必须继承父类一个构造方法，抽象方法不能被声明为静态。
抽象方法只需申明，而无需实现，抽象类中可以允许普通方法有主体
含有抽象方法的类必须申明为抽象类
抽象的子类必须实现抽象类中所有抽象方法，否则这个子类也是抽象类。
抽象类的构造函数用来初始化抽象类的一些字段，而这一切都在抽象类的派生类实例化之前发生。不仅如此，抽线类的构造函数还有一种巧妙应用：就是在其内部实现子类必须执行的代码

抽象类和接口的区别

　　接口　　

　　定义：用于限定某个对象所必须拥有的公共操作方法的一种结构，称之为接口（interface）
　语法：定义接口结构，使用interface关键字。接口内定义的都是一些公共方法。　　

　　简单的说，接口是对动作的抽象，抽象的是功能，表示的是对象能做什么；抽象类是对根源的抽象，抽象的是对象的类型，表示的是属于哪个种类,换句话说。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.

　　抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。

抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
抽象类要被子类继承，接口要被类实现。
接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
抽象方法只能申明，不能实现，接口是设计的结果，抽象类是重构的结果
抽象类里可以没有抽象方法
如果一个类里有抽象方法，那么这个类只能是抽象类
抽象方法要被实现，所以不能是静态的，也不能是私有的。
接口可继承接口，并可多继承接口，但类只能单根继承。

抽象类和其子类的使用示例

/**
 * Created by lili on 15/10/21.
 */

abstract class Person {
    public int age = 1;
    public final int PerID = 2;

    public Person() {

    }

    public Person(int age) {
        this.age = age;
    }

    abstract void show();//定义子类必须要重写的,即必须要做的事

    //子类必须要继承的,但不一定要重写
    public void play() {
        System.out.println("抽象类中的非抽象方法");
    }

    //子类必须继承且不能重写
    public final void talk() {
        System.out.println("talk like a person");
    }

    public static void think() {
        System.out.println("think like a person");
    }


}

class Student extends Person{
    public int age = 10;
    public final int PerID = 20;//注释后向下转型后的看成员变量访问的结果中PerID打印的是2,说明可被继承

    public Student() {

    }

    //必须要重写
    void show() {
        System.out.println("子类中重写抽象类中的抽象方法");
        System.out.println("子类内部访问age:" + age);//打印的是10,成员变量可以被重写
        System.out.println("子类内部访问PerID:" + PerID);//打印的是20,说明静态成员变量可以被"重写";
    }

//    public final void talk() { //报错,被覆盖的方法为final
//        System.out.println("talk like a student");
//    }

    public static void think() {
        System.out.println("think like a student");
    }
}

public class PolymorphismTest {
    public static void main(String[] args) {
        Person person = new Student();
        person.show();//方法被重写,访问的是重写后的方法
        System.out.println(person.age);//打印1,打印的是父类的age
        System.out.println(person.PerID);//打印2,打印的是父类的PerID
        person.talk();//talk like a person,调用的是父类的访问,静态方法,不被重写
        person.think();

        System.out.println("--------向下转型后的看成员变量访问的结果-----------");
        Student student = (Student)person;
        student.show();//方法被重写,访问的是重写后的方法
        System.out.println(student.age);//打印10,成员变量被重写了
        System.out.println(student.PerID);//打印20,成员方法被重写了
        student.talk();//talk like a person,静态方法,不被重写,但被继承
        student.think();
    }
}

运行结果：

子类中重写抽象类中的抽象方法
子类内部访问age:10
子类内部访问PerID:20
2
talk like a person
think like a person
--------向下转型后的看成员变量访问的结果-----------
子类中重写抽象类中的抽象方法
子类内部访问age:10
子类内部访问PerID:20
20
talk like a person
think like a student

Process finished with exit code 0

注释子类中的PerID定义，则运行结果为：

子类中重写抽象类中的抽象方法
子类内部访问age:10
子类内部访问PerID:2
2
talk like a person
think like a person
--------向下转型后的看成员变量访问的结果-----------
子类中重写抽象类中的抽象方法
子类内部访问age:10
子类内部访问PerID:2
2
talk like a person
think like a student

Process finished with exit code 0