抽象类和接口

于 2020-11-25 22:07:14 发布
阅读量98 收藏 1
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52284319/article/details/110100186
版权

抽象类

抽象的概述

​ 父类当中的方法，被子类们重写，而子类的各自实现不一样，那么父类的方法声明和方法体，只有声明还有意义，而方法体内容则没有存在的意义。我们把这种没有方法体内容的方法称为抽象方法。Java语言规定，如果一个类包含了抽象的方法，那么该类就是一个抽象类。

定义：

​ 抽象方法：没有方法体的方法

​ 抽象类：包含抽象方法的类

关键字的使用格式

抽象方法：

​ 使用abstract关键字修饰成员方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体，去掉花括号加分号

定义格式：

修饰符 abstract 返回值类型 方法名(参数列表);

实例代码

public abstract void run();

抽象类

​ 如果一个类包含了抽象方法，那么该类就是一个抽象类。

定义格式:

修饰符 abstract class ClassNmae {};

示例代码

public abstract class Animal{
    //奔跑的抽象方法
    public abstract void run();
}
public abstract class People{
    public abstract void eat();
}
抽象的使用

继承抽象类的子类必须重写父类的所有的抽象方法，否则，该子类也必须声明为一个抽象类。

注意事项

关于抽象类的使用需要注意的事项

  1. 抽象类不能直接创建new抽象类对象，如果创建对象，编译无法通过，只能创建其非抽象子类的对象。

  2. 抽象类中，可以有构造方法，时供子类创建对象时，初始化父类成员使用的

  3. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类

  4. 抽象类子类，必须重写父类中的所有的抽象方法，否则编译无法通过，除非该子类也是抽象类

重写实现：子类重写父类当中的抽象方法，去掉抽象方法当中的abstract关键字，然后添加方法体 和 { }

方法重写，是子类对父类抽象方法的完全实现，我们将这种重写操作，叫做方法实现

  • 能够写出定义接口的格式
  • 能够写出实现接口的格式
  • 能够说出接口的成员特点
  • 能够说出使用多态的前提条件
  • 理解多态的向上转型
  • 理解多态的向下转型
  • 能够使用多态和接口完成相应的案例开发

接口

概述：

​ 接口是Java语言中的一种引用类型，是方法的集合，如果说类的内部封装了成员变量，构造方法，成员方法，那么接口的内部主要就是封装了方法，包含了抽象方法(JDK1.7及以前)，默认方法和静态方法(JDK1.8),私有方法(JDK1.9)

接口的定义，它与类的定义很相似，但不再使用class关键字进行声明,而是用interface关键字进行声明，但一定要明确它并不是类，而是另外的一种引用数据类型。

接口的使用不能直接创建对象，但可以被实现(interface关键字，类似于被继承)，一个实现接口的类可以看作接口的子类，需要重写接口中的所有的抽象方法，创建该类对象，就可以调用方法了

接口就是多个类的公共规范，接口也是一种引用类型数据，如:类 数组 接口

备注:源文件还是.java,编译之后生成的字节码文件还是.class

格式：
public interface 接口名称{
 	//接口内容
 	//抽象方法 为主(JDK1.7)
    //常量(JDK1.7)
    //默认方法(JDK1.8)
    //静态方法(JDK1.8)
    //私有方法(JDK1.9)
}

含有抽象方法

​ 抽象方法：使用abstract关键字修饰，没有方法体内容，该方法主要是提供子类使用的（重写）

public interface InterfaceName{
    public abstract void method();
    //public abstract 可以默认不写
}

还有默认方法和静态方法

​ 默认方法：使用default关键字修饰的方法，不可省略，供子类调用或重写

​ 静态方法：使用static关键字修饰的方法，供接口直接调用

还有私有的方法和私有静态方法

​ 私有方法：使用private关键字，供接口中的默认方法和静态方法调用。

代码如下：

public interface InterfaceNmae {
    private void method(){
        //方法体内容
    }
}
接口的使用步骤
1. 接口不能直接使用,必须有一个实现类来实现该接口
    	格式:

public class 实现类名称 implement 接口名称{
 	//类的成员信息
}

2. 接口的实现必须重写(实现)接口当中所有的抽象方法实现,去掉abstract关键字,分号写成大括号
3. 创建实现类的对象,进行使用
注意事项:
如果实现类当中并没有重写接口当中的所有的抽象方法,那么这个实现类必须是一个抽象类

基本事项：

实现的概述

​ 类与接口的关系，为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似于继承，格式相仿，只是关键字不同，实现使用implement关键字

非抽象类实现接口

  1. 必须重写接口当中的所有的抽象方法
  2. 继承了接口当中的默认方法，既可以直接调用，也可以重写

实现格式：

public class 实现类 implements 接口名称{
    //重写接口当中的所有的抽象方法
    //重写接口当中的默认方法【可选】
}
抽象方法的实现：

​ 必须全部实现

代码如下

public interface Biological{//生物
    //定义一个吃东西的功能
    public abstract void eat();
    //定义一个休息的功能
    public abstract void sleep();
    
}
//定义一个实现类
public class Animal implement Biological {
    @Override
    public void eat(){
        System.out.println("吃东西");
    }
    @Override
    public void sleep()}{
    System.out.println("睡觉");
	}
}
//定义测试类
public class InterfaceDemo01 {
    public static void main(String[] arge){
        //创建子类对象
        Animal ani = new Animal();
        ani.eat;
        ani.sleep;
    }
}
输出结果
//吃东西
//睡觉
默认方法的使用

可以继承的，可以重写，二选一，但是只能通过实现类的对象来调用

  1. 继承默认方法，代码如下

    public interface Biological{
    public default void fly(){
        System.out.println("天上飞")
    }
}
//定义实现类
public class Animal implement Biological {
    //继承 什么也不写 直接调用
}
//定义测试类
public class InterfaceDemo01 {
    public static void main(String[] arge){
        //创建子类对象
        Animal ani = new Animal();
        ani.fly();
    }
}
//输出结果
//天上飞

    2.重写默认方法，代码如下

    public interface Biological{
    public default void fly(){
        System.out.println("天上飞")
    }
}
//定义实现类
public class Animal implement Biological {
    @Override
    public void fly(){
        System.out.println("自由的飞");
    }
}
//定义测试类
public class InterfaceDemo01 {
    public static void main(String[] arge){
        //创建子类对象
        Animal ani = new Animal();
        ani.fly();
    }
}
//结果：
//自由的飞
静态方法的使用

静态的一般都是和类.class 文件相关。只能使用接口名调用，不可以通过实现类的类名或者实现类的对象来调用，代码如下

public interface Biological{
    public static void fly(){
        System.out.println("天上飞")
    }
}
//定义实现类
public class Animal implement Biological {
   //
}
//定义测试类
public class InterfaceDemo01 {
    public static void main(String[] arge){
        //通过类名直接调用
        Biological.fly();
    }
}
//结果：
//自由的飞
私有方法的使用

私有方法：只有默认方法可以调用

私有静态方法：默认方法和静态方法都可以调用

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度考虑，私有的方法是对默认的方法和静态的方法的一种辅助。

代码如下

//定义一个接口
public interface Biological{
    private void run1(){
        System.out.println("跑");
    }
    public default void funMerhid1(){
        //System.out.println("跑");
        run1();
    }
    public default void funMerhid2(){
        //System.out.println("跑");
        run1();
    }
    public static void fly(){
        System.out.println("天上飞")
    }
    
}
接口的多实现

在继承体系中，一个类只能直接继承一个父类，而对于接口来说，一个类可以实现多个接口，这叫做接口的多实现。一个类能直接继承一个父类同时还可以实现多个接口

实现格式：

public class ClassName entends 父类 implement 接口1，接口2...{
    //重写接口中的所有的抽象方法
    //重写接口中的默认方法
    
}

抽象方法

​ 接口当中，有多个抽象方法，实现类必须重写所用的抽象方法，如果抽象方法有重名，只需要重写一次即可，

//定义多个接口
public interface Animla{
    public abstract void eat();
    public abstract void run();
}
public interface Human{
    public abstract void eat();
    public abstract void run();
}
//定义实现类
public class People implements Animal,Human{
    @Override
    public void eat(){
        System.out.println("吃东西");
    }
     @Override
    public void run(){
        System.out.println("健身");
    }
}

默认方法

​ 接口中，有多个默认方法时，实现类都可以继承使用，如果默认方法有重名的，必须重写一次，代码如下：

public interface A {
    public default void methodA(){}
    public default void method(){}
}
public interface B {
    public default void methodB(){}
    public default void method(){}
}
//定义实现类
public class C implements A,B {
    @OVerride
    public void method(){
        System.out.println("method方法被重写..");
    }
}

静态方法

​ 接口中，如果存在同名的静态方法并不会发生冲突，原因是只能通过各自的接口名访问静态的方法。

优先级问题

​ 当一个类，即继承了一个父类，又同时定义了多个接口，父类中的成员方法与接口当中的默认方法重名，子类就近执行父类成员方法

代码如下：

public interface A{
    public default void methidA(){
        System.out.println("AAA");
    }
}
//定义父类
public class D {
    public void methodA(){
        System.out.println("DDD");
    }
}
//定义子类
public class E extends D implements A {
    //未重写methodA()方法
}
public interface InterfaceDemo06 {

	public static void main(String[] args) {
		E e = new E();
        e.methodA();
	}
}
//结果
//DDD

接口的多继承【了解】

​ 一个接口能继承另一个接口或者多个接口，这和类之间的继承比较相似，接口的继承使用extends关键字，子接口继承父接口的方法，如果父接口中的默认方法又重名，那么子接口需要重新写一次，代码如下

public interface A {
    public default void method(){
        System.out.println("AAA");
    }
}
public interface B {
    public default void method(){
        System.out.println("BBB");
    }
}
//定义子接口
public interface C extends A,B{
    @Override
    public   void method(){
        System.out.println("CCC");
    }
}

备注：子接口重写默认方法，default关键字保留。

其他成员特点：

  • 接口中无法定义成员变量，但是可以定义常量，因为值不可变，默认使用的时public static final 修饰的
  • 接口当中，没有构造方法，不能创建对象
  • 接口当中，没有静态代码块
接口的好处：
  • 设定了规则
  • 降低了耦合性，【高内聚，低耦合】
  • 可以扩展原有类的功能
接口与抽象类的异同

相同点：

  • ​ 都包含抽象方法，其子类都必须重写这些抽象方法
  • ​ 都不能直接实例化对象
  • ​ 都位于继承的顶端，用于被其他类实现或继承

区别：

  • ​ 抽象类里面可以包含普通成员方法，接口不能包含普通成员方法
  • ​ 一个类只能继承一个父类(可以是抽象类)，一个类可以实现多个接口
  • ​ 类于类之间只能是单继承关系，接口与接口之间可以多继承
  • ​ 抽象类可以定义普通的成员变量和常量，而接口只能定义常量 public static final 修饰的
无；忧
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值