抽象类和接口介绍

清疚 2023-10-11 17:41 17阅读 0赞

一、抽象类  
1.1、abstract关键字  
abstract抽象修饰符可以修饰方法和类，使用abstract修饰符修饰的方法称为抽象方法，使用abstract修饰符修饰的类称为抽象类。在抽象方法中是没有方法体的，并且以分号结尾。例如我们定义一个交通工具停止方法，如下:

public class Transport{
        //定义抽象方法
        public abstract void stop();
    }

1.2、抽象类的定义  
当一个类中具有抽象方法时，该类就被视为一个抽象类。

注意：抽象类不能创建对象也就是不能给抽象类创建类的实例（抽象类不能用new创建对象）

Transportation t=new Transportation（）；//错误的  
  
Transportation t=new Car();//正确  
当子类继承抽象类时，必须对父类中的所有抽象方法进行重写，也就是说，如果父类有两个抽象方法那么子类继承后必须实现父类的两个抽象方法，否则子类也必须定义为抽象类。如果子类把父类的所有抽象方法都进行重写了那么该子类就不是抽象类了。

例如以下代码：

public abstract class Transport {
     
        //抽象方法，需要被子类重写
        public abstract void stop();
    }
    //Car类继承自抽象类Transport，需要实现（重写）Transport类的所有抽象方法
    public class Car extends Transport {
     
        //重写Transport类的抽象方法
        @Override
        public void stop() {
            System.out.println("小轿车用刹车盘刹车");
        }
     
    }
    //Bike类继承自抽象类Transport，需要实现（重写）Transport类的所有抽象方法
    public class Bike extends Transport {
     
        //重写Transport类的抽象方法
        @Override
        public void stop() {
            System.out.println("自行车用脚刹车");
        }
     
    }
    public class Test {
     
        public static void main(String[] args) {
            //该写法错误，因为抽象类不能被实例化，需要其子类进行实例化
    //        Transport trans = new Transport(); 
            //通过子类Car进行实例化
            Transport trans = new Car();
            //通过子类Bike进行实例化
            Transport trans1 = new Bike();
            
            trans.stop();
            trans1.stop();
        }
    }

在本代码中父类的抽象方法只有一个，如果子类继承父类后对父类的所有抽象方法进行重写，那么子类就可以不是抽象类，但是如果子类继承父类后没有对父类中的所有抽象方法进行重写，那么子类就必须定义为抽象类，不然程序会出错

1.3、抽象方法的限制  
final方法不能为抽象方法，这是因为final的方法不能被重写，但是抽象方法必须经过子类重写才能被使用  
私有方法不能被定义为抽象方法，私有方法并不能被子类继承，而抽象方法必须被子类继承，然后重写实现。  
静态方法不能被定义为抽象方法，因为抽象方法所在的抽象类是不能创建对象的，也就是不能够被实例化的。但是静态方法是可以通过类名调用，这样调用抽象方法是没有任何意义的  
二、接口  
2.1、接口的定义  
接口和父类有很多相似的地方，在程序中也是这样的，但是他们表示的含义完全不同。但是接口对外提供的是一个窗口的功能，子类可以同时接收多个接口，而一个子类只能有一个父类，interface是定义接口的关键字，当有该关键字时，就表示这里定义的是一个接口，和class命名的规则相同。abstract关键字并不是必须的，如果定义时不给出系统也会自动加上。当一个类实现一个接口时，需要使用implements关键字，后面跟上接口名，位置是和extends关键字继承父类一样的。接口的定义和实现：

\[abstract\] interface<J接口名>\{  
//定义在接口中的方法与成员变量  
\}  
2.2、接口中变量的设计和使用  
在接口中定义的变量，实际上是公共的静态变量，格式为：

public static final int p=3;  
2.3、接口的定义和使用  
接口中的方法是抽象的不能直接使用，只有在实现接口的类中，重写方法后才能被使用，例如：

//通过interface关键字定义接口

public interface Fly {
     
        //会飞
        public void flyable();
    }
    //通过implements关键字实现接口
    public class Bird implements Fly {
     
        @Override
        public void flyable() {
            System.out.println("我会飞，我是一只小小鸟");
        }
     
    }
    public interface Clib {
        
        //会爬树
        public void clibable();
    }
    public class Monkey implements Clib {
     
        @Override
        public void clibable() {
            System.out.println("我会爬树，我是一只小猴子");
        }
     
    }

2.4、实现多个接口  
在实现接口时，一个类可以同时实现多个接口，当一个类实现多个接口时，需要重写所有接口中的所有方法。实现的接口之间使用逗号隔开，例如：

public interface Eat {
     
        //能吃饭
        public void eatable();
    }
    //实现多个接口，需要用逗号隔开
    public class Pig implements Eat, Fly, Clib {
     
        @Override
        public void eatable() {
            System.out.println("我是猪，我很能吃");
        }
        
        @Override
        public void clibable() {
            System.out.println("我是老母猪，我会上树");
        }
     
        @Override
        public void flyable() {
            System.out.println("我会飞，我是飞猪");
        }
     
    }

三、抽象类和接口的区别  
接口是抽象类的特殊版本。接口里的方法必须都为抽象的，而抽象类里可以为抽象的也可以有其他形式的存在。

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th style="text-align:center;">抽象类</th> 
   <th style="text-align:center;">接口</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>抽象类中可以存在非抽象方法</td> 
   <td>接口中的方法全部被修饰为公共的抽象方法</td> 
  </tr> 
  <tr> 
   <td>实现抽象类里的方法时，可以实现所有方法，也可以实现部分方法</td> 
   <td>接口里的方法必须全部实现</td> 
  </tr> 
  <tr> 
   <td>抽象类里可以有私有的方法和私有的成员变量&nbsp;</td> 
   <td>接口里的方法都被修饰为public abstract类型的；</td> 
  </tr> 
  <tr> 
   <td>接口里的变量都被修饰为public static final类型的</td> 
   <td>一个类只能继承一个抽象类，Java只支持单继承&nbsp;&nbsp; &nbsp;一个类可以实现一个接口，也可以实现多个接口</td> 
  </tr> 
 </tbody> 
</table>