zoukankan      html  css  js  c++  java
  • 1.13抽象类及接口(附简述final关键字)

    一、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 }
  • 相关阅读:
    icons、tabs、tabs2、toolbars例子详解
    list、listhorizontal、listsearch的理解
    forms、forms_toolbar例子理解
    Accelerometer
    audio,carousel的学习
    数组去空项,相同项
    require与include函数
    php下intval()和(int)转换使用与区别
    PHP需要拷到system32下的加载库及一些相关知识
    字符转义
  • 原文地址:https://www.cnblogs.com/huang-changfan/p/9368599.html
Copyright © 2011-2022 走看看