Java 抽象类和接口

抽象类和接口

1.抽象类
①一个完整的类，所有方法都有实现（方法体），类可以没有方法class A{ 什么都没有}，但是有方法就肯定要有实现
②一个完整的类才可以被实例化，被new出对象来
③如果一个类暂时有方法未实现，需要被定义为抽象类（方法只有方法名，形参列表，没有方法体（未实现方法），则所在类被定义为抽象类）

抽象类的方法可以为空（没有方法体）
正常类的方法不能为空（必须有方法体）

④抽象类关键字用abstract声明

public abstract class Shape{
    int area;
    public abstract void calArea();//计算面积的空方法，需要子类去实现
}//当图形形状未知时无法给出calArea的具体实现，因此方法被定义为abstract

如果有抽象方法，一定要声明定义抽象类

//类A被定义为抽象类
    abstract class A{  }
//因此 A a = new A();这是不成立的，因为抽象类无法new出对象

⑤抽象类也是类，一个类继承于抽象类，就不能继承于其他的（抽象）类
⑥子类可以继承于抽象类，但是一定要实现父类们所有的abstract方法。如果不能全部实现，那么子类也必须被定义为抽象类。只有实现父类的所有抽象方法，才能变成完整类。

//这里定义一个Shape的抽象类
public abstract class Shape{
    int area;
    public abstract void calArea();//计算面积的空方法，需要子类实现
}

//定义了一个Rectangle类并且继承Shape这个抽象类
//子类Rectangle继承抽象类，一定要实现父类Shape的所有abstract的方法，即父类的calArea()方法
public class Rectangle extends Shape{

           int width;//宽
           int length;//长
           
     public Rectangle(int length ,int width)//构造函数，给长和宽赋值
     {
           this.length=length;
           this.width=width;
     }
     
     //实现父类的calArea()方法
     public void calArea()
     {
           System.out.println(this.length*this.width);//输出面积
           
     }//如果把这个方法注释掉，程序会报错“Rectangle必须实现Shape.calArea()这个方法”
     public static void main(String[] args){
     
           Rectangle rect =new Rectangle(10,5);//new一个对象rect出来并将其长和宽赋值进行初始化
           
           rect.calArea();//使用对象调用calArea函数，并将结果输出
       }
}//以上，Rectangle继承于Shape，那么Rectangle就必须实现calArea方法

2.接口
①如果类的所有方法都没有实现，那么这个类就算是接口interface

//注意，这里没有class，因为接口不算类
public interface Animal{  
     public void eat();//空方法
     public void move();//空方法
}

②类只可以继承（extends）一个类（被继承的类可以是抽象类也可以是普通类），但是可以实现（implements）多个接口，继承和实现可以同时（一个类可以继承于另外一个类，实现好几个接口，条件是，继承了另外一个类，例如继承抽象类，必须实现所有abstract的方法，实现多个接口，必须实现接口中所定义的所有方法）
③接口不算类，或者说是“特殊类”,所以定义接口不需要class
④保存在.java文件中，编译后也是.class字节码文件
⑤接口设计是为了弥补单根继承的不足。单根继承下，一个类只能遵循另外一个类的标准
⑥类实现接口，就必须实现所有未实现的方法。如果没有全部实现，那么只能成为一个抽象类
//第一个例子

//定义一个Animal的接口
//类实现接口，就必须实现 所有 未实现的方法
//接口方法都是public
public interface Animal{
     public void eat();//eat空方法，需要类实现
     public void move();//move空方法，需要类实现
}

//定义一个Cat类，并且实现Animal这个接口，即Cat类必须实现Animal接口所有未实现的方法eat()、move()方法
public class Cat implements Animal
{
      public void eat()
     {
           System.out.println("Cat: I  can  eat");
     }
      public void move()
     {
           System.out.println("Cat: I  can  move");
     }//如果注释掉其中的一个方法，系统会报错“Cat的方法必须实现所有的方法”
}

//第二个例子

//定义一个ClimbTree的接口
public interface ClimbTree{
     public void climb();//climb的空方法,需要类去实现
}

//定义了一个LandAnimal的抽象类，并且实现Animal这个接口
//这里有抽象方法，一定要定义声明抽象类
public abstract class LandAnimal implements Animal{

         public abstract void eat();//eat的抽象空方法，需要类去实现
         
        //move已经在LandAnimal（即该类）里面实现。
         public void move(){
              System.out.println("I  can walk  by  feet");
              
         }
 }

//定义一个Rabbit类，继承了一个LandAnimal（抽象类），并且实现ClimbTree爬树这个接口。
//子类要继承一个抽象类并且实现接口，则需要把LandAnimal和ClimbTree未实现的方法全部实现
//注意，extends必须写在implements前面，不能颠倒顺序。
public class Rabbit extends LandAnimal implements ClimbTree{

     public void climb(){
        System.out.println("Rabbit:  I  can  climb");
        
     }
     
     public void eat(){
        System.out.println("Rabbit:  I  can  eat");
        
     }
 }

//第三个例子

//Tiger实现CatFamily的接口，需要把方法全部实现
public class Tiger implements CatFamily{

      public void eat(){
           System.out.println("Tiger: I  can  eat");
           
     }
      public void move(){
           System.out.println("Tiger: I  can  move");
           
     }
      public void climb(){
           System.out.println("Tiger: I  can  climb");
     
     }
}

//继承多个接口，即CatFamily继承了Animal，ClimbTree这两个接口
public interface CatFamily extends Animal，ClimbTree{
     //eat()
     //move()
     //climb()
}

总结
①抽象类和接口的相同点：两者都不能被实例化，不能new操作
②抽象类和接口不同点：
a）抽象类abstract ，接口interface
b）抽象类可以有部分方法实现，接口所有方法不能有实现
c）一个类只能继承（extends）一个（抽象）类，实现（implements）多个接口
d）接口可以继承多个接口
e）抽象类有构造函数，接口没有构造函数
f）抽象类可以有main，也能运行，接口没有main函数
g）抽象类方法可以有private/protected，接口方法都是public