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.可以声明抽象类的变量,然后讲一个子类对象赋值给它,这是对象的上转型对象用法。

 

抽象类实例

 

 1 package 抽象类测试;
 2 
 3 abstract class Shape {                                //抽象类
 4     public abstract void showArea();
 5 }
 6 
 7 class Circle extends Shape{                            //圆类,继承抽象类Shape
 8     private double r;                                //圆的半径
 9     
10     public double getR() {                            //圆的get方法
11         return r;
12     }
13     
14     public void setR(double r) {                    //圆的set方法
15         this.r = r;
16     }
17     
18     public Circle(double r) {                         //带参数的构造方法
19         this.r = r;
20     }
21     
22     public Circle(){                                //无参数的构造方法
23         
24     }
25     
26     public void showArea() {                        //实现继承的抽象类的抽象方法
27         System.out.println("圆的面积为: " + Math.PI * r * r);
28     }
29 }
30 
31 class Rectangle extends Shape{                        //矩形类,继承了抽象类Shape
32     private double width;                            //
33     private double height;                            //
34     
35     public double getWidth() {
36         return width;
37     }
38     
39     public void setWidth(double width) {
40         this.width = width;
41     }
42     
43     public double getHeight() {
44         return height;
45     }
46     
47     public void setHeight(double height) {
48         this.height = height;
49     }
50     
51     public Rectangle(double width, double height) {
52         this.width = width;
53         this.height = height;
54     }
55     
56     public Rectangle(){
57         
58     }
59     
60     public void showArea() {                            //实现继承的抽象类的抽象方法
61         System.out.println("矩形的面积为: " + width * height);
62     }
63 }
64 public class AbstractDemo {
65     public static void main(String[] args) {
66         Shape shape;
67         Circle circle = new Circle(1);
68         shape = circle;
69         shape.showArea();            //此处调用的是Circle类中实现的showArea()方法
70         Rectangle rectangle = new Rectangle(2, 3);
71         shape = rectangle;    
72         shape.showArea();            //此处调用的是Rectangle类实现的showArea()方法
73     }                                //以上两处都是shape.showArea()方法,但是输出的结果不同
74 
75 }

运行结果如下

圆的面积为: 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 ...;

 

接口实例

 1 package 接口测试;
 2 
 3 interface Area {
 4 //    final double area = 100;
 5     public abstract void showArea();
 6 }
 7 
 8 class Circle implements Area {
 9 private double r;                                //圆的半径
10     
11     public double getR() {                            //圆的get方法
12         return r;
13     }
14     
15     public void setR(double r) {                    //圆的set方法
16         this.r = r;
17     }
18     
19     public Circle(double r) {                         //带参数的构造方法
20         this.r = r;
21     }
22     
23     public Circle(){                                //无参数的构造方法
24         
25     }
26     
27     public void showArea() {                        //实现接口中的抽象方法
28         System.out.println("圆的面积为: " + Math.PI * r * r);
29     }
30 }
31 
32 class Rectangle implements Area {
33     private double width;                            //
34     private double height;                            //
35     
36     public double getWidth() {
37         return width;
38     }
39     
40     public void setWidth(double width) {
41         this.width = width;
42     }
43     
44     public double getHeight() {
45         return height;
46     }
47     
48     public void setHeight(double height) {
49         this.height = height;
50     }
51     
52     public Rectangle(double width, double height) {
53         this.width = width;
54         this.height = height;
55     }
56     
57     public Rectangle(){
58         
59     }
60     
61     public void showArea() {         //实现接口中的抽象方法
62         System.out.println("矩形的面积为: " + width * height);
63     }
64 }
65 public class InterfaceDemo {
66     public static void main(String[] args) {
67         Area area;
68         Circle circle = new Circle(1);
69         area = circle;
70         area.showArea();            //此处调用的是Circle类中实现的showArea()方法
71         Rectangle rectangle = new Rectangle(2, 3);
72         area = rectangle;    
73         area.showArea();            //此处调用的是Rectangle类实现的showArea()方法
74     }                                //以上两处都是area.showArea()方法,但是输出的结果不同
75 
76 
77 }

运行结果

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

 

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

 

posted @ 2015-04-19 00:05  sodawoods  阅读(627)  评论(0编辑  收藏  举报