一、抽象类

1、抽象方法

抽象方法只有声明，而没有具体的实现。也就是说没有{}。

抽象方法的声明格式为：abstract void 方法名();

2、抽象类

包含一个抽象方法的类就是抽象类 使用abstract类就是抽象类

3、特点

1.抽象类与抽象方法必须使用abstract修饰

2.抽象类不允许创建对象

3.抽象类总可以有抽象方法也可以没有抽象方法.如果抽象类中有带主体方法子类继承也可以直直接用

4.抽象类的子类使用
    a.继承抽象类,重写抽象方法
    b.抽象类的子类也可是抽象类

4.格式

public abstract class People { //关键词abstract，声明该类为抽象类
       public int age;
       public void Num() {
       }
       public abstract Name(); //声明该方法为抽象方法
}

注意:
abstract不能与final并列修饰同一个类
abstract 不能与private、static、final或native并列修饰同一个方法。

5.使用

在下面这个例子中，把打印机类封装成抽象类，把print定义成抽象类，当HPPrinter和CannonPrinter要继承printer类的时候，必须重写print函数。这样写的好处是，每个打印机都有自己打印方式，此举可以防止子类没有写明打印方式。

public abstract void Printer() {
       public void open() {
            system.out.print("打印机开启");
        }

        public void close() {
            system.out.print("打印机关闭");
        }

        abstract void print(); //把print方法定义为抽象方法
  }

public HPPrinter extends Printer {
         void print(){ //必须重写抽象方法print()  
                system.out.print("惠普打印机开始打印");
          };
}

public CanonPrinter extends Printer {
     void print(){ //必须重写抽象方法print()
              system.out.print("佳能打印机开始打印");
      };
}

接口

接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法组成

1.格式

public interface interface 接口名称{
      全局常量
      抽象方法
}

2.特点

1.使用关键字interface

2.接口的实现也必须通过子类，使用关键字implements，而且接口是可以多实现的
class A implements Inter1,Inter2{ //Inter1和Inter2是接口   
   ...
}

3.一个类可以同时继承抽象类和接口
class A extends Abs implements Inter1,Inter2{ //Abs是一个抽象类   
    ...
}

4.一个接口不能继承普通的类，但可以通过extends关键字继承多个接口，实现接口的多继承
interface Inter extends Inter1,Inter2{ //Inter、Inter1、Inter2都为接口  
     ...
}

5.接口中可以含有 变量和方法。但是要注意，接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关键字，比如private、protected、static、 final等修饰会报编译错误）

6.无构造方法

抽象类和接口的区别

接口和抽象类区别

一、语义层次

public abstract class People { //关键词abstract，声明该类为抽象类
      void Num();　　　　　　
      abstract void Name(); 　　　//声明该方法为抽象方法
}

Interface Person {
       void Num();
       void Name();
}

一、抽象类方式中，抽象类可以拥有任意范围的成员数据，同时也可以拥有自己的非抽象方法，但是接口方式中，它仅能够有静态、不能修改的成员数据（但是我们一般是不会在接口中使用成员数据），同时它所有的方法都必须是抽象的。

二、在某种程度上来说，接口是抽象类的特殊化。

三、对子类而言，它只能继承一个抽象类（这是java为了数据安全而考虑的），但是却可以实现多个接口。

二、设计层次

1、 抽象层次不同

抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。

2、 跨域不同

抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分，然后泛化成抽象类，子类继承该父类即可，但是接口不同。实现它的子类可以不存在任何关系，共同之处。例如猫、狗可以抽象成一个动物类抽象类，具备叫的方法。鸟、飞机可以实现飞Fly接口，具备飞的行为，这里我们总不能将鸟、飞机共用一个父类吧！所以说抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a" 关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的， 仅仅是实现了接口定义的契约而已。

3、 设计层次不同

对于抽象类而言，它是自下而上来设计的，我们要先知道子类才能抽象出父类，而接口则不同，它根本就不需要知道子类的存在，只需要定义一个规则即可，至于什么子类、什么时候怎么实现它一概不知。比如我们只有一个猫类在这里，如果你这是就抽象成一个动物类，是不是设计有点儿过度？我们起码要有两个动物类，猫、狗在这里，我们在抽象他们的共同点形成动物抽象类吧！所以说抽象类往往都是通过重构而来的！但是接口就不同，比如说飞，我们根本就不知道会有什么东西来实现这个飞接口，怎么实现也不得而知，我们要做的就是事前定义好飞的行为接口。所以说抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。

实例:

现在有个鸟类，鸟的属性有种类，颜色，重量等，鸟的行为有吃，飞。但是有的鸟类只会奔跑不会飞(鸵鸟)。这时如果我们在一个Birds类中去定义飞和奔跑的行为，分别让只会飞的鸟和只会奔跑的鸟都去继承这个类，好像有些不太妥当。我们可以这样解决：定义一个抽象类，属性包括种类、颜色、重量，行为包括吃。在定义一个Fly接口，包含一个方法fly()。在定义一个Run接口，包含一个run()方法。如果只是会飞的鸟我们就继承Birds类，实现Fly接口。如果只是会奔跑的鸟我们就实现Birds类，实现Run接口。如果继承Birds类，实现了Fly和Run接口，那就是又会飞又会奔跑的鸟。实现代码如下：

定义鸟的抽象类其中用3个成员变量一个eat的抽象方法,一个print方法
public abstract class Birds { 
         private String type; 
         private String color; 
         private double weight; 

         public Birds(String type, String color, double weight){ 
                this.setType(type); 
               this.setColor(color); 
               this.setWeight(weight); 
           } 

         public abstract void eat();

         public void print(){ 
              System.out.println("种类："+this.getType()); 
              System.out.println("颜色："+this.getColor()); 
              System.out.println("重量:"+this.getWeight()); 
        }

       public String getType() { 
             return type; 
       }
      public void setType(String type) { 
            this.type = type;
       } 
      public String getColor() { 
          return color; 
       } 
       public void setColor(String color) { 
          this.color = color; 
       } 
     public double getWeight() { 
        return weight; 
     } 
    public void setWeight(double weight) { 
        this.weight = weight; 
    } 
}

定义飞的接口
public interface Fly { 
    void fly(); 
} 

定义跑的接口
public interface Run { 
    void run(); 
} 

/**
* 蜂鸟 继承抽象类,实现Fly的接口
*/ 
public class HummingBird extends Birds implements Fly {
     public HummingBird(String type, String color, double weight){ 
         super(type, color, weight); 
     }

    @Override 
    public void fly() {
        //实现飞接口中的方法
        System.out.println("我是"+this.getType()+",我会fly。"); 
    } 

   @Override 
   public void eat() {
   //实现抽象类中的抽象方法
    System.out.print("我是"+this.getType()+",我吃花蜜。"); 
   } 
} 

/**
* 鸵鸟
*/  

public class OstrichBirds extends Birds implements Run {
       public OstrichBirds(String type, String color, double weight) { 
           super(type, color, weight); 
        } 

     @Override
       public void run() { 
       System.out.println("我是"+this.getType()+",我会奔跑。"); 
       }     

      @Override 
       public void eat() { 
       System.out.println("我是"+this.getType()+",我吃草。"); 
      } 
} 

public class Test { 
     public static void main(String [] args){ 
          //蜂鸟 
         Birds hummingBirds =new HummingBird("蜂鸟", "彩虹色", 2.3); 
         hummingBirds.print(); 
         hummingBirds.eat(); 
         Fly f = (Fly) hummingBirds; 
         f.fly();  

       //鸵鸟 
        OstrichBirds ostrichBirds =new OstrichBirds("鸵鸟", "灰色", 200.2); 
        ostrichBirds.print(); 
        ostrichBirds.eat(); 
        ostrichBirds.run(); 

        System.out.println("是否会飞=>"+(hummingBirds instanceof Fly)); 
        }
}