Java基础之五：抽象类与接口

最新推荐文章于 2022-07-22 10:48:22 发布

mengxiaohu001

最新推荐文章于 2022-07-22 10:48:22 发布

阅读量397

点赞数

一、抽象类介绍

下面通过一下的小程序深入理解抽象类

　　因此在类Animal里面只需要定义这个enjoy()方法就可以了，使用abstract关键字把enjoy()方法定义成一个抽象方法，定义如下：public abstract void enjoy();

　　从某种意义上来说，抽象方法就是被用来重写的，所以在父类声明的抽象方法一定要在子类里面重写。如果真的不想在子类里面重写这个方法，那么可以再在子类里面把这个方法再定义为抽象方法，因为子类觉得我去实现也不合适，应该让继承我的子类去实现比较合适，因此也可以在继承这个子类的下一个子类里面重写在父类里面声明的抽象方法，这是可以的。

　　这里有一个规则：既然父类里面的方法是抽象的，那么对于整个类来说，它就有一个没有实现的方法，这个方法不知道怎么去实现，那么这个类是就是残缺不全的，因此这个类应该被定义为一个抽象类。所以前面这样声明的声明的class Animal应该要在class的前面加上abstract，即声明成这样：abstract class Animal，这样Animal类就成了一个抽象类了。Animal类的最终定义代码如下：

 1 /**
 2  * 父类Animal
 3  * 在class的前面加上abstract，即声明成这样：abstract class Animal
 4  * 这样Animal类就成了一个抽象类了
 5  */
 6 abstract class Animal {
 7 
 8     public String name;
 9 
10     public Animal(String name) {
11         this.name = name;
12     }
13     
14     /**
15      * 抽象方法
16      * 这里只有方法的定义，没有方法的实现。
17      */
18     public abstract void enjoy(); 
19     
20 }

　　Java语言规定，当一个类里面有抽象方法的时候，这个类必须被声明为抽象类。

　　子类继承父类时，如果这个父类里面有抽象方法，并且子类觉得可以去实现父类的所有抽象方法，那么子类必须去实现父类的所有抽象方法，如：

 1 /**
 2  * 子类Dog继承抽象类Animal，并且实现了抽象方法enjoy
 3  * @author gacl
 4  *
 5  */
 6 class Dog extends Animal {
 7     /**
 8      * Dog类添加自己特有的属性
 9      */
10     public String furColor;
11 
12     public Dog(String n, String c) {
13         super(n);//调用父类Animal的构造方法
14         this.furColor = c;
15     }
16 
17     @Override
18     public void enjoy() {
19         System.out.println("狗叫....");
20     }
21 
22 }

　　这个父类里面的抽象方法，子类如果觉得实现不了，那么把就子类也声明成一个抽象类，如：

 1 /**
 2  * 这里的子类Cat从抽象类Animal继承下来，自然也继承了Animal类里面声明的抽象方法enjoy()，
 3  * 但子类Cat觉得自己去实现这个enjoy()方法也不合适，因此它把它自己也声明成一个抽象的类，
 4  * 那么，谁去实现这个抽象的enjoy方法，谁继承了子类，那谁就去实现这个抽象方法enjoy()。
 5  * @author gacl
 6  *
 7  */
 8 abstract class Cat extends Animal {
 9 
10     /**
11      * Cat添加自己独有的属性
12      */
13     public String eyeColor;
14 
15     public Cat(String n, String c) {
16         super(n);//调用父类Animal的构造方法
17         this.eyeColor = c;
18     }
19 }

　　这里的子类Cat从抽象类Animal继承下来，自然也继承了Animal类里面声明的抽象方法enjoy()，但子类Cat觉得自己去实现这个enjoy()方法也不合适，因此它把它自己也声明成一个抽象的类，那么，谁去实现这个抽象的enjoy方法，谁继承了子类，那谁就去实现这个抽象方法enjoy()。如：

 1 /**
 2  * 子类BlueCat继承抽象类Cat，并且实现了从父类Cat继承下来的抽象方法enjoy
 3  * @author gacl
 4  *
 5  */
 6 class BlueCat extends Cat {
 7 
 8     public BlueCat(String n, String c) {
 9         super(n, c);
10     }
11 
12     /**
13      * 实现了抽象方法enjoy
14      */
15     @Override
16     public void enjoy() {
17         System.out.println("蓝猫叫...");
18     }
19     
20 }

完整的测试代码如下：

  1 package javastudy.summary;
  2 
  3 /**
  4  * 父类Animal
  5  * 在class的前面加上abstract，即声明成这样：abstract class Animal
  6  * 这样Animal类就成了一个抽象类了
  7  */
  8 abstract class Animal {
  9 
 10     public String name;
 11 
 12     public Animal(String name) {
 13         this.name = name;
 14     }
 15     
 16     /**
 17      * 抽象方法
 18      * 这里只有方法的定义，没有方法的实现。
 19      */
 20     public abstract void enjoy(); 
 21     
 22 }
 23 
 24 /**
 25  * 这里的子类Cat从抽象类Animal继承下来，自然也继承了Animal类里面声明的抽象方法enjoy()，
 26  * 但子类Cat觉得自己去实现这个enjoy()方法也不合适，因此它把它自己也声明成一个抽象的类，
 27  * 那么，谁去实现这个抽象的enjoy方法，谁继承了子类，那谁就去实现这个抽象方法enjoy()。
 28  * @author gacl
 29  *
 30  */
 31 abstract class Cat extends Animal {
 32 
 33     /**
 34      * Cat添加自己独有的属性
 35      */
 36     public String eyeColor;
 37 
 38     public Cat(String n, String c) {
 39         super(n);//调用父类Animal的构造方法
 40         this.eyeColor = c;
 41     }
 42 }
 43 
 44 /**
 45  * 子类BlueCat继承抽象类Cat，并且实现了从父类Cat继承下来的抽象方法enjoy
 46  * @author gacl
 47  *
 48  */
 49 class BlueCat extends Cat {
 50 
 51     public BlueCat(String n, String c) {
 52         super(n, c);
 53     }
 54 
 55     /**
 56      * 实现了抽象方法enjoy
 57      */
 58     @Override
 59     public void enjoy() {
 60         System.out.println("蓝猫叫...");
 61     }
 62     
 63 }
 64 
 65 /**
 66  * 子类Dog继承抽象类Animal，并且实现了抽象方法enjoy
 67  * @author gacl
 68  *
 69  */
 70 class Dog extends Animal {
 71     /**
 72      * Dog类添加自己特有的属性
 73      */
 74     public String furColor;
 75 
 76     public Dog(String n, String c) {
 77         super(n);//调用父类Animal的构造方法
 78         this.furColor = c;
 79     }
 80 
 81     @Override
 82     public void enjoy() {
 83         System.out.println("狗叫....");
 84     }
 85 
 86 }
 87 
 88 public class TestAbstract {
 89 
 90     /**
 91      * @param args
 92      */
 93     public static void main(String[] args) {
 94 
 95         /**
 96          * 把Cat类声明成一个抽象类以后，就不能再对Cat类进行实例化了，
 97          * 因为抽象类是残缺不全的，缺胳膊少腿的，因此抽象类不能被实例化。
 98          */
 99         //Cat c = new Cat("Catname","blue");
100         Dog d = new Dog("dogname","black");
101         d.enjoy();//调用自己实现了的enjoy方法
102         
103         BlueCat c = new BlueCat("BlueCatname","blue");
104         c.enjoy();//调用自己实现了的enjoy方法
105     }
106 }

一、接口的概念

　　JAVA是只支持单继承的，但现实之中存在多重继承这种现象，如“金丝猴是一种动物”，金丝猴从动物这个类继承，同时“金丝猴是一种值钱的东西”，金丝猴从“值钱的东西”这个类继承，同时“金丝猴是一种应该受到保护的东西”，金丝猴从“应该受到保护的东西”这个类继承。这样金丝猴可以同时从 “动物类”、“值钱的东西类”、“应该受到保护的东西” 这三个类继承，但由于JAVA只支持单继承，因此金丝猴只能从这三个类中的一个来继承，不能同时继承这三个类。因此为了封装现实生活中存在的多重继承现象，为了实现多继承，可以把其中的两个类封装成接口。使用接口可以帮助我们实现多重继承。

　　接口的本质——接口是一种特殊的抽象类，这种抽象类里面只包含常量和方法的定义，而没有变量和方法的实现。

　　抽象类所具有的一些东西接口可以具有，假如一个抽象类里面所有的方法全都是抽象的，没有任何一个方法需要这个抽象类去实现，并且这个抽象类里面所有的变量都是静态(static)变量，都是不能改变(final)的变量，这时可以把这样的抽象类定义为一个接口(interface)。把一个类定义成一个接口的格式是把声明类的关键字class用声明接口的关键字interface替换掉即可。

1 /**
2  * java中定义接口
3  */
4 public interface JavaInterfaces {
5 
6 }

　　接口(interface)是一种特殊的抽象类，在这种抽象类里面，所有的方法都是抽象方法，并且这个抽象类的属性（即成员变量）都是声明成“public static final 类型属性名”这样的，默认也是声明成“public static final”即里面的成员变量都是公共的、静态的，不能改变的。因此在接口里面声明常量的时候，可以写成“public static final 类型常量名=value(值)”这样的形式，也可以直接写成“类型常量名=value(值)”如：“public static final int id=10”可以直接写成“int id=10”这样的形式，因为在接口里面默认的属性声明都是“public static final”的，因此“public static final”可以省略不写。在接口里面声明的抽象方法可以不写abstract关键字来标识，因为接口里面所有的方法都是抽象的，因此这个“abstract”关键字默认都是省略掉的，如在一个接口里面声明这样的三个方法：“public void start()”、“public void run()”、“public void stop()”这三个方法前面都没有使用abstract关键字来标识，可它们就是抽象方法，因为在接口里面的声明的方法都是抽象方法，因此在接口里面的抽象方法都会把abstract关键字省略掉，因为默认声明的方法都是抽象的，所以就没有必要再写“abstract”字了，这一点与在抽象类里面声明抽象方法时有所区别，在抽象类里面声明抽象方法是一定要使用“abstract”关键字的，而在接口里面声明抽象方法可以省略掉“abstract”。注意：在接口里面声明的抽象方法默认是“public(公共的)”的，也只能是“public(公共的)”之所以要这样声明是为了修正C++里面多重继承的时候容易出现问题的地方，C++的多继承容易出现问题，问题在于多继承的多个父类之间如果他们有相同的成员变量的时候，这个引用起来会相当地麻烦，并且运行的时候会产生各种各样的问题。JAVA为了修正这个问题，把接口里面所有的成员变量全都改成static final，成员变量是static类型，那么这个成员变量就是属于整个类里面的，而不是专属于某个对象。对于多重继承来说，在一个子类对象里面实际上包含有多个父类对象，而对于单继承来说，子类对象里面就只有一个父类对象。多继承子类对象就有多个父类对象，而这些父类对象之间可能又会存在有重复的成员变量，这就非常容易出现问题，因此在JAVA里面避免了这种问题的出现，采用了接口这种方式来实现多继承。作为接口来说，一个类可以从接口继承（或者叫实现接口），这也是多继承，接口里面的成员变量不专属于某个对象，都是静态的成员变量，是属于整个类的，因此一个类去实现多个接口也是无所谓的，不会存在对象之间互相冲突的问题。实现多个接口，也就实现了多重继承，而且又避免了多重继承容易出现问题的地方，这就是用接口实现多重继承的好处。

二、接口特性

2.1.接口举例

  1 package javastudy.summary;
  2 
  3 /**
  4  * 这里定义了接口：Painter。 在Painter接口里面定义了paint()和eat()这两个抽象方法。
  5  * 
  6  * @author gacl
  7  * 
  8  */
  9 interface Painter {
 10     public void eat();
 11 
 12     public void paint();
 13 }
 14 
 15 /**
 16  * 这里定义了两个接口：Singer 在Singer接口里面定义了sing()和sleep()这两个抽象方法。
 17  * 
 18  * @author gacl
 19  * 
 20  */
 21 interface Singer {
 22     public void sing();
 23 
 24     public void sleep();
 25 }
 26 
 27 /**
 28  * 类Student实现了Singer这个接口
 29  * 
 30  * @author gacl
 31  * 
 32  */
 33 class Student implements Singer {
 34 
 35     private String name;
 36 
 37     public Student(String name) {
 38         this.name = name;
 39     }
 40 
 41     public String getName() {
 42         return name;
 43     }
 44 
 45     public void setName(String name) {
 46         this.name = name;
 47     }
 48 
 49     /**
 50      * 实现接口中定义的sing方法
 51      */
 52     @Override
 53     public void sing() {
 54         System.out.println("student is singing");
 55     }
 56 
 57     /**
 58      * 实现接口中定义的sleep方法
 59      */
 60     @Override
 61     public void sleep() {
 62         System.out.println("student is sleeping");
 63     }
 64 
 65     public void study() {
 66         System.out.println("Studying...");
 67     }
 68 
 69 }
 70 
 71 /**
 72  * Teacher这个类实现了两个接口：Singer和Painter。 这里Teacher这个类通过实现两个不相关的接口而实现了多重继承。
 73  * 
 74  * @author gacl
 75  * 
 76  */
 77 class Teacher implements Singer, Painter {
 78 
 79     private String name;
 80 
 81     public Teacher(String name) {
 82         this.name = name;
 83     }
 84 
 85     /**
 86      * 在Teacher类里面重写了这两个接口里面的抽象方法，
 87      * 通过重写抽象方法实现了这两个接口里面的抽象方法。
 88      */
 89     @Override
 90     public void eat() {
 91         System.out.println("teacher is eating");
 92     }
 93 
 94     public String getName() {
 95         return name;
 96     }
 97 
 98     @Override
 99     public void paint() {
100         System.out.println("teacher is painting");
101     }
102 
103     public void setName(String name) {
104         this.name = name;
105     }
106 
107     @Override
108     public void sing() {
109         System.out.println("teacher is singing");
110     }
111 
112     @Override
113     public void sleep() {
114         System.out.println("teacher is sleeping");
115     }
116 
117     public void teach() {
118         System.out.println("teaching...");
119     }
120 }
121 
122 public class TestInterfaces {
123 
124     public static void main(String[] args) {
125         /**
126          * 这里定义了一个接口类型的变量s1
127          */
128         Singer s1 = new Student("le");
129         s1.sing();
130         s1.sleep();
131         Singer s2 = new Teacher("steven");
132         s2.sing();
133         s2.sleep();
134         Painter p1 = (Painter)s2;
135         p1.paint();
136         p1.eat();
137     }
138 }

　　这里验证了两个规则，“一个类可以实现多个无关的接口”，Teacher类既实现了Singer接口，同时也实现了Painter接口，而Singer接口和Painter接口是无关系的两个接口。“多个无关的类可以实现同一接口”，Student类和Teacher类都实现了Singer接口，而Student类和Teacher类并不是关系很密切的两个类，可以说是无关的两个类。

运行结果：

2.2.画内存分析图体会接口与实现类之间存在的多态性

　　首先分析main方法的第一句话

　　　Singer s1 = new Student(“le”);

　　这里首先定义了一个接口类型的变量s1，接口Singer是Student类实现的，即相当于Student类从Singer接口继承，Singer接口的本质是一个特殊的抽象类，所以这里Singer接口就是Student类的父类，因此s1就是父类对象的一个引用，即这里这句话执行完后就是一个父类对象s1的引用指向子类对象Student。所以内存里面的布局应该是这样：栈空间里面有一个父类对象的引用s1,堆空间里面new出了一个Student对象，创造这个Student对象的时候调用了Student类的构造方法Student(String name)，其定义如下：

　　Student(String name){

　　　　this.name = name;

　　}

　　通过调用构造方法使得这个Student对象有了一个自己的名字“le”，因此堆内存里面的Student对象的name属性值为“le”。

　　这个Student对象能够访问位于代码区里面的sleep()方法和sing()方法，因为Student类从父类Sing继承而来，因此自然可以访问到这两个方法，除此之外，还能访问Student类里面自定义的Study()方法。因此代码区里面存放着这三个方法等待着Student类的对象去访问，也就是去调用。一个正常的Student可以直接调用这三个方法。那么怎么找得到位于代码区的这三个方法呢？Student对象里面存在着能找得到这个三个方法的函数指针，引用对象通过这个指针的索引指向就能找到代码区里面的这三个方法。

　　s1是父类对象的索引，但此时s1指向的却是子类对象，即一个父类对象的索引指向了子类对象。这里很不幸的是，由于这个s1是一个父类对象的引用，站在s1的角度上，它就是只把你这个子类对象Student当成是一个Singer，s1只能看到Student对象里面的sing()和sleep这两个方法的方法指针，因此使用这个s1引用对象只能去访问从父类继承下来的sleep()和sing()这两个方法，但由于这两个方法在子类Student里面被重写了，那么现在就是这种情况了，子类Student从父类Singer继承，在子类里面重写了从父类继承下来的sing()和sleep()这两个方法，父类对象的引用指向了子类对象，这三种情况加在一起就使得多态可以存在了，这样调用位于代码区里面的方法时，会根据new出来的实际对象去调用代码区里面的方法，因此这里在s1眼里虽然是把这个new出的Student当成一个Singer，但这个对象实际上就是一个Student，因此使用父类对象的引用s1调用代码区里面的sleep()和sing()方法时，调用的是在子类里面重写过后的sing()和sleep()方法。

　　接着分析第二句话

　　　　Singer s2 = new Teacher(“steven”);

　　Teacher这个类实现了Singer接口和Painter接口，即相当于从两个父类继承，一个父类是Singer，另一个父类是Painter。

　　这里的s2也是父类对象Singer的引用，指向的却是子类对象Teacher，因此也是一个父类对象的引用指向子类对象。

　　创造这个Teacher对象的时候，调用Teacher(String name)构造方法，其定义如下：

　　　　Teacher(String name){

　　　　　　this.name=name;

　　　　}

　　调用构造方法后，Teacher有了自己的名字steven，所以Teacher的name属性值为steven，由于这个Teacher实现了Painter接口和Singer接口，因此也继承这两个接口里面的方法，因此一个正常的Teacher可以访问的方法有：paint()、eat()和sing()、sleep。前面两个方法是从Painter类继承过来的，后面两个方法是从Singer类继承过来的。除了这四个方法外，还有自己定义的Teach()方法。可是很不幸的是，由于s2是一个Singer类对象的引用，因此站在s2的角度来看，它只把Teacher当成是一个普通的Singer，因此它看到的只是Teacher对象里面的sing()和sleep()这两方法，然后要调用时就通过Teacher对象里面的函数指针找到位于代码区的sleep()和sing()这两个方法。别的方法s2是看不到的，因此也调用不了。

　　Painter p1=(Painter)s2;

　　这里把s2强制转换成Painter，s2对象实际是指向Teacher的，把s2强制转换成Painter以后，就可以把Teacher当成Painter来用，所以p1会把Teacher当成Painter来看待，因此p1只能看到Teacher里面的painter()方法和eat()方法，因此能够访问到的也只有这两个方法。所以接口对于我们实际当中的对象来说，每一个接口暴露了我们这个实际对象的一部分方法。你使用什么样的接口，就只能访问这个接口里面定义的方法，别的接口定义的方法就没办法访问得到。

　　接口可以帮助我们实现多重继承这种逻辑，接口和它的实现类之间存在多态性。

2.3.通过下面这些代码验证接口更进一步的特性

  1 package javastudy.summary;
  2 
  3 /**
  4  * 把“值钱的东西”这个类定义成一个接口Valuable。在接口里面定义了一个抽象方法getMoney()
  5  * @author gacl
  6  *
  7  */
  8 interface Valuable {
  9     public double getMoney();
 10 }
 11 
 12 /**
 13  * 把“应该受到保护的东西”这个类定义成一个接口Protectable。
 14  * 在接口里面定义了一个抽象方法beProtected();
 15  * @author gacl
 16  *
 17  */
 18 interface Protectable {
 19     public void beProteced();
 20 }
 21 
 22 /**
 23  * 这里是接口与接口之间的继承，接口A继承了接口Protectable，
 24  * 因此自然而然地继承了接口Protectable里面的抽象方法beProtected()。
 25  * 因此某一类去实现接口A时，除了要实现接口A里面定义的抽象方法m()以外，
 26  * 还要实现接口A从它的父接口继承下来的抽象方法beProtected()。
 27  * 只有把这两个抽象方法都实现了才算是实现了接口A。
 28  * @author gacl
 29  *
 30  */
 31 interface A extends Protectable {
 32     void m();
 33 }
 34 
 35 /**
 36  * 这里定义了一个抽象类Animal。
 37  * @author gacl
 38  *
 39  */
 40 abstract class Animal {
 41     private String name;
 42     /**
 43      * 在Animal类里面声明了一个抽象方法enjoy()
 44      */
 45     abstract void enjoy();
 46 }
 47 
 48 /**
 49  * 这里是为了实现了我们原来的语义：
 50  * “金丝猴是一种动物”同时“他也是一种值钱的东西”同时“他也是应该受到保护的东西”。而定义的一个类GoldenMonKey。
 51  * 为了实现上面的语义，这里把“值钱的东西”这个类定义成了一个接口Valuable，
 52  * 把“应该受到保护的东西”这个类也定义成了一个接口Protectable。这样就可以实现多继承了。
 53  * GoldenMonKey类首先从Animal类继承，然后GoldenMonKey类再去实现Valuable接口和Protectable接口，
 54  * 这样就可以实现GoldenMonKey类同时从Animal类，Valuable类，Protectable类继承了，即实现了多重继承，
 55  * 实现了原来的语义。
 56  * @author gacl
 57  *
 58  */
 59 class GoldenMonKey extends Animal implements Valuable,Protectable {
 60 
 61     /**
 62      * 在GoldenMoKey类里面重写了接口Protectable里面的beProtected()这个抽象方法，
 63      * 实现了接口Protectable。
 64      */
 65     @Override
 66     public void beProteced() {
 67         System.out.println("live in the Room");
 68     }
 69 
 70     /**
 71      * 在GoldenMoKey类里面重写了接口Valuable里面的getMoney()这个抽象方法，实现了接口Valuable。
 72      */
 73     @Override
 74     public double getMoney() {
 75         return 10000;
 76     }
 77 
 78     /**
 79      * 这里重写了从抽象类Animal继承下来的抽象方法enjoy()。
 80      * 实现了这抽象方法，不过这里是空实现，空实现也是一种实现。
 81      */
 82     @Override
 83     void enjoy() {
 84         
 85     }
 86     
 87     public static void test() {
 88         /**
 89          * 实际当中在内存里面我们new的是金丝猴，在金丝猴里面有很多的方法，
 90          * 但是接口的引用对象v能看到的就只有在接口Valuable里面声明的getMoney()方法，
 91          * 因此可以使用v.getMoney()来调用方法。而别的方法v都看不到，自然也调用不到了。
 92          */
 93         Valuable v = new GoldenMonKey();
 94         System.out.println(v.getMoney());
 95         /**
 96          * 把v强制转换成p，相当于换了一个窗口，通过这个窗口只能看得到接口Protectable里面的beProtected()方法
 97          */
 98         Protectable p = (Protectable)v;
 99         p.beProteced();
100     } 
101 }
102 
103 /**
104  * 这里让Hen类去实现接口A，接口A又是从接口Protectable继承而来，接口A自己又定义了一个抽象方法m()，
105  * 所以此时相当于接口A里面有两个抽象方法：m()和beProtected()。
106  * 因此Hen类要去实现接口A，就要重写A里面的两个抽象方法，实现了这两个抽象方法后才算是实现了接口A。
107  * @author gacl
108  *
109  */
110 class Hen implements A {
111 
112     @Override
113     public void beProteced() {
114         
115     }
116 
117     @Override
118     public void m() {
119         
120     }
121     
122 }
123 
124 /**
125  * java中定义接口
126  */
127 public class JavaInterfacesTest {
128 
129     public static void main(String[] args) {
130         GoldenMonKey.test();
131     }
132 }