JavaSE基础之（十一）接口

已于 2022-09-19 09:39:21 修改
阅读量340 收藏 1
点赞数 3
分类专栏： Java 文章标签： 接口 java 抽象类
于 2021-02-24 15:17:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50994235/article/details/114020693
版权

十一、接口


对于面向对象编程来说，抽象是一个极具魅力的特征。如果一个程序员的抽象思维很差，那他在编程中就会遇到很多困难，无法把业务变成具体的代码。在 Java 中，可以通过两种形式来达到抽象的目的： 抽象类、接口。

11.1 概述

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

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

    小贴士：
    引用数据类型：数组、类、接口

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

    小贴士：
    接口中的方法都是抽象方法，不允许有普通方法！

11.2 接口定义

接口通过 interface 关键字来定义，它可以包含一些常量和方法：

/**
 * @author QHJ
 * @date 2022/8/31  14:36
 * @description: 接口
 */
public interface MyInterface {
    // 常量
    String LED = "LED";

    // 抽象方法
    int getElectricityUse();

    // 静态方法
    static boolean isEnergyEfficient(String electtronicType) {
        return electtronicType.equals(LED);
    }

    // 默认方法
    default void printDescription() {
        System.out.println("电子");
    }
}

查看上面代码的反编译结果：

public interface MyInterface 
{

    public abstract int getElectricityUse();

    public static boolean isEnergyEfficient(String electtronicType)
    {
        return electtronicType.equals("LED");
    }

    public void printDescription()
    {
        System.out.println("\u7535\u5B50");
    }

    public static final String LED = "LED";
}

由此可见，接口中定义的所有变量或者方法，都会自动添加上 public 关键字。

01、MyInterface 接口中的核心知识点

  1. 接口中定义的变量会在编译的时候自动加上 public static final 修饰符（这个注意看一下反编译后的字节码），也就是说 LED 变量其实就是一个常量。

    Java 官方文档上有这样的声明：

    Every field declaration in the body of an interface is implicitly public, static, and final.（ 接口主体中的每个字段声明都是隐式公共的、静态的和最终的。）

    换句话说，接口可以用来作为常量类使用，还能省略掉 public static final ，这看似是一种不错的选择，但是这种选择并不可取。因为接口的本意是对方法进行抽象，而常量接口会对子类中的变量造成命名空间上的 “污染”。

  2. 没有使用 private、default、static关键字修饰的方法是隐士抽象的，在编译的时候会自动加上 public abstract 修饰符。也就是说上面 getElectricityUse()其实是一个抽象方法，没有方法体——这是定义接口的本意。

  3. 从 Java 8 开始，接口中允许有静态方法。静态方法无法由（实现了该接口的）类的对象调用，它只能通过接口名来调用：MyInterface.isEnergyEfficient("LED")。

    接口中定义静态方法的目的是为了提供一种简单的机制，使我们不必创建对象就能调用方法，从而提高接口的竞争力。

  4. 接口中允许定义 default方法也是从 Java 8 开始的，它始终由一个代码块组成，为实现该接口而不覆盖该方法的类提供默认实现。既然要提供默认实现，就要有方法体，换句话说，默认方法后面不能直接使用 “;” 号来结束——编译器会报错。
    在这里插入图片描述
    允许在接口中定义默认方法的理由很充分，因为一个接口可能有多个实现类，这些类就必须实现接口中定义的抽象类，否则编译器就会报错。假如我们需要在所有的实现类中追加某个具体的方法，在没有 default 方法的帮助下，我们就必须挨个对实现类进行修改。

02、结论

  1. 接口中允许定义变量
  2. 接口中允许定义抽象方法
  3. 接口中允许定义静态方法（Java 8 之后）
  4. 接口中允许定义默认方法（Java 8 之后）

03、扩展

  1. 接口中没有构造方法，不允许直接实例化，否则编译器会报错。
    在这里插入图片描述
    需要定义一个类去实现接口，然后再实例化：

    /**
 * @author QHJ
 * @date 2022/8/31  15:16
 * @description: 接口的实现类
 */
public class MyInterfaceImpl implements MyInterface{

    public static void main(String[] args) {
        new MyInterfaceImpl();
    }

    @Override
    public int getElectricityUse() {
        return 0;
    }
}


/**
 * @author QHJ
 * @date 2022/8/31  14:41
 * @description:
 */
public class InterfaceTest {
    public static void main(String[] args) {
        new MyInterfaceImpl();
    }
}

  2. 接口可以是空的，既可以不定义变量，也可以不定义方法。其中最典型的例子就是 Serializable 接口：

    public interface Serializable {
}

    Serializable 接口用来为序列化的具体实现提供一个标记，也就是说，只要某个类实现了 Serializable 接口，那么它就可以用来序列化了。

  3. 不要在定义接口的时候使用 final 关键字，否则会报编译错误，因为接口就是为了让子类实现的，而 final 阻止了这种行为。
    在这里插入图片描述

  4. 接口的抽象方法不能是 private、protected、final，否则编译器都会报错：
    在这里插入图片描述

  5. 接口中无法定义成员变量，但是可以定义变量，变量其实是隐式 public static final（常量），所以其值无法改变。

    //默认是一个静态常量，不可以被修改
(static final) int age = 20;

  6. 接口中没有静态代码块。

11.3 接口可以做什么？

01、使某些类具有某些功能

使某些实现类具有我们想要的功能。比如：实现了 Cloneable 接口的类具有拷贝的功能，实现了 Comparable 或 Comparator 的类具有比较功能。
在这里插入图片描述

Cloneable 和 Serializable 一样都属于标记性接口，它们内部都是空的。实现了 Cloneable 接口的类可以使用 Object.clone() 方法，否则会抛出 CloneNotSupportedException。

/**
 * @author QHJ
 * @date 2022/8/31  15:37
 * @description: 使实现类具有某些功能
 */
public class CloneableTest implements Cloneable {
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        CloneableTest test1 = new CloneableTest();
        CloneableTest test2 = (CloneableTest) test1.clone();
    }
}

在这里插入图片描述

02、通过接口实现多继承

Java 原则上只支持单一继承，但通过接口可以实现多重继承的目的。

如果有两个类共同继承一个父类，那么父类的方法就会被两个子类重写。然后，如果有一个新类同时继承了这两个子类，那么在调用重写方法的时候编译器就不能识别要调用哪个类的方法了。这也正是著名的菱形问题：
在这里插入图片描述
ClassC 同时继承了 ClassA 和 ClassB，ClassC 的对象在调用 ClassA 和 ClassB 中重写的方法时，就不知道该调用 ClassA 的方法还是 ClassB 的方法。

但是接口就没有这方面的困扰。定义两个接口 Fly 和 Run，一个实现类 Dog：

/**
 * @author QHJ
 * @date 2022/8/31  16:37
 * @description: Fly接口
 */
public interface Fly {
    void fly();
}


/**
 * @author QHJ
 * @date 2022/8/31  16:38
 * @description: Run接口
 */
public interface Run {
    void run();
}

Dog 类同时实现这两个接口：

/**
 * @author QHJ
 * @date 2022/8/31  16:39
 * @description: 狗类
 */
public class Dog implements Fly, Run {
    @Override
    public void fly() {
        System.out.println("会飞的狗");
    }

    @Override
    public void run() {
        System.out.println("会跑的狗");
    }
}

在某种形式上，接口实现了多重继承的目的：在现实世界里，狗的确只会跑，但是在某些虚幻的梦境中，狗是会飞的。这就意味着需要赋予这只狗更多的能力，通过抽象类是无法实现的，只能通过接口。

03、实现多态

多态，通俗的理解就是同一件事发生在不同的对象上会产生不同的结果。就好比鼠标的左键可以点击 × 来关闭一个页面，也可以点击超链接打开新的页面。

多态可以通过继承的关系实现，也可以通过接口的形式实现：

/**
 * @author QHJ
 * @date 2022/8/31  16:46
 * @description: 形状接口
 */
public interface Shape {
    String name();
}

Circle 类和 Square 类分别实现了 Shape 接口，并重写了 name() 方法：

/**
 * @author QHJ
 * @date 2022/8/31  16:47
 * @description:
 */
public class Circle implements Shape{
    @Override
    public String name() {
        return "圆形";
    }
}


/**
 * @author QHJ
 * @date 2022/8/31  16:47
 * @description:
 */
public class Square implements Shape{
    @Override
    public String name() {
        return "正方形";
    }
}

测试类：

/**
 * @author QHJ
 * @date 2022/8/31  14:41
 * @description: 接口测试类
 */
public class InterfaceTest {
    public static void main(String[] args) {
        List<Shape> shapes = new ArrayList<>();
        Shape circleShape = new Circle();
        Shape squareShap = new Square();

        shapes.add(circleShape);
        shapes.add(squareShap);

        for (Shape shape : shapes){
            System.out.println(shape.name()); // 圆形 正方形
        }
    }
}

这就实现了多态，变量 circleShape 和 squareShap 的引用类型都是 Shape，但执行 shape.name() 方法的时候，Java 虚拟机知道该去调用 Circle 的 name() 方法还是 Square 的 name() 方法。

多态存在的 3 个前提：

  1. 要有继承关系，比如 Circle 类和 Square 类都实现了 Shape 接口；
  2. 子类要重写父类的方法，Circle 和 Square 都重写了 name() 方法；
  3. 父类引用指向子类对象，circleShape 和 squareShape 的类型都为 Shape，但前者指向的是 Circle 对象，后者指向的是 Square 对象。

也就意味着，尽管在 for 循环中，shape 的类型都为 Shape，但在调用 name() 方法的时候，它知道 Circle 对象应该调用 Circle 类的 name() 方法，Square 对象应该调用 Square 类的 name() 方法。

11.4 基本的实现

01、实现

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

非抽象子类实现接口：

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

02、实现格式

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

03、使用

  • 抽象方法的使用

    所有抽象方法必须全部实现。

  • 默认方法的使用

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

    • 继承默认方法
    //定义接口
public interface IUSB {
    /**
     * 默认方法
     */
    public default void service2(){
        System.out.println("默认方法输出service2");
    }
}
//定义实现类
public class UDISK implements IUSB{
   @Override
    public void service2() {
    	//继承，什么都不用写，直接调用
    }
}
//测试类
public class test {
    public static void main(String[] args) {
      	IUSB iusb = new UDISK();
        iusb.service2();
    }
}
输出结果：
默认方法输出service2
    • 重写默认方法
    //定义接口
public interface IUSB {
    /**
     * 默认方法
     */
    public default void service2(){
        System.out.println("默认方法输出service2");
    }
}
//定义实现类
public class UDISK implements IUSB{
   @Override
    public void service2() {
    	//方法重写
    	System.out.println("重写默认方法输出service2");
    }
}
//测试类
public class test {
    public static void main(String[] args) {
      	IUSB iusb = new UDISK();
      	//调用重写的默认方法
        iusb.service2();
    }
}
输出结果：
重写默认方法输出service2

  • 静态方法的使用

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

    //定义接口
public interface IUSB {
    /**
     * 静态方法
     */
    public static void service3(){
        System.out.println("静态方法输出service3");
    }
}
//定义实现类
public class UDISK implements IUSB{
  //无法重写静态方法
}
//测试类
public class test {
    public static void main(String[] args) {
      	//UDISK.service3();错误，无法继承方法，也无法调用。
        IUSB.service3();
    }
}
输出结果：
静态方法输出service3

11.5 接口的多实现

01、多实现

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

02、实现格式:

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

[ ]： 表示可选操作。

03、使用

  • 抽象方法

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

    //定义多个接口
interface A {     
	public abstract void showA();     
	public abstract void show(); 
}   
interface B {     
	public abstract void showB();     
	public abstract void show(); 
}
//定义实现类
public void 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 showA();     
	public default void show(); 
}   
interface B {     
	public default void showB();     
	public default void show(); 
}
//定义实现类
public void 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");   //重名默认方法必须重写  
 	} 
}

04、优先级问题

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

//定义接口
interface A {    
	 public default void methodA(){         
	 	System.out.println("AAAAAAAAAAAA");     
	 } 
}
//定义父类
class D {     
	public void methodA(){         
		System.out.println("DDDDDDDDDDDD");     
	} 
}
//定义子类
class C extends D implements A {   
	 // 未重写methodA方法   
}
//定义测试类
public class Test {     
	public static void main(String[] args) {         
		C c = new C();         
		c.methodA();      
	} 
} 
输出结果: 
DDDDDDDDDDDD

11.6 接口的多继承

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

//定义父接口
interface A {     
	public default void method(){         
		System.out.println("AAAAAAAAAAAAAAAAAAA");     
	}
}   
interface B {     
	public default void method(){         
		System.out.println("BBBBBBBBBBBBBBBBBBB");     
	} 
}
//定义子接口
interface D extends A,B{     
	@Override     
	public default void method() {         
		System.out.println("DDDDDDDDDDDDDD");     
	} 
}

小贴士：
子接口重写默认方法时，default 关键字可以保留。
子类重写默认方法时，default 关键字不可以保留。

11.7 接口在应用中常见的三种模式

在编程领域，好的设计模式能够让我们的代码事半功倍。在使用接口的时候，经常会用到三种模式：策略模式、适配器模式和工厂模式。

01、策略模式

策略模式的思想是，针对一组算法，将每一种算法封装到具有公共接口的实现类中，接口的设计者可以在不影响调用者的情况下对算法做出改变：

// 接口：教练
interface Coach {
    // 方法：防守
    void defend();
}

// 何塞·穆里尼奥
class Hesai implements Coach {

    @Override
    public void defend() {
        System.out.println("防守赢得冠军");
    }
}

// 德普·瓜迪奥拉
class Guatu implements Coach {

    @Override
    public void defend() {
        System.out.println("进攻就是最好的防守");
    }
}

public class Demo {
    // 参数为接口
    public static void defend(Coach coach) {
        coach.defend();
    }
    
    public static void main(String[] args) {
        // 为同一个方法传递不同的对象
        defend(new Hesai());
        defend(new Guatu());
    }
}

Demo.defend() 方法可以接受不同风格的 Coach，并根据所传递的参数对象的不同而产生不同的行为，这被称为“策略模式”。

02、适配器模式

适配器模式的思想是，针对调用者的需求对原有的接口进行转接。生活当中最常见的适配器就是HDMI（英语：High Definition Multimedia Interface，中文：高清多媒体接口）线，可以同时发送音频和视频信号。

interface Coach {
    void defend();
    void attack();
}

// 抽象类实现接口，并置空方法
abstract class AdapterCoach implements Coach {
    public void defend() {};
    public void attack() {};
}

// 新类继承适配器
class Hesai extends AdapterCoach {
    public void defend() {
        System.out.println("防守赢得冠军");
    }
}

public class Demo {
    public static void main(String[] args) {
        Coach coach = new Hesai();
        coach.defend();
    }
}

Coach 接口中定义了两个方法（defend() 和 attack()），如果类直接实现该接口的话，就需要对两个方法进行实现。

如果我们只需要对其中一个方法进行实现的话，就可以使用一个抽象类作为中间件，即适配器（AdapterCoach），用这个抽象类实现接口，并对抽象类中的方法置空（方法体只有一对花括号），这时候，新类就可以绕过接口，继承抽象类，我们就可以只对需要的方法进行覆盖，而不是接口中的所有方法。

03、工厂模式

所谓的工厂模式理解起来也不难，就是什么工厂生产什么，比如说宝马工厂生产宝马，奔驰工厂生产奔驰，A 级学院毕业 A 级教练，C 级学院毕业 C 级教练。

// 教练
interface Coach {
    void command();
}

// 教练学院
interface CoachFactory {
    Coach createCoach();
}

// A级教练
class ACoach implements Coach {

    @Override
    public void command() {
        System.out.println("我是A级证书教练");
    }
    
}

// A级教练学院
class ACoachFactory implements CoachFactory {

    @Override
    public Coach createCoach() {
        return new ACoach();
    }
    
}

// C级教练
class CCoach implements Coach {

    @Override
    public void command() {
        System.out.println("我是C级证书教练");
    }
    
}

// C级教练学院
class CCoachFactory implements CoachFactory {

    @Override
    public Coach createCoach() {
        return new CCoach();
    }
    
}

public class Demo {
    public static void create(CoachFactory factory) {
        factory.createCoach().command();
    }
    
    public static void main(String[] args) {
        // 对于一支球队来说，需要什么样的教练就去找什么样的学院
        // 学院会介绍球队对应水平的教练。
        create(new ACoachFactory());
        create(new CCoachFactory());
    }
}

有两个接口，一个是 Coach（教练），可以 command()（指挥球队）；另外一个是 CoachFactory（教练学院），能 createCoach()（教出一名优秀的教练）。然后 ACoach 类实现 Coach 接口，ACoachFactory 类实现 CoachFactory 接口；CCoach 类实现 Coach 接口，CCoachFactory 类实现 CoachFactory 接口。当需要 A 级教练时，就去找 A 级教练学院；当需要 C 级教练时，就去找 C 级教练学院。

依次类推，我们还可以用 BCoach 类实现 Coach 接口，BCoachFactory 类实现 CoachFactory 接口，从而不断地丰富教练的梯队。

EijoaHoaiQ:D
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 接口
hualoushihui的博客
07-15 178
接口 一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java 不支持多重继承。有了接口，就可以得到多重继承的效果。 另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有 is-a 的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3 机、手机、数码相机、移动硬盘等都支持 USB 连接。 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 “能..
JavaSE基础（一）
最新发布
07-19
JavaSE基础是学习Java编程语言的核心部分，涵盖了Java开发所需的各项基础知识。让我们深入探讨这些关键概念。 1. **JDK**：全称为Java Development Kit，是Java编程的基础，提供了开发和运行Java应用程序所需的所有...
java接口
miracleon的博客
09-15 172
Java 接口 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。 除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。 接口无法被实例化，...
Java 中的接口有什么作用？
weixin_30951231的博客
11-24 139
http://www.zhihu.com/question/20111251 接口的作用对于很多新手来说很不容易理解，我给大家举个例子。接口只是一个规范，所以里面的方法都是空的。假如我开了一个宠物粮店，声明所有宠物都可以来我这里买粮食，这就相当于一个接口，public interface PetRestaurant {public void buy();}当一只狗看到了，知道自己是宠物，所...
Java接口 详解（一）
热门推荐
wei_zhi的博客
10-06 12万+
一、基本概念接口（Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合。接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。如果一个类只由抽象方法和全局常量组成，那么这种情况下不会将其定义为一个抽象类。只会定义为一个接口，所以接口严格的来讲属于一个特殊的类，而这个类里面只有抽象方法和全局常量，就连构造方法也没有。范例：定义一个接口interf
JavaSE基础面试题.docx
06-11
JavaSE基础面试题涵盖了许多核心概念，以下是这些知识点的详细说明： 1. **面向对象的特征**：包括封装、继承和多态。封装是隐藏对象的属性和实现细节，仅对外提供公共访问方式；继承是子类继承父类的属性和方法，...
JavaSE基础课件
12-03
这个“JavaSE基础课件”包含了全面的Java编程基础知识，对于初学者和有经验的程序员来说，都是一个宝贵的资源，可以用来学习、复习或者巩固Java编程技能。 在JavaSE的学习中，首先会接触到的是基础语法，包括变量、...
javaSE基础
03-26
### JavaSE基础知识详解 #### 一、JavaSE概述与环境搭建 **1. JavaSE简介** JavaSE（Java Standard Edition）是Java平台的标准版本，主要应用于桌面应用软件的开发。它提供了开发Java应用程序所需的全部基本类库...
1.JavaSE基础学习笔记
06-11
### JavaSE基础学习笔记 #### 一、Java概述与历史 - **起源与发展**：Java最初由Sun Microsystems在1995年推出，后被Oracle公司收购并继续发展。Java经历了多个版本的发展，逐渐形成了Java SE（Standard Edition，...
Java 接口
05-25
Java 接口的初识学习demo
Java接口详解
云都小生
04-14 348
作者：云都小生 概述 在Java面向对象中，Java与C#同样，只支持单继承关系——即一个类只能有一个父类。但是现实中却有这样的需求——金银花是一种花，但它还是一种草药。如何解决这种需求，我们就需要用到接口。 一个类只能继承一个父类，但是一个类可以实现多个接口。 接口是一系列方法的声明，是一些列方法特征的集合，一个接口只能纯粹有方法的特征，但方法不能有实现。这是与抽象类的区...
Java 接口详解
liaofeifei_book的博客
06-15 274
接口详解 文章所涉及的资料来自互联网整理和个人总结，仅作为个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！ 1.1接口概述 接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法、成员方法，那么接口的内部主要就是封装了方法，包含抽象方法(JDK 7及以前)、默认方法和静态方法(JDK8)，私有方法(JDK9)。 1.2 定义格式 接口格式 public interface 接口名称 { // 抽象方法 // 默认方法 // 静态方法
java接口的理解
qq_51730795的博客
05-18 681
一.什么是接口 接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。 二.接口的特点 就像一个类一样，一个接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的。（即只有方法标识符，而没有方法体）。 1.用 interface 来定义。 2.java中，接口和类是并列的两个结构。 3. 抽象类和接口是两个并列的结构，抽象
Java学习————接口
T.J的博客
09-28 219
[来自菜鸟教程] Java 接口 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。 除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。 接口无法被实...
java 接口
weixin_44528681的博客
03-03 123
接口 接口就是多个类的公共规范 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法 定义接口 public interface 名称{ //j接口内容 } 接口包含的内容 java7: 1.常量 2.抽象方法 java8: 在java7的基础上还有 3.默认方法 4.静态方法 java9： 还包括 私有方法 接口使用步骤 1.接口接口不能直接使用，必须有一个“实现类”来实现该接口。 格式： public class 实现类名称 implements 接口名称{ } 2.接口的实现必须覆盖重写（实
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值