Java学习之接口与多态篇

Java学习之接口与多态篇0x00前言在前面写的几篇文章里,讲了封装和继承,那么这篇文章就来讲讲第三大面向对象的特性多态吧,在此之前先接着上篇文章的抽象先来看看Java里面接口的应用。0x01

大家好,又见面了,我是全栈君,祝每个程序员都可以多学几门语言。

Java学习之接口与多态篇

0x00 前言

在前面写的几篇文章里,讲了封装和继承,那么这篇文章就来讲讲第三大面向对象的特性多态吧,在此之前先接着上篇文章的抽象先来看看Java里面接口的应用。

0x01 接口

接口在java里面属于引用数据类型,是方法的集合。如果说的类的内部封装了成员变量、构造方法和成员方法,那么接口内部主要封装了方法,包括抽象方法,默认方法和静态方法,私有方法。

接口的定义和定义类差不多,定义接口需要使用到interface关键字。虽然说他也会被编译为class文件,但是他并不是一个类,而是另一种引用数据类型。

引用数据类型:数组、接口、类

接口的使用,他和抽象类一样不能直接被创建,但是他可以被实现使用implements关键字。
一个实现接口的类可以看作是接口的子类,需要实现接口里面所有的抽象方法,创建该类的对象,就可以调用方法了,否则他必须是抽象的子类。

定义格式:

public interface 接口名{
    
}

抽象方法使用 abstract 关键字修饰,可以省略,没有方法体。该方法供子类实现使用。

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

接口里的默认方法和静态方法

默认方法:使用default进行修饰,不能省略,提供给子类或者子类重写使用。

静态方法:使用static修饰,提供给接口直接调用。

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

接口里的私有方法和静态方法

私有方法和定义私有变量一样,使用private修饰,提供给接口的默认方法和静态方法调用。

pubilc interface InterfaceName{
    
}

实现接口

类和接口的关系为实现关系,这被称为类实现接口,这类可以称为接口的实现类,基本上和抽象类有点类似,也可以称为接口的子类。实现的动作蕾仕于继承,格式几乎一致,但是是使用implements关键字,而不是extends。

实现接口必须重写所有的抽象方法

集成了接口的默认方法,可以直接调用也可以重写

接口代码:
public interface MyInterface {
    void eat();
    void sleep();

}
实现类代码:
public class Zi implements MyInterface {


    @Override
    public void eat() {
        System.out.println("吃");
    }

    @Override
    public void sleep() {
        System.out.println("睡");

    }
}

main方法代码:

public static void main(String[] args) {
        Zi zi = new Zi();
        zi.eat();
        zi.sleep();

    }

接口默认方法代码实现:

定义接口:

public interface MyInterface {
    default void eat() {
        System.out.println("吃");
        
    }
    public default void sleep(){
        System.out.println("睡");
    }

}
实现类代码:

public class Zi implements MyInterface {



}

main方法代码:

public static void main(String[] args) {
        Zi zi = new Zi();
        zi.sleep();
        zi.eat();

    }

这里接口定义的第一个方法直接defalut使用这个关键字定义默认方法,第二个加上了public这两种写法都可以,前者是省略式的写法。

实现类的任何代码都没写,只写了一个继承,默认方法是默认就定义好的,可以不用写,从实例化对象直接调用,当然也可以在实现类里面进行重写。

接口静态方法使用

静态与.class 文件相关,只能使用接口名调用,不可以通过实现类的类名或者实现类的对象调用。

接口定义:
public interface MyInterface {
    static void eat() {
        System.out.println("吃");
    }
}

实现类定义:

public class Zi implements MyInterface {

    
}

main方法代码:

public static void main(String[] args) {
        MyInterface.eat();

    }
    

这里可以看到在main方法里面,实例化一个对象,然后去访问eat方法是报错的,定义为静态的方法必须使用接口名进行访问。

私有方法的使用

私有方法:只有默认方法可以访问。

私有静态方法:只有默认方法和静态方法可以调用。

如果一个接口有多个默认方法并且重复,那么就可以提取出来封装到私有方法里面,供默认方法去调用他。

public interface LiveAble {
default void func(){
func1();
func2();
} p
rivate void func1(){
System.out.println("跑起来~~~");
} p
rivate void func2(){
System.out.println("跑起来~~~");
}
}

这种写法是jdk9的新特性,jdk8没有,此段描述纯属复制。

0x02 接口多实现

在前面说到因为java只支持单继承,所以一个类只能继承一个父类,但是对于接口来说,一个类是可以实现多个接口的,这就叫做接口的多实现,并且一个类里面可以继承一个父类,同时也实现多个接口。

格式:

class 类名 extends 父类名 impls 接口1,接口2{
    ...
}
或者
class 父类名 impls 接口1,接口2{
    ...
}

接口多实现多抽象方法

如果在多个接口中有重名的方法,该重名的方法只需重写一次。

接口多实现多个默认方法

接口中多个默认方法,实现类都可以继承使用。但是如果有重名的方法就必须重写一次。

接口1:

public interface MyInterface {
    default void method1(){
        System.out.println("我是一个没有感情的默认方法");
    }
    }
接口2:
public interface MyInterface2 {
    default void method1(){
        System.out.println("我是一个没有感情的默认方法");
    }
    }
实现类:

public class Zi implements MyInterface,MyInterface1 {
    @Override
    public void method1() {
        System.out.println("没有感情的方法");
    }
}

main方法代码:

    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method1();
    }

而接口中的静态方法就不会存在重名的问他,静态方法访问可以直接使用接口名访问静态方法。

优先级问题

一个类中如果计策了一个父类又实现了多个接口时,父类中的成员方和接口中的默认方法重名,子类就近选择执行的父类成员方法。

注意事项:

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

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

接口中,没有静态代码块。

0x03 多态

多态是面向对象的第三大特性。

多态:指同一种行为,具有不同的表现形式。

多态前提:

1.继承或者实现

2.方法的重写

3.父类引用指向子类[格式]

格式:

父类类型 变量名 = new 子类对象;
变量名.方法名();

父类类型:指向子类对象继承的父类类型,或者是实现的父类接口类型。

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

父类代码:

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


子类1代码:
public class Cat extends Animal {


    @Override
    public void play() {
        System.out.println("撸猫");
    }
}

子类2 代码:
public class Dog extends Animal{

    @Override
    public void play() {
        System.out.println("撸狗");
    }
}

main方法代码:

public static void main(String[] args) {
        Animal cat = new Cat();
        Animal dog = new Dog();
        cat.play();
        dog.play();
    }

0x04 多态引用类型转换

多态的转型分为向上转型喝向下转型两种:

我们经常用到的就是向上转型,多态本身就是子类类型向父类类型向上转换的过程。

当父类引用指向子类对象的时候,这就是向上转型。
代码:

Antmal cat = new Cat();

向下转型:父类类型向子类类型向下转换的过程,这个过程是强制的。

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

格式:

子类类型 变量名 =(子类类型)父类变量名;

在这里来说一下为什么要使用转型

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

总结:如果要调用子类拥有而父类没有的方法的时候就要使用到向下转型。

父类代码:
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("抓鱼");
    }

}

main方法代码:

public static void main(String[] args) {
        Animal cat = new Cat();
        cat.eat();
        Cat c =(Cat)cat;
        c.catchMouse();
    }

为了避免ClassCastException的发生,Java提供了 instanceof 关键字,给引用变量做类型的校验,格式如下:


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

所以,转换前,我们最好先做一个判断。

public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
if (a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}

0x05 结尾

接口与多态篇章更新完成,检测每天一个小总结。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/119956.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号