Java面向对象中的---抽象类，final，接口

1. final：最终的、不能改变的-----------------单独应用几率低

• 修饰变量：变量不能被改变

  class Aoo{
      final int a = 5;
      void show(){
          //a = 55; //编译错误，final的变量不能被改变
      }
  }
  

• 修饰方法：方法不能被重写

  class Boo{
      void show(){}
      final void test(){}
  }
  class Coo extends Boo{
      void show(){}
      //void test(){} //编译错误，final的方法不能被重写
  }
  

• 修饰类：类不能被继承

  final class Doo{}
  //class Eoo extends Doo{} //编译错误，final的类不能被继承
  class Foo{}
  final class Goo extends Foo{} //正确，不能当老爸，但能当儿子
  

2. static final常量：应用率高

• 必须声明同时初始化

• 常常通过类名点来访问，不能被改变

• 建议：常量名所有字母都大写，多个单词用_分隔

• 编译器在编译时，会将常量直接替换为具体的数，效率高

• 何时用：数据永远不变，并且经常使用

  public class StaticFinalDemo {
      public static void main(String[] args) {
          System.out.println(Hoo.PI); //常常通过类名点来访问
          //Hoo.PI = 3.1415926; //编译错误，常量不能被改变
  
  
          //1)加载Ioo.class到方法区中
          //2)静态变量num一并存储到方法区中
          //3)到方法区中获取num的值并输出
          System.out.println(Ioo.num);
  
          //编译器在编译时，会将常量直接替换为具体的值，效率高
          //相当于System.out.println(5);
          System.out.println(Ioo.COUNT);
      }
  }
  
  class Ioo{
      public static int num = 5; //静态变量
      public static final int COUNT = 5; //常量
  }
  
  class Hoo{
      public static final double PI = 3.14159;
      //public static final int NUM; //编译错误，常量必须声明同时初始化
  }
  

3. 抽象方法：

• 由abstract修饰
• 只有方法的定义，没有具体的实现(连{}都没有)

4. 抽象类：

• 由abstract修饰
• 包含抽象方法的类必须是抽象类
• 抽象类不能被实例化(new对象)
• 抽象类需要被继承，派生类：
  • 重写超类的所有抽象方法----------变不完整为完整
  • 也声明为抽象类----------------------不常用
• 抽象类的意义：
  • 封装共有的属性和行为-------------------代码复用
  • 为所有派生类提供统一的类型----------向上造型(代码复用)
  • 可以包含抽象方法，为所有派生类提供统一的入口(向上造型后能点出来)，同时可以达内强制必须重写的目的(相当于制定了一个标准)

5. 接口：

• 是一种数据类型(引用类型)

• 由interface定义

• 只能包含常量和抽象方法--------数据默认都是常量，方法默认都是抽象的

• 接口不能被实例化(new对象)

• 接口是需要被实现/继承的，实现类/派生类：必须重写所有抽象方法

• 一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现

• 接口可以继承接口

  
  /**
   * 接口的演示
   */
  public class InterfaceDemo {
      public static void main(String[] args) {
          //Inter5 o = new Inter5(); //编译错误，接口不能被实例化
          Inter5 o1 = new Doo(); //向上造型
          Inter4 o2 = new Doo(); //向上造型
      }
  }
  
  //演示接口的语法
  interface Inter{
      public static final int NUM = 5;
      public abstract void show();
      int COUNT = 5; //默认public static final
      void test(); //默认public abstract
      //int number; //编译错误，常量必须声明同时初始化
      //void say(){} //编译错误，抽象方法不能有方法体
  }
  
  //演示接口的实现
  interface Inter1{
      void show(); //制定规范
      void test();
  }
  class Aoo implements Inter1{
      public void show(){} //重写接口的抽象方法时，必须加public权限
      public void test(){} //--------遵守规范
  }
  
  //演示接口的多实现
  interface Inter2{
      void show();
  }
  interface Inter3{
      void test();
  }
  abstract class Boo{
      abstract void say();
  }
  class Coo extends Boo implements Inter2,Inter3{
      public void show(){}
      public void test(){}
      void say(){}
  }
  
  //演示接口继承接口
  interface Inter4{
      void show();
  }
  interface Inter5 extends Inter4{
      void test();
  }
  class Doo implements Inter5{
      public void test(){}
      public void show(){}
  }