Java接口详解

Surpass余sheng军

已于 2023-02-12 22:09:01 修改

阅读量1k

点赞数 2

分类专栏： JavaSE 文章标签： java 开发语言

于 2023-02-08 15:07:51 首次发布

By Mr.Gao

本文链接：https://blog.csdn.net/weixin_53622554/article/details/128924141

版权

JavaSE 专栏收录该内容

56 篇文章 6 订阅

订阅专栏

一.static静态关键字

定义变量不加static关键字：每个对象单独保存一个变量。
定义变量加static关键字：静态变量/类变量/共享变量 public static 数据类型变量名；所有对象会共享该变量。
如果一个变量(静态变量/类变量/共享变量)或者方法(静态方法)加了static关键字，调用的时候不需要通过对象来调用，而是可以直接通过类名来调用。

1.定义变量不加static关键字，每个对象单独保存一个变量！

package com.interfaceoop;

public class Manage {
    // 主函数
    public static void main(String[] args) {
        Test t1 = new Test();
        t1.count = 10;
        Test t2 = new Test();
        t2.count = 20;
        System.out.println("t1 = " + t1.count + "   t2 = " + t2.count); // t1 = 10   t2 = 20

    }
}
// 一个文件里面只能有一个共有类/主类
class Test{
    // 定义变量不加static关键字，每个对象单独保存一个变量
    public int count;
}

2.定义变量加static关键字：静态变量/类变量/共享变量，所有对象会共享该变量！

package com.interfaceoop;

public class Manage {
    // 主函数
    public static void main(String[] args) {
        Test t1 = new Test();
        t1.count = 10; // Test.count = 10;
        Test t2 = new Test();
        t2.count = 20;//  Test.count = 20; 静态变量的值可以修改
        System.out.println("t1 = " + t1.count + "   t2 = " + t2.count); // t1 = 20   t2 = 20

    }
}
// 一个文件里面只能有一个共有类/主类
class Test{
    // 定义变量加static关键字，所有对象会共享该变量,调用不受对象的影响
    // public static 数据类型 变量名;  静态变量/类变量/共享变量
    public static int count; 
}

二.关键字final的应用场景

final：最后，最终，不可变的。
final的作用：final用于修饰类、属性和方法。
被final修饰的类不可以被继承：public final class 类名{ };
被final修饰的方法不可以被重写：public final 返回值类型方法名（）{ };
被final修饰的属性值不可以被修改：public final 数据类型属性名 = 初始值;

三.接口

对于接口的理解：

简单的说，接口就是一种被规范的标准，只要符合这个标准就认为拥有了这种功能。
接口的表现在于对行为的抽象。
就好比插座，每个厂商生产的插座我们都可以使用，这是因为它们他们有同一个标准，这里插座就是接口。

既然都有了类，为什么还要有接口?

接口常被用作在团队开发当中
接口可以规范整个开发过程
接口被用来描述一种抽象。
因为Java不像C++一样支持多继承，所以Java可以通过接口的多实现来弥补这个局限。
接口被用来实现抽象，而抽象类也被用来实现抽象，为什么一定要用接口呢？接口和抽象类之间又有什么区别呢？

接口是一种用interface定义的类型，而抽象类是一种用class定义的类型。
原因是抽象类内部可能包含非final的变量，但是在接口中只有被public static final修饰的常量。
抽象方法只能存在于抽象类或者接口中，但是抽象类中却能存在非抽象方法，即有方法体的方法。

定义接口：public interface 接口名{ }
在接口中只有一种访问修饰符就是public，因为接口是一种规范，规范的目的是为了公开化。
接口不能实例化。
接口的结构特点：1.常量(接口中只可以定义常量，且常量必须被赋值) 2.抽象方法
接口中常量默认被public static final修饰，方法默认被public static abstract修饰！
接口的使用(implements)：接口是一种引用数据类型，但是接口不能直接创建对象，要重新定义类实现接口，重写接口中所有的抽象方法。
接口的基本使用：被类实现。
实现接口：public class 子类 implements 接口1，接口2...{ }
一个类实现接口，必须重写接口中的全部抽象方法，否则这个类需要定义成抽象类。
接口是用来被类实现的，实现接口的类被称为实现类。实现类可以理解成所谓的子类。
实现(继承)接口,要重新定义类实现接口，重写接口中所有的抽象方法,包括该接口继承的接口,即父接口它里面的抽象方法也要重写
接口的特点：接口不能直接创建对象，要重新定义类实现(继承)接口，重写接口中所有的抽象方法。
接口的静态方法只能接口自己调用。
接口不能创建对象，方法只能过继给实现类，由实现类的对象调用。
接口也可以用extends关键字去继承，但是只能继承接口，并且支持多继承。
接口多继承的作用：规范合并，整合多个接口为同一个接口，便于子类实现。
接口与接口的继承（extends），接口也可以用extends关键字去继承，但是它只能继承接口，它可以继承多个接口，extends多继承只是对接口而言，而类只能单继承。
接口的所有属性全部都是public static final的
常量与属性的区别：

访问修饰符的区别在接口中只允许用public访问修饰符。
常量在定义的时候必须给定初始值。
常量在定义的时候全部大写，NAME_XXX，如果有多个单词，加下划线。

package com.gch.d10_interface;

/**
    声明了一个接口:体现一种规范,规范一定是公开的
 */
public interface InterfaceDemo {
    // 目标:接口中的成分特点:JDK8之前接口中只能有抽象方法和常量。
    // 1.常量:
    // 注意:由于接口体现规范思想,规范默认都是公开的,所以代码层面,public static final可以省略不写
    String SCHOOL_NAME = "程序员";
//    public static final String SCHOOL_NAME = "程序员";

    // 2.抽象方法
    // 注意:由于接口体现规范思想,规范默认都是公开的,所以代码层面,public abstract可以省略不写
    void run();
//    public abstract void run();

    void eat();
//    public abstract void eat();
}

类与类之间是extends单继承关系

接口与接口之间是extends多继承关系，一个接口可以同时继承多个接口。

类与接口之间是implements多实现关系(类实现接口)

1.接口的结构

package com.interfaceoop;

// 定义接口：public interface 接口名
public interface Student {
    // 接口结构  接口只允许用public修饰符
    // 1.常量(接口中只可以定义常量，接口中所有的属性全部都是public static final修饰的)
    public static final String NAME = "小李";

    // 2.抽象方法(abstract写不写都行,有参数有返回值都不影响,但是不能有{})
    public abstract void study();
    public void seName(String name);
    public String getName();
}

2.接口也可以用extends关键字去继承，并且支持多继承，但是接口只能继承接口，extends多继承只是对接口而言，而类只能单继承

public interface 子接口 extends 父接口1，父接口2....{ }

package com.interfaceoop;

import java.awt.event.ActionListener;
import java.awt.event.MouseListener;

// 定义接口：public interface 接口名
// 接口也可以用extends关键字来继承,但是接口只能继承接口,并且接口支持继承多个接口
public interface Student extends ActionListener, MouseListener {
    // 接口结构  接口只允许用public修饰符
    // 1.常量(接口中只可以定义常量，接口中所有的属性全部都是public static final修饰的)
    public static final String NAME = "小李";

    // 2.抽象方法(abstract写不写都行,有参数有返回值都不影响,但是不能有{})
    public abstract void study();
    public void seName(String name);
    public String getName();
}

3.实现/继承（implements）接口要重写接口中所有的抽象方法，包括该接口继承的接口，即父接口，它里面的抽象方法也要重写！

package com.interfaceoop;

import java.awt.event.ActionListener;
import java.awt.event.MouseListener;

// 定义接口：public interface 接口名
// 接口也可以用extends关键字来继承,但是接口只能继承接口,并且接口支持继承多个接口
public interface Student extends ActionListener, MouseListener {
    // 接口结构  接口只允许用public修饰符
    // 1.常量(接口中只可以定义常量，接口中所有的属性全部都是public static final修饰的)
    public static final String NAME = "小李";

    // 2.抽象方法(abstract写不写都行,有参数有返回值都不影响,但是不能有{})
    public abstract void study();
    public void seName(String name);
    public String getName();
}

package com.interfaceoop;

import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;

// 事件处理类:实现接口的类
// 实现接口/继承接口:public class 子类 implements 接口1,接口2,....{ }
// 继承/实现接口,要重写接口中所有的抽象方法,包括该接口继承的接口,
// 即父接口它里面的抽象方法也要重写
public class ImplementsStudent implements Student{
    public void study(){}
    public void seName(String name){}
    public String getName(){return null;}

    public void actionPerformed(ActionEvent e){}

    public void mouseClicked(MouseEvent e){}
    public void mousePressed(MouseEvent e){}
    public void mouseReleased(MouseEvent e){}
    public void mouseEntered(MouseEvent e){}
    public void mouseExited(MouseEvent e){}
}

4.实现(继承)接口的同时也可以继承类：必须先extends继承类再实现(继承)接口

格式:public class 子类 extends 父类 implements 接口1,接口2,...{ }

类只支持单继承(即一个子类只能有一个父类)，接口可以多实现

package com.interfaceoop;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;

// 事件处理类:实现接口的类
// 实现接口/继承接口:public class 子类 implements 接口1,接口2,....{ }
// 实现(继承)接口,要重写接口中所有的抽象方法,包括该接口继承的接口,即父接口它里面的抽象方法也要重写

// 实现(继承)接口的同时也可以继承类  格式: public class 子类 extends 父类 implements 接口1,接口2,...{ }
public class ImplementsStudent extends JFrame implements Student{
    public void study(){}
    public void seName(String name){}
    public String getName(){return null;}

    public void actionPerformed(ActionEvent e){}

    public void mouseClicked(MouseEvent e){}
    public void mousePressed(MouseEvent e){}
    public void mouseReleased(MouseEvent e){}
    public void mouseEntered(MouseEvent e){}
    public void mouseExited(MouseEvent e){}
}

Surpass余sheng军

关注

2
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java接口详解

/ 主函数// 一个文件里面只能有一个共有类/主类// 定义变量不加static关键字，每个对象单独保存一个变量// 主函数静态变量的值可以修改// 一个文件里面只能有一个共有类/主类// 定义变量加static关键字，所有对象会共享该变量,调用不受对象的影响// public static 数据类型变量名;静态变量/类变量/共享变量。
复制链接

扫一扫