面向对象（四）

1、抽象类

      当一个类包含了抽象方法，该类必须使用abstract关键字来修饰，但抽象类可以不包含任何抽象方法，只需使用abstract关键字来修饰即可。抽象类是不可以被实例化的，因为在抽象类中有可能包含抽象方法，抽象方法是没有方法体的，不可以被调用。如果想调用抽象类中定义的方法，则需要创建一个子类，在子类中将抽象类中的抽象方法进行实现。

      例：

           // 定义抽象类Animal
          abstract class Animal {
                  // 定义抽象方法shout()
                 abstract void shout();
            }

         // 定义Dog类继承抽象类Animal
         class Dog extends Animal {
               // 实现抽象方法shout()
               void shout() {
                   System.out.println("汪汪……");
               }
          }

           // 定义测试类
          public class Text {
                public static void main(String[] args) {
                     Dog dog = new Dog(); // 创建Dog类的实例对象
                     dog.shout(); // 调用dog对象是的shout()方法
                 }
          }

      

2、接口

      如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另外一种方式来定义，即接口。

      例：

            interface    Test{

                 int   id  =   1 ;      //定义全局变量

                 void   breathe（）;       //定义抽象方法

                  void   run（）;

             }

        上例中抽象方法breathe（）并没有使用abstract关键字来修饰，这是因为接口中定义的方法和变量都包含一些默认修饰符。接口中定义的方法默认使用“public abstract”来修饰，即抽象方法。接口中的变量默认使用“public static final”来修饰，即全局变量。

        

       1）、   由于接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法，此时需要定义一个类，并使用implements关键字实现接口中所有的方法。

          例：

             // 定义了Animal接口
             interface Animal {
                 int ID = 1;       // 定义全局常量
                 void breathe();  // 定义抽象方法breathe()
                 void run();      // 定义抽象方法run()
              }

 

              // Dog类实现了Animal接口
              class Dog implements Animal {
                    //实现breathe()方法
                    public void breathe() {
                           System.out.println("狗在呼吸");
                    }
                  //实现run()方法
                   public void run() {
                           System.out.println("狗在跑");
                   }
           }

 

              / / 定义测试类
              public class Example11 {
                   public static void main(String args[]) {
                              Dog dog = new Dog(); //创建Dog类的实例对象
                              dog.breathe();        //调用Dog类的breathe()方法
                              dog.run();             //调用Dog类的run()方法
                    }
              }

          2）、一个接口可以使用extends关键字去继承另一个接口。

           例：

                  // 定义了Animal接口
                  interface Animal {
                        int ID = 1;       // 定义全局常量
                        void breathe();  // 定义抽象方法breathe()
                        void run();       // 定义抽象方法run()
                   }

                   // 定义了LandAnimal接口,并继承了Animal接口
                   interface LandAnimal extends Animal { // 接口继承接口
                          void liveOnland();                   // 定义抽象方法liveOnLand()
                   }

                  // 定义Dog类实现Animal接口
                  class Dog implements LandAnimal {
                        //实现breathe()方法
                        public void breathe() {
                                  System.out.println("狗在呼吸");
                        }

 
                        //实现run()方法
                        public void run() {
                                  System.out.println("狗在跑");
                        }

                       // 实现liveOnLand()方法
                       public void liveOnland() {
                            System.out.println("狗生活在陆地上");
                       }
               }

 

                // 定义测试类
                public class Example12 {
                        public static void main(String args[]) {
                             Dog dog = new Dog(); // 创建Dog类的实例对象
                             dog.breathe();        // 调用Dog类的breathe()方法
                             dog.run();             // 调用Dog类的run()方法
                             dog.liveOnland();    // 调用Dog类的liveOnland()方法
                         }
                  }

 

             总结：

                     ·接口中的方法都是抽象的，不能被实例化

                     ·当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法。

                     ·一个类通过implements关键字实现接口时，可以实现多个接口，被实现的多个接口之间要用逗号隔开。

                              interface  A  {} 

                              interface  B  {} 

                              class C   implements  A ,  B  {}

                     ·一个接口可以通过extends关键字继承多个接口，接口之间用逗号隔开。

                                interface  A  {} 

                                interface  B  {} 

                                interface  C   extends A ,  B  {}

                     ·一个类在继承另一个类的同时还可以实现接口，此时，extends关键字必须位于implements关键字之前。

                                 class A  extends  B  implements  C  {}             //先继承，再实现