1.13抽象类及接口（附简述final关键字）

一、final

final的中文意思就是不可更改的，最终的。

1.final修饰变量，那么该变量无法更改。一旦该变量赋了初值，就不能重新赋值。

 final MAX = 1100;
 //final修饰后MAX就无法重新赋值。

2.final修饰方法

final修饰方法，那么该方法不能被子类重写，但可以重载。

 class Person{
      final void getName(){.....}
 }

 //getName()方法，无法被子类重写。

3.final修饰类

final修饰类，该类无法被继承。

二、抽象类

首先什么是抽象类，简而言之就是包含了抽象方法的类。

那什么又是抽象方法了，就是只有声明部分，但没有方法体。

完整的方法应该是

 void getName()  //方法声明
 {                      //方法体
       System.out.println("i am hcf");
 }
而抽象方法是没有方法体的，abstract void getName();

抽象方法前面必须加abstra修饰，拥有抽象方法的类称为抽象类，那么抽象类前面要加上abstract修饰。

 abstract class  Person{
     abstract void getName();
 }

下面简述抽象类的几个要点：

1.有抽象方法的类只能定义为抽象类，不然会出现错误。

 abstract class  Person{            //定义为抽象类，那么必须包含抽象方法。
        abstract void getName();  //有抽象方法，必定为抽象类
 }                                 

2.抽象类不能用new创建对象，即使你在抽象类里面添加构造方法也不行。

public class TestAbstract {
    public static void main(String[] args) {
    /*    Person stu = new Person();      */    //Person是抽象类，无法实例化
    }
}

abstract class  Person{
  abstract void getName();
  public void Person(){         //即使添加了构造方法也无法实例化。
   }                                    //只要是抽象类，就无法实例化。
}

3.抽象类中可以包含一般的方法或属性，但只能被子类调用。

 public class TestAbstract {
     public static void main(String[] args) {
         Student stu = new Student();
         stu.getName();
         stu.out();        //抽象类中的其他方法可以通过子类来调用
     }
 }

 abstract class  Person{
     abstract  void getName();
     void out(){                                   //抽象类中包含的其他方法
         System.out.println("1132");
     }
 }

 class Student extends Person{
     public void getName(){
         System.out.println("i am hcf");
     }
 }

运行结果：
i am hcf
1123

4.抽象类只能被继承。

5.子类必须实现抽象类中的抽象方法。

abstract class  Person{
    abstract  void getName();
    void out(){
        System.out.println("1132");
    }
}

class Student extends Person{
    public void getName(){         //子类必须实现抽象方法，否则会报错。
        System.out.println("i am hcf");
    }
}

到这里大家可能会问，这抽象类有什么好处，为什么要用它？

抽象类就相当于模板，子类必须遵守这个模板。

因为子类必须实现抽象类中的方法，这样可以做到设计和实现分离。

设计人员只需要定义好方法，返回值等，开发人员实现这些方法即可。

三、接口

接口比抽象类还要抽象，接口只能包含方法声明和常量。

接口说明：

1.接口只能用public 或default修饰，public修饰的接口名称必须和文件名相同（这点和public类相似）。

 public interface Fly{
        void flyStyle();
 }

 interface attack{
        int attackRange(String arms);
 }

2.一个文件中只能有一个被public修饰的接口。

3.接口可以多继承

public interface Fly{
      void flyStyle();
 }

interface Attack{
        int attackRange(String arms);
}

interface FlyArms extends Fly, Attack{  //飞行武器（FiyArams）就继承了Fly（飞行）接口和attack（攻击）接口

 }

4.接口中常量默加上public static final，写于不写都一样。

 interface Fly{
     int MIN_HIGHT = 1;   //相当于public static final int MIN_HIGHT = 1;
     void flyStyle();     //相当于public abstract void flyStyle();
 }

5.接口中的方法默认加上public abstract，写于不写都一样。

接口要点：

1.接口不可被类继承，只能被类实现（implements）。

2.接口中的方法必须实现，且方法必为public。

 public interface Fly{
       void flyStyle();
  }

 interface Attack{
         int attackRange(String arms);
 }

 class implements Fly{                        //接口只能被实现（implements）
          public void flyStyle(){             //类实现接口必须实现接口中定义好的方法。
                System.out.println("飞飞飞！");
          }
 }

3.接口不能创建实例，但可以声明引用变量类型。

 public class FramPaint {
     public static void drawFram(MyPaint p){   //(Mypaint p) 接口声明引用变量类型
         System.out.println("启动线程");        //有点像之前的多态父类声明引用子类对象。
         System.out.println("增加循环");        //这个还涉及到后面的回调函数，其实就是多态。
         System.out.println("查看消息");
         p.paint();
         System.out.println("启动缓存");

     }
     public static void main(String[] args) {
         FramPaint.drawFram(new GameFarm());    //调用静态方法可以直接类名加方法调用，
     }                                          //静态方法中只能调用静态方法。

 }

 interface MyPaint {
     void paint();
 }

 class GameFarm implements MyPaint{
     @Override
     public void paint() {
         System.out.println("GameFarm");
     }
 }

下面还有一个小例子，用于理解

 public class Test {
     public static void main(String[] args){
         FireArms fa = new FireArms();
         fa.flyStyle();
         System.out.println("攻击距离："+fa.attackRange(fa.name));
 }
 }

 interface Fly{
     void flyStyle();
 }

 interface Attack{
       int attackRange(String arms);
 }

 interface FlyArms extends Fly, Attack{}

 class FireArms implements FlyArms{
      String name = "FireArms";
      public void flyStyle(){
          System.out.println("扣动扳机飞行");
      }
      public int attackRange(String arms){
          int range = 0;
          switch(arms){
          case  "FireArms": range = 800;
          break;
          default:System.out.println("未知");
          break;
          }
          return range;
      }
 }