zoukankan      html  css  js  c++  java
  • Java抽象类及接口

    一、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 }
    复制代码
  • 相关阅读:
    【题解】【BT】【Leetcode】Populating Next Right Pointers in Each Node
    【题解】【BT】【Leetcode】Binary Tree Level Order Traversal
    【题解】【BST】【Leetcode】Unique Binary Search Trees
    【题解】【矩阵】【回溯】【Leetcode】Rotate Image
    【题解】【排列组合】【素数】【Leetcode】Unique Paths
    【题解】【矩阵】【回溯】【Leetcode】Unique Paths II
    【题解】【BST】【Leetcode】Validate Binary Search Tree
    【题解】【BST】【Leetcode】Convert Sorted Array to Binary Search Tree
    第 10 章 判断用户是否登录
    第 8 章 动态管理资源结合自定义登录页面
  • 原文地址:https://www.cnblogs.com/YWJAVA7010/p/9372559.html
Copyright © 2011-2022 走看看