Java 抽象类

抽象方法：

• 在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。
• 而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。
• 抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。

抽象方法示例：

//没有方法体，有abstract关键字做修饰

public abstract void xxx();

抽象类的基本概念：

• 众所周知，父类是将子类所共同拥有的属性和方法进行抽取，这些属性和方法中，有的是已经明确实现了的，有的还无法确定，那么我们就可以将其定义成抽象，在后日子类进行重用，进行具体化。
• 所以，抽象类是为了把相同的但不确定的东西的提取出来，为了以后的重用。定义成抽象类的目的，就是为了在子类中实现抽象方法。
• 简单说，拥有抽象方法的类就是抽象类（但抽象类中也可以不包含抽象方法），抽象类要使用abstract关键字声明。

抽象类示例：

//定义一个抽象类

abstract class A{

 

    //普通方法

    public void fun(){

        System.out.println("存在方法体的方法");

    }

 

    //抽象方法，没有方法体，有abstract关键字做修饰

    public abstract void print();

}

抽象类的特性和使用：

• 抽象类不能被实例化。因为抽象类中方法未具体化，这是一种不完整的类，所以直接实例化也就没有意义了。
• 抽象类的使用必须有子类，使用extends继承，一个子类只能继承一个抽象类。
• 子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）。
• 抽象类可以不包含抽象方法，但如果类中包含抽象方法，就必须将该类声明为抽象类。

抽象类的基本使用示例：

//定义一个抽象类

abstract class A{

 

    //普通方法

    public void fun(){

        System.out.println("存在方法体的方法");

    }

 

    //抽象方法，没有方法体，有abstract关键字做修饰

    public abstract void print();

}

 

//单继承

//B类是抽象类的子类，是一个普通类

class B extends A{

 

    //强制要求覆写

    @Override

    public void print() {

        System.out.println("Hello World !");

    }

 

}

public class TestDemo {

 

    public static void main(String[] args) {

        //向上转型

        A a = new B();

 

        //被子类所覆写的过的方法

        a.print();

    }

}

运行结果：

Hello World !

抽象类的使用限制：

• 抽象类可以有构造方法。

由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。
并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。

示例如下：

abstract class A{

    public A(){

        System.out.println("*****A类构造方法*****");

    }

 

    public abstract void print();

}

 

class B extends A{

    public B(){

        System.out.println("*****B类构造方法*****");

    }

 

    @Override

    public void print() {

        System.out.println("Hello World !");

    }

}

 

public class TestDemo {

    public static void main(String[] args) {

        A a = new B();

    }

}

执行结果：

*****A类构造方法*****

*****B类构造方法*****

• 抽象类不能使用final声明，因为抽象类必须有子类，而final定义的类不能有子类。
• 抽象类能否使用static声明吗？

外部抽象类不允许使用static声明，而内部的抽象类可以使用static声明。
使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。

内部抽象类使用示例：

abstract class A{

    //static定义的内部类属于外部类

    static abstract class B{

        public abstract void print();

    }

}

 

class C extends A.B{

    public void print(){

        System.out.println("**********");

    }

}

 

public class TestDemo {

    public static void main(String[] args) {

        //向上转型

        A.B ab = new C();

        ab.print();

    }

}

执行结果：

**********

• 抽象类中的static方法可以直接调用。

示例代码：

abstract class A{

    public static void print(){

        System.out.println("Hello World !");

    }

}

 

public class TestDemo {

    public static void main(String[] args) {

        A.print();

    }

}

执行结果：

Hello World !

• 有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见，目的是对用户隐藏不需要知道的子类。

示例如下：

abstract class A{

    public abstract void print();

 

    //内部抽象类子类

    private static class B extends A{

        //覆写抽象类的方法

        public void print(){

            System.out.println("Hello World !");

        }

    }

 

    //这个方法不受实例化对象的控制

    public static A getInstance(){

        return new B();

    }

}

 

public class TestDemo {

    public static void main(String[] args) {

        //此时取得抽象类对象的时候完全不需要知道B类这个子类的存在

        A a = A.getInstance();

        a.print();

    }

}

执行结果：

Hello World !