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;
     }
}