JAVA中的抽象类和接口

一 抽象类

抽象类就是不能被实例化的类，即不可以用new运算符创建本类的对象。在实际应用中，抽象类应该具有子类，且其子类一般不为抽象类。

java中使用抽象类的原因有如下四点：

1.抽象类是较高层次的概括，其他的类可以继承它的抽象化特征；

2.抽象类包括它的所有子类共享的公共行为和公共属性，即抽象类中定义一些属性和方法，其他类继承该抽象类并实现这些属性和方法；

3.抽象类使编写程序更贴近人类的思维方式和客观世界；

4.在用户生成实例时强迫用户生成更具体的实例，保证代码的安全性。

二 接口

在接口中只包含    常量    和     方法的声明，接口中的数据成员默认为static和final，方法默认为public abstract

java中使用接口的原因有如下四点：

1.弥补单继承的不足；

2.接口中定义动作原型，由实现接口的类完成接口中的方法，这样可以最大限度的实现动态绑定，隐藏实现细节，实现不同类之间的常量共享；

3.接口可以了解对象的交互界面，而无需了解对象所对应的类；

4.接口为设计和规划大型java应用程序提供了一种方便的程序设计框架。

三  抽象类和接口的区别

1.抽象类中可以定义抽象的和非抽象的元素，接口是完全抽象的（常量以及抽象方法）。

2.接口没有构造方法，而抽象类中可以有构造方法，但不能创建抽象类的对象。

3.一个类每次只能继承一个类，可以实现多个接口。一个接口可以扩展多个接口。（类的继承和接口的扩展都用关键字extends）

4.接口中的成员都是public的，而抽象类没有这样的限定。

 

四 抽象类用法以及实例

 

[访问权限修饰符] abstract class 抽象类名 {

//抽象类成员

}

 

几点说明：

1.抽象类中可以没有任何抽象方法，但这样做违背了高度抽象的原则。

2.若一个类中有抽象的方法，那么这个类一定为抽象类。

3.抽象类中可以声明构造方法，但是抽象类不能用new运算符创建抽象类的对象。

4.可以声明抽象类的变量，然后讲一个子类对象赋值给它，这是对象的上转型对象用法。

 

抽象类实例

 

package 抽象类测试;

abstract class Shape {                                //抽象类
    public abstract void showArea();
}

class Circle extends Shape{                            //圆类，继承抽象类Shape
    private double r;                                //圆的半径
    
    public double getR() {                            //圆的get方法
        return r;
    }
    
    public void setR(double r) {                    //圆的set方法
        this.r = r;
    }
    
    public Circle(double r) {                         //带参数的构造方法
        this.r = r;
    }
    
    public Circle(){                                //无参数的构造方法
        
    }
    
    public void showArea() {                        //实现继承的抽象类的抽象方法
        System.out.println("圆的面积为： " + Math.PI * r * r);
    }
}

class Rectangle extends Shape{                        //矩形类，继承了抽象类Shape
    private double width;                            //宽
    private double height;                            //高
    
    public double getWidth() {
        return width;
    }
    
    public void setWidth(double width) {
        this.width = width;
    }
    
    public double getHeight() {
        return height;
    }
    
    public void setHeight(double height) {
        this.height = height;
    }
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    public Rectangle(){
        
    }
    
    public void showArea() {                            //实现继承的抽象类的抽象方法
        System.out.println("矩形的面积为： " + width * height);
    }
}
public class AbstractDemo {
    public static void main(String[] args) {
        Shape shape;
        Circle circle = new Circle(1);
        shape = circle;
        shape.showArea();            //此处调用的是Circle类中实现的showArea()方法
        Rectangle rectangle = new Rectangle(2, 3);
        shape = rectangle;    
        shape.showArea();            //此处调用的是Rectangle类实现的showArea()方法
    }                                //以上两处都是shape.showArea()方法，但是输出的结果不同

}

运行结果如下

圆的面积为： 3.141592653589793
矩形的面积为： 6.0

 

五 接口的使用方法和实例

 

接口的定义

[接口修饰符] interface 接口名称 [extends 父接口名] {

//方法的声明以及静态常量

}

 

几点说明：

1.接口中的数据成员是静态常量，用final修饰，必须赋初始值，此值不能改变，可以实现不同类之间的常量共享。

2.接口中的方法必须为抽象方法，用public abstract修饰。

3.接口中数据成员前的final关键字，抽象方法前的public abstract 关键字可以省略。

4.一个类只能继承一个父类，但是可以实现多个接口。 如 class A extends B inplements C, D, E;

5.一个类实现某个接口时，需要实现接口中所有的方法

6.一个类在实现接口中的方法时，一定要用public修饰

7.一个接口可以扩展多个接口。    interface 子接口名 extends 父接口名1， 父接口名2 ...；

 

接口实例

package 接口测试;

interface Area {
//    final double area = 100;
    public abstract void showArea();
}

class Circle implements Area {
private double r;                                //圆的半径
    
    public double getR() {                            //圆的get方法
        return r;
    }
    
    public void setR(double r) {                    //圆的set方法
        this.r = r;
    }
    
    public Circle(double r) {                         //带参数的构造方法
        this.r = r;
    }
    
    public Circle(){                                //无参数的构造方法
        
    }
    
    public void showArea() {                        //实现接口中的抽象方法
        System.out.println("圆的面积为： " + Math.PI * r * r);
    }
}

class Rectangle implements Area {
    private double width;                            //宽
    private double height;                            //高
    
    public double getWidth() {
        return width;
    }
    
    public void setWidth(double width) {
        this.width = width;
    }
    
    public double getHeight() {
        return height;
    }
    
    public void setHeight(double height) {
        this.height = height;
    }
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    public Rectangle(){
        
    }
    
    public void showArea() {         //实现接口中的抽象方法
        System.out.println("矩形的面积为： " + width * height);
    }
}
public class InterfaceDemo {
    public static void main(String[] args) {
        Area area;
        Circle circle = new Circle(1);
        area = circle;
        area.showArea();            //此处调用的是Circle类中实现的showArea()方法
        Rectangle rectangle = new Rectangle(2, 3);
        area = rectangle;    
        area.showArea();            //此处调用的是Rectangle类实现的showArea()方法
    }                                //以上两处都是area.showArea()方法，但是输出的结果不同


}

运行结果

圆的面积为： 3.141592653589793
矩形的面积为： 6.0

 

以上两个程序分别用抽象类和接口实现了多态。