java开发三年，这些接口你都不会用，凭什么给你涨工资？？

news/2024/7/24 6:47:40 标签: java

接口概述:

1、接口是Java语言中的一种引用类型，是方法的"集合"，所以接口的内部主要就是定义方法，包含常量,抽象方法（JDK 7及以前），额外增加默认方法和静态方法（JDK 8）,额外增加私有方法(jdk9)。

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

public class 类名.java–>.class

public interface 接口名.java–>.class

接口的使用，它不能创建对象，但是可以被实现（implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。
2、光理论还是不够的、在此给大家免费赠送2020最新5大JAVA架构项目实战教程及大厂面试题库，有兴趣的可以进裙 783802103 获取，小白勿进哦！

定义格式

public interface 接口名称 {
    // 常量
    // 抽象方法
    // 默认方法(jdk8)
    // 静态方法(jdk8)
    // 私有方法(jdk9)
}
复制代码

案例

public interface IA {
    // 常量 默认修饰符 public static final  这三个修饰符可以省略
    public static final int NUM1 = 10;
    int NUM2 = 20;

    // 抽象方法 默认修饰符 public abstract 这2个修饰符可以省略
    public abstract void method1();
    void method2();

    // 默认方法 默认修饰符 public default public修饰符可以省略,default不可以省略
    public default void method3(){
        System.out.println("默认方法 method3");
    }

    default void method4(){
        System.out.println("默认方法 method4");
    }

    // 静态方法: public static修饰  static修饰符不可以省略 public可以省略
    public static void method5(){
        System.out.println("静态方法 method5");
    }

     // 私有静态方法 使用private static修饰  不可以省略
     private static void method6(){
        System.out.println("私有静态方法 method6");
    }

    // 私有非静态方法 使用private修饰
    private  void method7(){
        System.out.println("私有静态方法 method7");
    }
}

public class Test {
    public static void main(String[] args) {
       
        System.out.println(IA.NUM1);// 10
    }

    // 类中的默认方法,使用默认权限修饰符(空)
    void method(){

    }
}


复制代码

接口中成员的访问特点

接口中成员访问特点概述

  接口中成员的访问特点:
                接口中的常量: 主要是供接口直接使用
                接口中的抽象方法: 供实现类重写的
                接口中的默认方法: 供实现类继承的(实现类中可以直接调用,实现类对象也可以直接调用)
                接口中的静态方法: 只供接口直接调用,实现类继承不了
                接口中的私有方法: 只能在接口中直接调用,实现类继承不了

复制代码

案例演示

public interface IA {
    //  接口中的常量: 主要是供接口直接使用
    public static final int NUM = 10;

    // 接口中的抽象方法: 供实现类重写的
    public abstract void method1();

    // 接口中的默认方法: 供实现类继承使用(实现类中可以直接调用,实现类对象也可以直接调用)
    public default void method2(){
        System.out.println("默认方法method2");
        method4();
        method5();
    }

    // 接口中的静态方法: 只供接口直接调用,实现类继承不了
    public static void method3(){
        System.out.println("静态方法method3");
        method5();
    }

    // 接口中的私有方法: 只能在接口中直接调用,实现类继承不了
    private void method4(){// 只能在接口的默认方法中调用
        // 方法体
        method5();
    }

    private static void method5(){//
        // 方法体
    }
}

实现类:

public class ImpA implements IA{

   /* @Override
    public void method2() {

    }*/

    @Override
    public void method1() {
        System.out.println("重写接口中的method1抽象方法");
    }
}


测试类:

public class Test {
    public static void main(String[] args) {
      
        System.out.println(IA.NUM);// 10

        // 创建实现类对象,访问NUM常量
        ImpA ia = new ImpA();
        System.out.println(ia.NUM);// 10

        // 调用method2方法
        ia.method2();

        // 通过接口名调用接口中的静态方法
        IA.method3();
        //ia.method3();// 编译报错,
    }
}

复制代码

多实现时的几种冲突情况

公有静态常量的冲突: 多个父接口中,相同的常量不能被继承 - 公有抽象方法的冲突: 实现类必须重写一次 公有默认方法的冲突: 实现类必须重写 公有静态方法的冲突: 无影响,因为静态方法实现类不能继承 私有方法的冲突: 无影响,因为私有方法只能在本接口中直接访问,实现类不能继承 实现类重写接口中的默认方法,不需要加default

公有静态常量的冲突

实现类不继承冲突的变量

interface IA{
    public static final int a = 10;
    public static final int b= 20;
}
interface IB{
    public static final int a = 30;
}
class Zi implements IA,IB{
    //只继承了b，没有继承a，因为a冲突了
}

public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
     //   System.out.println(z.a);//编译错误
        System.out.println(z.b);
    }
}


复制代码

公有抽象方法的冲突

实现类只需要重写一个

interface IA{
    public void show();
}
interface IB{
    public void show();
}
class Zi implements IA,IB{
    @Override
    public void show() {//子类只需要重写一个show()即可
        System.out.println("子类的show()...");
    }
}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

复制代码

公有默认方法的冲突

实现类必须重写一次最终版本

interface IA{
    public default void show(){
        System.out.println("IA");
    }
}
interface IB{
    public default void show(){
        System.out.println("IB");
    }
}
class Zi implements IA,IB{
    @Override
    public void show() {//必须重写一次的show()
        System.out.println("Zi的show()....");
    }
}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}


复制代码

公有静态方法的冲突

静态方法是直接属于接口的,不能被继承,所以不存在冲突

interface IA{
    public static  void show(){
        System.out.println("IA");
    }
}
interface IB{
    public static void show(){
        System.out.println("IB");
    }
}
class Zi implements IA,IB{

}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();//编译错误，show()不能被继承。
    }
}



复制代码

私有方法的冲突

私有方法只能在本接口中直接使用,不存在冲突

接口和接口的关系

接口可以“继承”自另一个“接口”，而且可以“多继承”

interface IA{}
interface IB{}
interface IC extends IA,IB{//是“继承”，而且可以“多继承”
}
复制代码

接口继承接口的冲突情况

公有静态常量的冲突: 不能被继承,使用不了 公有抽象方法的冲突: 只继承一个 公有默认方法的冲突: 必须重写一次 公有静态方法和私有方法的冲突 : 无影响,因为不能被子接口继承

公有静态常量的冲突

interface IA{
    public static final int a = 10;
    public static final int b = 30;
}
interface IB{
    public static final int a = 20;
}
interface IC extends IA,IB{//没有继承a
}
//测试：
main(){
    System.out.println(IC.a);//错误的
}

复制代码

公有抽象方法冲突

interface IA{
    public void show();
}
interface IB{
    public void show();
}
interface IC extends IA,IB{//IC只继承了一个show()
}
class Zi implements IC{
    //重写一次show()
    public void show(){
    }
}

复制代码

公有默认方法的冲突

interface IA{
    public default void d1(){
    }
}
interface IB{
    public default void d1(){
    }
}
interface IC extends IA,IB{//必须重写一次d1()
    public default  void d1(){
    }
}

复制代码

公有静态方法和私有方法

不冲突,因为静态方法是直接属于接口的,只能使用接口直接访问,而私有方法只能在接口中访问,也没有冲突 实现类继承父类又实现接口时的冲突

定义格式

public class 实现类名 extends 父类名 implements 接口名1,接口名2,...{           }
复制代码

实现类继承父类又实现接口时的冲突:

公有静态常量的冲突–>没有继承 公有抽象方法的冲突—>重写 公有默认方法的冲突—>优先父类 公有静态方法---->优先父类 私有方法的冲突—> 没有冲突

父类和接口的公有静态常量的冲突

class Fu{
    public static final int a = 10;
}
interface IA{
    public static final int a = 20;
}
class Zi extends Fu implements IA{//没有继承a变量
}
public class Demo {
    public static void main(String[] args) {
        System.out.println(Zi.a);//编译错误
    }
}


复制代码

父类和接口的抽象方法冲突

abstract class Fu{
    public abstract void show();
}
interface IA{
    public void show();
}
class Zi extends Fu implements IA{// 必须重写
    
}
//测试：
main(){
    Zi z = new Zi();
    z.show();//a
}


复制代码

父类和接口的公有默认方法的冲突

class Fu{
    public void show(){
        System.out.println("a");
    }
}
interface IA{
    public default void show(){
        System.out.println("b");
    }
}
class Zi extends Fu implements IA{
}
//测试：
main(){
    Zi z = new Zi();
    z.show();//a
}

复制代码

父类和接口的公有静态方法

class Fu{
    public static void show(){
        System.out.println("fu...");
    }
}
interface IA{
    public static void show(){
        System.out.println("IA...");
    }
}
class Zi extends Fu implements IA{//只继承了"父类"的静态方法，没有继承接口的静态方法

}
public class Demo {
    public static void main(String[] args) {
        Zi.show();//fu…
    }
}

复制代码

父类和接口的私有方法

不存在冲突

最后

大家看完有什么不懂的可以找我。另外给大家免费赠送2020最新5大JAVA架构项目实战教程及大厂面试题库，有兴趣的可以进裙 783802103 获取，小白勿进哦！

本文的文字及图片来源于网络加上自己的想法,仅供学习、交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理


http://www.niftyadmin.cn/n/1603416.html

相关文章

Spring Boot 中的 Tomcat 是如何启动的？

Spring Boot 中的 Tomcat 是如何启动的？

我们知道 Spring Boot 给我们带来了一个全新的开发体验，让我们可以直接把 Web 程序打包成 jar 包直接启动，这得益于 Spring Boot 内置了容器，可以直接启动。 本文将以 Tomcat 为例，来看看 Spring Boot 是如何启动 Tomcat 的&…
阅读更多...
6年Python大神总结10大开发技巧，80%的人都不会

6年Python大神总结10大开发技巧，80%的人都不会

今天给大家分享 10 个我平时整理非常实用的 Python 开发小技巧，内容目录如下： 值得一提的是，这 10 个技巧全部收录在我自己写的 《Python黑魔法指南》里 另外要特别注意：光理论是不够的。这里顺便免费送大家一套2020最新python入门…
阅读更多...
什么是真正的架构设计？十年Java经验让我总结出了这些，不愧是我

什么是真正的架构设计？十年Java经验让我总结出了这些，不愧是我

一. 什么是架构和架构本质 在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。 此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我们先讨论架构的概念定义，概念是人认识这个世界的…
阅读更多...
如何实现Python单例模式？最牛实战详解

如何实现Python单例模式？最牛实战详解

前言 今天在群里讨论时讨论到了单例模式，这应该是大家最熟悉的一种设计模式了。 简单而言，单例模式就是保证某个实例在项目的整个生命周期中只存在一个，在项目的任意位置使用，都是同一个实例。 单例模式虽然简单，但…
阅读更多...
架构师一定要看微服务设计的四个原则

架构师一定要看微服务设计的四个原则

微服务的设计原则 AKF原则 业界对于可扩展的系统架构设计有一个朴素的理念,就是：通过加机器就可以解决容量和可用性问题。(如果一台不行那就两台)。(世界上没有什么事是一顿烧烤不能解决的。如果有，那就两顿。） 这一理念在“云计算”概念疯狂…
阅读更多...
SSM框架-SpringMVC详解

SSM框架-SpringMVC详解

springmvc概述 Springmvc是spring框架的一个模块，spring和springmvc无需中间整合层整合。 Springmvc是一个基于mvc的web框架 表现层的三大任务： URL到controller的映射http请求参数绑定http响应的生成和输出 MVC设计模式 MVC设计模式是一种通用的软件…
阅读更多...
springboot核心基础之spring.factories机制

springboot核心基础之spring.factories机制

引言 在java spring cloud项目中，我们常常会在子模块中创建公共方法，那么在另外一个子模块中，需要加载配置文件的时候，往往Spring Boot 自动扫描包的时候，只会扫描自己模块下的类。这个是springboot约定俗成的内容。 …
阅读更多...
Java关键字：final，static，this，super

Java关键字：final，static，this，super

1. final 关键字： final 关键字，意思是最终的、不可改变的，初始化之后就不能再次修改 ，用来修饰类、方法和变量，具有以下特点：final 修饰的类不能被继承，final类中的所有成员方法都会被隐式的指…
阅读更多...
最新文章

Copyright @ 2022~2023