1.13抽象类及接口(附简述final关键字)

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

新老客户大回馈,云服务器低至5折

一、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 }

 

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:this引用逃逸

下一篇:Javac编译原理 《深入分析java web 技术内幕》第四章