手机版
你好,游客 登录 注册
背景:
阅读新闻

论Java中的抽象类与接口

[日期:2020-01-14] 来源:cnblogs.com/yhycoder  作者:coderyhy [字体: ]

抽象类和抽象方法

定义

  • 抽象方法和抽象类都必须被abstract关键字修饰。
  • 抽象——abstract,抽象类的方法不一定是抽象的,但抽象方法出现的类一定是抽象类。
//抽象方法,没有方法体(即没有{}),只有声明
abstract void f();
  • 最重要的是:抽象类,抽象既不是真的,所以,抽象类不可以实例化。但可以通过子类的实例化来使用
/**
 * @author yhy
 * 用来完成9.2的练习
 * 验证抽象类与抽象方法的使用
 */
public class YanZheng {
    public static void main(String[] args) {
//      不能被实例化,抽象类,会报错
//        ChouXiang chouxi = new ChouXiang() ;
//        可以实例child类
//        即通过继承其子类来实现不能继承抽象类
        Child test = new Child();
    }
}
abstract class AbstractChouXiang{
    /**
     * 构造函数
     */
    AbstractChouXiang() {
    }
    /**
     * 定义一个抽象类的抽象方法
     */
    abstract void chouxiang();
}
class Child extends AbstractChouXiang{
   Child(){
       System.out.println("实例时候就打印出来");
   }

    /**
     * 注意这里不是abstract就不要讲方法定义为abstract
     */
    @Override
    void  chouxiang(){
         System.out.println("继承抽象类");

    }
}
  • 子类可以不是抽象类,但要实现抽象父类中的所有抽象方法,否则必须定义为abstract类型。(下面的代码中,我将其子类的重写方法注释掉之后,就会报错must be declared abstract or implentment abstract method)

与普通类的区别以及注意点:

  • 抽象类也是可以与普通类那样,可以直接extends,区别在于抽象类不能直接实例化,可以通过实例化其子类,通过子类重写方法实现等——设置抽象方法就是让子类来实现的,否则毫无意义。

  • 与普通方法的区别

    抽象方法和空方法体的方法不是同一个概念。例如,public abstract void test();是一个抽象方法,它根本没方法体,即方法定义后面没有一对花括号;但public void test(){}方法是一个普通方法,它已经定义了方法体,只是方法体为空,即它的方法体什么也不做,因此这个方法不可使用abstract来修饰。——疯狂的Java讲义

  • abstract不能用于修饰Field,不能用于修饰局部变量,即没有抽象变量、没有抽象Field等说法;abstract也不能用于修饰构造器,没有抽象构造器,抽象类里定义的构造器只能是普通构造器

抽象类的作用

  • 《thinking in java》

    • 抽象类是普通的类与接口之间的一种中庸之道。

    • 抽象方法、抽象类可以使类的抽象性明确起来,告诉用户和编译器怎么使用它们;

    • 同时,抽象类是很好的重构工具,在后期的工作中,可以实现重用性。

  • 体现一种模板的效果,从一群相似的子类提炼出一个抽象类的感觉一样,提供了一种规范,子类可以在其原来的基础上进行扩展。

  • 抽象父类可以只定义需要使用的某些方法,把不能实现的部分抽象成抽象方法,就是一中留给下一代去实现,一开始没有能力去实现,那可就给厉害的人去做,留给其子类去实现。

接口

定义

  • 特殊的“抽象类”——接口(interface):比抽象类更加抽象的是接口,在接口中所有的方法都是抽象的。就不能像上面的抽象类一样还可以有普通方法。
//省略public就变为默认级别,只能在当前包所访问
public interface Figure { 
//接口中静态成员变量
String name = "几何图形";//省略public static final 
// 绘制几何图形方法
void onDraw(); //省略public 这里是抽象方法
}
  • Java中可以implements多个接口,多继承的含义便是接入多个接口(继承只能单继承)
  • 一个类可以实现一个或多个接口,继承使用extends关键字(但接口只能继承接口),实现则使用implements关键字。

示例

  • JieKou.java
import java.text.SimpleDateFormat;

/**
 * @author yhy
 * 这个是实现接口定义的代码,在其它地方去调用
 * 这里的接口不用public的话,其它的包就访问不了
 */
public interface JieKou {
//   定义了两个常量
    /**
     * 这里定义一个df变量来获取当前时间
     */
    SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
    String AUTHOR = "yhycoder";
    /**
     * 定义一个接口的方法
     * 这里的public是多余的,在接口里面是自动为public
     */
    /*public*/ void print();
}
  • 使用接口的Java代码
//访问了其它包的接口,就是下面这个地址
import music.daima.ebook.JieKou;
import java.util.Date;

public class UseInterfaces {
    public static void main(String[] args) {
//实例化using类,实现查看代码的运行情况
        Using Shuchu = new Using();
        Shuchu.print();

    }
}

/**
 * 这里是接口继承接口
 */
interface Jiekou2 extends JieKou{
    String num = "接口2";
}

/**
 * 这里是Using类实现了JieKou和Jiekou2接口,逗号隔开
 */
class Using implements JieKou,Jiekou2 {
    /**
     * 重写了方法,调用接口定义的常量
     */
    @Override
    public void print() {
        System.out.println(AUTHOR+"在新的包里面使用接口的时间:"+df.format(new Date())+" 同时还有"+num);
    }
}

注意

  1. 接口与抽象类一样都不能被实例化
  2. 实现接口时接口中原有的抽象方法在实现类中必须实现。默认方法可以根据需要有选择实现(覆盖)。静态方法不需要实现,实现类中不能拥有接口中的静态方法。(Java 8之后)
//InterfaceA.java文件,定义一个接口 
public interface InterfaceA {
//抽象方法
    void methodA();
    String methodB();
// 默认方法
    default int methodC() {
    return "6666";
    }
// 默认方法
    default String methodD() {
    return "这是默认方法";
    }
// 静态方法
    static double methodE() {
    return 0.0;
    } 
}

实现接口代码

import xxxx.InterfaceA;
public class ABC implements InterfaceA {
    //重写
    @Override
    public void methodA() {
    }
    @Override
    public String methodB() {
    return "实现methodB方法...";
    }
    //重写覆盖,根据自己的需要来。
    @Override
    public int methodC() {
    return 500;
    } 
}
//实现类中不能有接口中的静态方法,最后一行
public class HelloWorld {
    public static void main(String[] args) {
//声明接口类型,对象是实现类,发生多态
    InterfaceA abc = new ABC();
// 访问实现类methodB方法
    System.out.println(abc.methodB());
// 访问默认方法methodC
    System.out.println(abc.methodC()); 
// 访问默认方法methodD
    System.out.println(abc.methodD()); 
// 访问InterfaceA静态方法methodE,这里不能通过实现类去使用接口的静态方法,只能通过接口名调用
    System.out.println(InterfaceA.methodE()); 
    } 
}

作用

  1. 规范,在分配不同人的任务时,接口就像是总纲一样,告诉大家去实现哪些功能模块等。(命名规范都有限制到)

最后:接口与抽象类的异同

不同

  • 接口interface,实现接口则使用implements;抽象类abstract

  • 抽象类可以有普通方法。Java 8 之前接口中只有抽象方法,而 Java 8 之后接口中也可以声明具体方法,具体方法通过声明默认方法实现。

  • 接口可以继承多个,而抽象类不可���。

  • 和类继承相似,子接口扩展某个父接口,将会获得父接口里定义的所有抽象方法、常量Field、内部类和枚举类定义。

  • 实现父接口的所有:一个类实现了一个或多个接口之后,这个类必须完全实现这些接口里所定义的全部抽象方法(也就是重写这些抽象方法);否则,该类将保留从父接口那里继承到的抽象方法,该类也必须定义成抽象类。

  • 接口定义的是一种规范,因此接口里不能包含构造器和初始化块定义。接口里可以包含Field(只能是常量)、方法(只能是抽象实例方法)、内部类(包括内部接口、枚举)定义。但抽象类与普通类一样,可以有构造器,初始化模块等。

  • 接口只有常量——接口中不能有实例成员变量,接口所声明的成员变量全部是静态常量,即便是变量不加 public static final 修饰符也是静态常量。抽象类与普通类一样各种形式的成员变量都可以声明。

相同

  • 都不能直接实例化来使用。
  • 接口和抽象类都可以包含抽象方法,实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

使用场景

  • 想要多重继承的时候——接口(功能性强,规范性)

  • 想要底层基础功能模块不断改变——抽象类(模板设计)

linux
相关资讯       Java接口  Java抽象类 
本文评论   查看全部评论 (0)
表情: 表情 姓名: 字数

       

评论声明
  • 尊重网上道德,遵守中华人民共和国的各项有关法律法规
  • 承担一切因您的行为而直接或间接导致的民事或刑事法律责任
  • 本站管理人员有权保留或删除其管辖留言中的任意内容
  • 本站有权在网站内转载或引用您的评论
  • 参与本评论即表明您已经阅读并接受上述条款