面向对象（接口）

最新推荐文章于 2022-11-14 09:35:12 发布

每一刻都是崭新的71

最新推荐文章于 2022-11-14 09:35:12 发布

阅读量226

点赞数 1

分类专栏：新手求指教求一起探讨文章标签： java 面向对象接口

本文链接：https://blog.csdn.net/qq_43298772/article/details/89398927

版权

新手求指教同时被 2 个专栏收录

90 篇文章 2 订阅

订阅专栏

求一起探讨

79 篇文章 0 订阅

订阅专栏

面向对象(接口的概述及其特点)

接口概述：

为了体现父类功能的扩展性，Java中就提供了接口来定义这些额外的拓展功能，并不给出具体实现，将来哪些子类需要使用到这些额外功能，只需要把这部分额外功能实现即可

接口特点：

接口用关键字interface表示格式:

interface 接口名 {}

类实现接口用implements表示格式:

class 类名 implements 接口名 {}

接口不能实例化

那么，接口如何实例化呢?
按照多态的方式来实例化。

接口的子类

可以是抽象类。但是意义不大。
可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

代码示例：

package org.westos.test;




/**
 * @Author: Administrator
 * @CreateTime: 2019-04-13 15:01
 */
public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Animal an = cat;
        an.eat();
        // CalcInterface 是猫的一个父接口，所以猫类也可以看成是父接口的一个子类
        CalcInterface calcInterface = cat; //接口不能直接实例化，但是可以使用多态类实例化
        calcInterface.calc();
        //多态
        CalcInterface c = new Dog();
        c.calc();
        //接口不能new 对象

    }
}

abstract class Animal {

    public abstract void eat();
}
interface CalcInterface {
    //用来定义额外功能
    public abstract void calc(); //接口中的方法只能是抽象类，即只需要声明，不需要具体实现，

}

class Cat extends Animal implements CalcInterface{
    @Override
    public void eat() {        //重写抽象类中的抽象方法
        System.out.println("猫吃鱼");
    }

    public void catcheMouse(){      子类猫类的特有方法
        System.out.println("猫抓老鼠");
    }

    @Override
    public void calc() {    //因为接口中的方法只能是抽象方法，所以实现接口时必须对抽象方法进行实现
        System.out.println("猫经过不断的努力学习，会做算术了");
    }
}

class Dog extends Animal implements CalcInterface{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void lookDoor(){
        System.out.println("狗看门");
    }


    @Override
    public void calc() {
        System.out.println("狗经过自己的学习，也学会了做算术");
    }
}

通过对接口知识的讲解以及对之前知识的理解可以知道上述代码执行结果为：

猫吃鱼
猫经过不断的努力学习，会做算术了
狗经过自己的学习，也学会了做算术

面向对象(接口的成员特点)

接口成员特点：

成员变量；只能是常量，并且是静态的；默认修饰符：public static final；建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法；默认修饰符：public abstract；建议：自己手动给出。

代码示例：

package org.westos.demo4;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-14 11:01
 */
public class MyTest {
    public static void main(String[] args) {
        //接口中成员变量的特点
        //接口中的成员变量全是静态的公共常量
        //接口中没有构造方法的
        //接口中没有非抽象方法，全是抽象方法

        int a = A.A;
        System.out.println(a);
        int num = A.num;

    }
}

interface A{
    //接口中成员变量前面有默认的修饰符  public static final
    int num=100;
    public static final  int A=1000;

   //方法前面存在默认修饰符 public abstract
    public abstract void hehe();
    void test();
}

面向对象(类与类,类与接口,接口与接口的关系)

类与类,类与接口,接口与接口的关系：

类与类：继承关系,只能单继承,可以多层继承。
类与接口：实现关系,可以单实现,也可以多实现。并且还可以在继承一个类的同时实现多个接口。
接口与接口：继承关系,可以单继承,也可以多继承。

代码示例：

package org.westos.demo5;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-14 11:06
 */
public class MyTest {
    public static void main(String[] args) {
        //类跟类之间的关系
        // 类跟类是继承关系，只能是单继承，支持多层继承
        // 类跟接口是实现关系 既可以实现一个接口，也可以实现多个接口,实现接口，必须重写接口中所有的抽象方法
        // 接口跟接口的关系，继承关系，而且可以多继承
    }

}

class Fu{}
interface A{

    void a();
}
interface C{
    void c();
}

class B extends Fu implements A,C{       类与接口可以多实现，也可以单实现


    @Override
    public void a() {

    }

    @Override
    public void c() {

    }
}

interface  E{
    void e();
}

interface F{
    void f();
    void ff();

}

interface G extends E,F{      接口可以多继承
    void g();
    void gg();

}

class V implements G{


    @Override
    public void e() {   //以下都是对接口中的抽象方法进行重写

    }

    @Override
    public void f() {

    }

    @Override
    public void ff() {

    }

    @Override
    public void g() {

    }

    @Override
    public void gg() {

    }
}

面向对象(抽象类和接口的区别)

成员区别：

抽象类：

成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象

接口：

成员变量：只可以常量
成员方法：只可以抽象

关系区别：

类与类：继承，单继承
类与接口：实现，单实现，多实现
接口与接口：继承，单继承，多继承

设计理念区别：

抽象类被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

注意：JDK1.8之后在接口中提供了用default修饰的方法，可以给出功能的具体实现，子类可以继承下去用
相当于间接实现了多继承

代码示例：

package org.westos.demo6;

/**
 * @Author: Administrator
 * @CreateTime: 2019-04-14 11:18
 */
public class MyTest2 {
    //JDK1.8之后，接口中可以定义默认方法
    public static void main(String[] args) {
     C c= new C();
     A a=c;
     a.test();
     a.test2();
     a.test3();
     B b=c;
     b.test22();
     b.test333();
    }
}

interface A{
    void hehe();
    public default void test(){
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现");
    }

    public default void test2() {
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现");
    }

    public default void test3() {
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现");
    }

}

interface B {
    void hehe();

    public default void show() {
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现？？？");
    }

    public default void test22() {
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现？？？");
    }

    public default void test333() {
        System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现？？？");
    }

}

class C implements A,B{


    @Override
    public void hehe() {

    }

    @Override
    public void test22() {
    System.out.println("JDK1.8之后接口中，可以定义默认方法，可以有方法的具体实现？？？，但是被重写了");
    }
}