Java基础：接口、多态

最新推荐文章于 2023-09-05 21:17:15 发布
最新推荐文章于 2023-09-05 21:17:15 发布
阅读量150 收藏 2
点赞数 2
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37726813/article/details/128165516
版权

第一章 接口

1.1概述

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

接口的定义，它与定义类方式相似，但是使用 interface关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，接口。

接口的使用，它不能创建对象，但是可以被实现（interface，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

1.2 定义格式

public interface 接口名称 { 
    // 抽象方法 
    // 默认方法 
    // 静态方法 
    // 私有方法 
}

含有抽象方法

抽象方法：

使用代码如下：

public interface InterFaceName { 
    public abstract void method();
}

含有默认方法和静态方法

默认方法：使用default修饰，不可省略，供子类调用或者子类重写。

静态方法：使用static修饰，供接口直接调用。

代码如下：

public interface InterFaceName { 
    public default void method() { 
        // 执行语句 
    }
    public static void method2() { 
        // 执行语句 
    } 
}

含有私有方法和私有静态方法

私有方法：使用private修饰，供接口中的默认方法或者静态方法调用。

代码如下：

public interface InterFaceName { 
    private void method() { 
        // 执行语句 
    } 
}

1.3 基本的实现

实现的概述

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

非抽象子类实现接口：

  • 必须重写接口中所有抽象方法。

  • 继承了接口的默认方法，即可以直接调用，也可以重写。

实现格式：

class 类名 implements 接口名 { 
    // 重写接口中抽象方法【必须】 
    // 重写接口中默认方法【可选】 
}

抽象方法的使用

必须全部实现，代码如下：

定义接口：

public interface LiveAble {
    // 定义抽象方法 
    public abstract void eat(); 
    public abstract void sleep(); 
}

定义实现类：

public class Animal implements LiveAble { 
    @Override 
    public void eat() { 
        System.out.println("吃东西"); 
    }
    @Override 
    public void sleep() { 
        System.out.println("晚上睡"); 
    } 
}

定义测试类：

public class Interface_Demo { 
    public static void main(String[] args) { 
        // 创建子类对象 
        Animal animal = new Animal(); 
        // 调用实现后的方法 
        animal.eat(); 
        animal.sleep(); 
    } 
}

在这里插入图片描述

默认方法的使用

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

  • 继承默认方法，代码如下：

定义接口：

public interface LiveAble { 
    public default void fly(){ 
        System.out.println("天上飞"); 
    } 
}

定义实现类：

public class Animal implements LiveAble { 
    // 继承，什么都不用写，直接调用 
}

定义测试类：

public class Interface_Demo { 
    public static void main(String[] args) { 
        // 创建子类对象 
        Animal animal = new Animal(); 
        // 调用默认方法 
        animal.fly(); 
    } 
}

在这里插入图片描述

  • 定重写默认方法，代码如下：

定义接口：

public interface LiveAble { 
    public default void fly(){ 
        System.out.println("天上飞"); 
    } 
}

定义实现类：

public class Animal implements LiveAble { 
    @Override 
    public void fly() { 
        System.out.println("自由自在的飞"); 
    } 
}

定义测试类：

public class Interface_Demo { 
    public static void main(String[] args) { 
        // 创建子类对象 
        Animal animal = new Animal(); 
        // 调用重写方法 
        animal.fly(); 
    } 
}

在这里插入图片描述

静态方法的使用

静态与.class文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，代码如下：

定义接口：

public interface LiveAble { 
    public static void run(){ 
        System.out.println("跑起来~~~"); 
    } 
}

定义实现类：

public class Animal implements LiveAble { 
    // 无法重写静态方法 
}

定义测试类：

public class Interface_Demo { 
    public static void main(String[] args) { 
        // Animal.run(); // 【错误】无法继承方法,也无法调用 
        LiveAble.run();  
    } 
}

在这里插入图片描述

私有方法的使用

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

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

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

定义接口：

public interface LiveAble { 
    default void func(){ 
        fly01();
        fly02();
    }

    private void  fly01(){
        System.out.println("fly01  飞起来~~~~");
    }
    private void  fly02(){
        System.out.println("fly02  飞起来~~~~");
    }
}

定义测试类：

public class Interface_Demo {
    public static void main(String[] args) {
        // 创建子类对象
        Animal animal = new Animal();

        // 调用默认方法
        animal.fly();
    }
}

在这里插入图片描述

1.4 接口的多实现

在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

实现格式：

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... { 
    // 重写接口中抽象方法【必须】 // 重写接口中默认方法【不重名时可选】 
}
  • [ ]： 表示可选操作。

抽象方法

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：

定义多个接口：

public interface A { 
    public abstract void showA();
    public abstract void show(); 
}
public interface B { 
    public abstract void showB(); 
    public abstract void show(); 
}

定义实现类：

public class C implements A,B{
    @Override 
    public void showA() { 
        System.out.println("showA"); 
    }
    @Override 
    public void showB() { 
        System.out.println("showB"); 
    }
    @Override 
    public void show() { 
        System.out.println("show"); 
    } 
}

默认方法

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

定义多个接口：

interface A { 
    public default void methodA(){} 
    public default void method(){} 
}
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 methodA(){ 
    System.out.println("AAAAAAAAAAAA"); 
    } 
}

定义父类：

public class D {
    public void methodA(){
        System.out.println("DDDDDDDDDDDD");
    }
}

定义子类：

public class C extends D implements A { 
    // 未重写methodA方法 
}

定义测试类：

public class Interface_Demo2 {
    public static void main(String[] args) {
        C c = new C();
        c.methodA();
    }
}

在这里插入图片描述

1.5 接口的多继承【了解】

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

定义父接口：

public interface A { 
     public default void method(){             
         System.out.println("AAAAAAAAAAAAAAAAAAA"); 
    } 
}
public interface B {
    public default void method(){ 
        System.out.println("BBBBBBBBBBBBBBBBBBB"); 
    } 
}

定义子接口：

public interface D extends A,B{ 
    @Override 
    public default void method() { 
        System.out.println("DDDDDDDDDDDDDD"); 
    } 
}

小贴士：

  • 子接口重写默认方法时，default关键字可以保留。

  • 子类重写默认方法时，default关键字不可以保留。

1.6 其他成员特点

  • 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。

  • 接口中，没有构造方法，不能创建对象。

  • 接口中，没有静态代码块。

第二章 多态

2.1 概述

引入

多态是继封装、继承之后，面向对象的第三大特性。

生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

定义

多态：是指同一行为，具有多个不同表现形式。

2.2 多态的体现

多态体现的格式：

父类类型 变量名 = new 子类对象； 
变量名.方法名();
  • 父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

代码如下：

Fu f = new Zi(); 
f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

代码如下：

定义父类：

public abstract class Animal { 
    public abstract void eat(); 
}

定义子类：

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Animal cat = new Cat();
        // 调用的是 Cat 的 eat
        cat.eat();

        // 多态形式，创建对象
        Animal dog = new Dog();
        // 调用的是 Dog 的 eat 
        dog.eat();
    }
}

在这里插入图片描述

2.3 多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。代码如下：

定义父类：

public abstract class Animal { 
    public abstract void eat(); 
}

定义子类：

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}

定义测试类：

public class Test02 {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Cat c = new Cat();
        Dog d = new Dog();
        // 调用showCatEat
        showCatEat(c);
        // 调用showDogEat
        showDogEat(d);
        /*以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代 而执行效果一致 */
        showAnimalEat(c);
        showAnimalEat(d);
    }
    public static void showCatEat (Cat c){
        c.eat();
    }
    public static void showDogEat (Dog d){
        d.eat();
    }
    public static void showAnimalEat (Animal a){
        a.eat();
    }
}

在这里插入图片描述

由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。

当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。

不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。

所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

2.4 引用类型转换

多态的转型分为向上转型与向下转型两种：

向上转型

  • 向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型 变量名 = new 子类类型(); 
如：Animal a = new Cat();

向下转型

  • 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名; 
如:Cat c =(Cat) a;

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

转型演示，代码如下：

定义类：

public abstract class Animal {
    public abstract void eat();
}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }

    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

    public void watchHouse() {
        System.out.println("看家");
    }
}

定义测试类：

public class Test03 {
    public static void main(String[] args) {
        // 向上转型 
        Animal animal = new Cat();
        animal.eat();  // 调用的是 Cat 的 eat

        // 向下转型
        Cat cat = (Cat)animal;
        cat.catchMouse();  // 调用的是 Cat 的 catchMouse
    }
}

在这里插入图片描述

转型的异常

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test04 {
    public static void main(String[] args) {
        // 向上转型
        Animal animal = new Cat();
        animal.eat(); // 调用的是 Cat 的 eat
        // 向下转型
        Dog dog = (Dog) animal;
        dog.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
    }
}

在这里插入图片描述

这段代码可以通过编译，但是运行时，却报出了ClassCastException，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。为了避免ClassCastException的发生，Java提供了instanceof关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型 
如果变量属于该数据类型，返回true。 
如果变量不属于该数据类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test04 {
    public static void main(String[] args) {
        // 向上转型
        Animal animal = new Cat();
        animal.eat(); // 调用的是 Cat 的 eat
        // 向下转型
        //Dog dog = (Dog) animal;
        //dog.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse(); // 调用的是 Cat 的 catchMouse
        } else if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse(); // 调用的是 Dog 的 watchHouse
        }
    }
}

在这里插入图片描述

Mr.D.Chuang
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java接口,多态
qiaoqiaoqiaoyezi的博客
07-06 610
Java接口，多态
JAVA基础（10.接口和多态）
weixin_45707083的博客
05-16 417
JAVA接口和多态，让你认识不一样的基础
Java接口、多态
最新发布
qq_51149294的博客
09-05 155
public interface 接口名 {public abstract 返回值类型 方法名(参数);public default 返回值类型 方法名(形参){方法体return 结果public static 返回值类型 方法名(参数){方法体return 结果前提:必须有子父类继承关系或接口实现关系必须有方法的重写(没有重写 , 多态没有任何意义) , 多态主要是玩重写方法的new 对象 : 父类引用指向子类对象多态弊端:不能直接调用子类特有的功能。
java之多态与接口
zsl666999的博客
03-14 202
方法的递归是指在一个方法的内部调用自身的过程，递归必须要有结束的条件，不然就会陷入无限递归的状态，永远无法结束调用。​ 接口中默认成员方法都是抽象方法，并且可以省略 public abstract。只能对父类进行强转成子类，从而达到使用子类特殊的方法（重写的方法除外的方法）​ 接口中的成员属性默认都是常量，并且可以省略 static final。一个父类根据new不同的子类对象，调用同一个方法，产生不同的结果。​ 引用数据类型：地址值无法被修改（对象中的内容可以改）
java之接口的多态
Victor998的博客
11-05 1050
接口与类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中。实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。一个类可以实现多个接口，接口也可以继承其他接口。与继承关系类似，接口与实现类之间存在多态性。接口的主要用途就是被实现类实现。定义Java类的语法格式：先写。接口，实际上就是定义了一种规范。，而没有变量和方法的实现。开发中，体会面向接口编程！接口使用上也满足多态性。
Java零基础-多态.md
08-10
内容概要： 本文介绍了Java中多态...建议通过阅读相关的Java教材或搜索资料，进一步了解与多态相关的高级主题，如抽象类和接口等内容。 如有疑问，可以参考Java官方文档或向技术论坛寻求帮助，进一步加深对多态的理解。
java基础继承封装多态
04-01
本资源摘要信息将对 Java 基础知识点进行总结，涵盖继承、封装、多态等概念，并对面向对象的设计、数据库设计模式等进行讲解。 继承 继承是 Java 中的一种机制，允许一个类继承另一个类的属性和方法。继承的语法是...
Java基础教程之类型转换与多态
09-04
总的来说，Java的基础教程中，类型转换和多态是学习的重点。理解并熟练掌握这些概念，对于编写高效、可维护的Java代码至关重要。在实际开发中，类型转换可以让我们灵活地处理数据，而多态则能帮助我们设计出更加抽象...
Java基础语法之接口和多态穿拖鞋的汉子上传
07-08
Java基础语法之接口和多态 Java中的接口是一种特殊的抽象类，是功能的集合，也可以看做是一种数据类型。接口定义了应该具备的方法，但不提供具体的实现，具体的实现由接口的实现类（相当于接口的子类）来完成。这样...
java基础_多态
05-28
除了类之间的继承，多态也可以通过接口实现。一个类可以实现多个接口，从而表现出多个接口定义的行为。接口的多态性使得代码更加灵活，便于设计和维护。 ```java interface CanFly { void fly(); } interface Can...
运行时实现Java的多态性
01-08
运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成“一个接口，多个方法”。Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制，下面就继承和接口实现两方面谈谈java运行时多态性的实现。 　　一、通过继承中超类对象引用变量引用子类对象来实现 　　举例说明： 　　//定义超类superA 　　class superA 　　{ 　　int i = 100; 　　void fun() 　　{ 　　System.out.println(“This is superA”); 　　} 　　} 　　//定义superA的子类subB 　
Java接口的多态特性
weixin_52385232的博客
03-24 1344
Java接口的多态特性
java 接口 多态_Java基础-接口与多态
weixin_34252946的博客
02-20 213
一、接口1.1 接口的概念接口是功能的集合，同样可看做是一种数据类型。接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。请记住：一切事物均有功能，即一切事物均有接口。1.2 接口的定义与定义类的class不同接口定义时需要使用interface关键字。定义接口所在的仍为.java文件，虽然声明时使用的为int...
多态性知识点
clear_0217的博客
12-15 491
多态性 多态性是发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用 多态形成的三个条件： 有继承，父类定义方法，子类重写方法 父类的引用指向子类的对象Object obj = new Date(); 可以使用参数传递时多态，也可以直接创建对象时多态 多态可以用三个定义和两个方法来总结 三个定义分别是父类定义子类构建、接口定义实现类构建和抽象类定义实体类构建 两个方法分别是方法重载和方法重写 多态分为两种： 编译时多态：方法的重
java 接口，接口的特性，接口实现多态，面向接口编程
Noah_ZX的博客
04-18 768
所谓面向接口编程，在程序设计时，只关心实现类具备什么能力，而不关心实现类如何实现这个能力。面向接口编程时，面向接口的约定而不考虑接口的具体实现。也就是说，面向接口编程时，接口的定义方只关系实现类是否具备接口所定义的能力，而实现类如何被的该能力接口定义方一点都不关心。接口表示一种约定 (协议), 约定 (规范) 了实现类应该具备 (has a) 的能力。=> 实现类必须实现接口中所有的方法，所以接口规范了实现类的行为。=> 接口约定了实现类应该具备的行为。
Java接口以及多态性简单理解
tf599262681的博客
06-08 1047
对外提供的都是接口。 接口的思想： 笔记本电脑的USB接口： １.接口的出现扩展了功能 ２.接口其实就是暴露出来的规则 ３.接口的出现降低了耦合性，解耦*类用于描述是事物的共性基本功能 *接口用于定义的都是事物的额外功能接口和抽象类的区别？ 1.类与类之间是继承关系。is a 类与接口是实现关系。like a 2.抽象类中可以定义抽象和非抽象方
java接口实现多态
热门推荐
oguro的博客
11-08 1万+
多态： 父类的引用类型变量指向了子类的对象或者是接口类型的引用类型变量指向了接口实现类 的对象。 实现关系下的多态： 接口  变量  = new  接口实现类的对象。 interface Dao{ //接口的方法全部都是非静态的方法。 public void add(); public void delete(); } //接口的实现类 class U
十七、Java多态与接口
z_zsx的博客
04-10 542
1、Java接口 类似于类，但是有一些区别 （1）接口中只能声明常量 而且是静态常量 （2）关于default方法 接口中使用default修饰的方法允许有方法体 接口中使用default修饰的方法允许被实现类重写，使用实现类的实例化对象调用,执行的是实现类中重写的方法 接口中使用default修饰的方法可以被子接口继承并且子接口可以重写继承的default修饰的方法 父接口 default void fun01(){ // 在接口中使用default修饰的方法允许...
java 接口实现关系下的多态
weixin_34281537的博客
04-27 101
2019独角兽企业重金招聘Python工程师标准>>> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mr.D.Chuang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值