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

2018-07-27 06:23:31来源：博客园阅读 ()

一、final

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

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

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

2.final修饰方法

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

1 class Person{
2      final void getName(){.....}
3 }
4 
5 //getName()方法，无法被子类重写。

3.final修饰类

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

二、抽象类

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

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

完整的方法应该是

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

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

1 abstract class  Person{
2     abstract void getName();
3 }

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

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

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

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.抽象类中可以包含一般的方法或属性，但只能被子类调用。

 1 public class TestAbstract {
 2     public static void main(String[] args) {
 3         Student stu = new Student();
 4         stu.getName();
 5         stu.out();        //抽象类中的其他方法可以通过子类来调用
 6     }
 7 }
 8 
 9 abstract class  Person{
10     abstract  void getName();
11     void out(){                                   //抽象类中包含的其他方法
12         System.out.println("1132");
13     }
14 }
15 
16 class Student extends Person{
17     public void getName(){
18         System.out.println("i am hcf");
19     }
20 }

运行结果：
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类相似）。

1 public interface Fly{
2        void flyStyle();
3 }
4 
5 
6 interface attack{
7        int attackRange(String arms);
8 }

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，写于不写都一样。

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

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

接口要点：

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

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

 1 public interface Fly{
 2       void flyStyle();
 3  }
 4  
 5  
 6 interface Attack{
 7         int attackRange(String arms);
 8 }
 9 
10 
11 class implements Fly{                        //接口只能被实现（implements）
12          public void flyStyle(){             //类实现接口必须实现接口中定义好的方法。
13                System.out.println("飞飞飞！");
14          }
15 }

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

 1 public class FramPaint {
 2     public static void drawFram(MyPaint p){   //(Mypaint p) 接口声明引用变量类型
 3         System.out.println("启动线程");        //有点像之前的多态父类声明引用子类对象。
 4         System.out.println("增加循环");        //这个还涉及到后面的回调函数，其实就是多态。
 5         System.out.println("查看消息");
 6         p.paint();
 7         System.out.println("启动缓存");
 8         
 9     }
10     public static void main(String[] args) {
11         FramPaint.drawFram(new GameFarm());    //调用静态方法可以直接类名加方法调用，
12     }                                          //静态方法中只能调用静态方法。
13     
14 }
15 
16 interface MyPaint {
17     void paint();
18 }
19 
20 class GameFarm implements MyPaint{
21     @Override
22     public void paint() {
23         System.out.println("GameFarm");        
24     }    
25 }

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

 1 public class Test {
 2     public static void main(String[] args){
 3         FireArms fa = new FireArms();
 4         fa.flyStyle();
 5         System.out.println("攻击距离："+fa.attackRange(fa.name));
 6 }
 7 }
 8 
 9 interface Fly{
10     void flyStyle();
11 }
12 
13 
14 interface Attack{
15       int attackRange(String arms);
16 }
17 
18 interface FlyArms extends Fly, Attack{}
19 
20 
21 class FireArms implements FlyArms{
22      String name = "FireArms";
23      public void flyStyle(){
24          System.out.println("扣动扳机飞行");
25      }
26      public int attackRange(String arms){
27          int range = 0;
28          switch(arms){
29          case  "FireArms": range = 800;
30          break;
31          default:System.out.println("未知");
32          break;
33          }
34          return range;
35      }
36 }