system不明确_不说别的，你Java开发三年，这些接口还整不明白，怎么给你涨工资...

接口概述:

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

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

public class 类名.java–>.class

public interface 接口名.java–>.class

接口的使用，它不能创建对象，但是可以被实现(implements ，类似于被继承)。一个实现接口的类(可以看做是接口的子类)，需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。2、光理论还是不够的，来吧看案例实现

定义格式

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…    }}

父类和接口的私有方法

不存在冲突

---

其实除了这些接口之外，还有很多这样的基础的问题，除了一些原因之外，还有一点就是看你基础掌握的怎么样，还有一些源码的知识，其实就是看你在原来的公司接触的知识或者你自己学到的项目到了一个什么样的层次，说句不好的话就是公司对于你的分类和划分

那除了接口之外，你还需要准备哪些知识呢？

目录

展开详解

需要这份xmind知识导图的，关注+转发后，私信“资料”即可查看获取方式

文档

当然了，只有这些东西怎么能够，这是我在整理这份知识导图的时候参考的书籍，适应人群的话，我个人觉得各个层次都适合，但是更适合刚开始学习以及基础不扎实的朋友

第一部分：环境准备

认识什么Java以及开发环境搭建

第二部分：编程基础

第三部分：编程提高

这里面有swing这样不怎么使用的技术了，但是，最近还有一些大学生问我这个该如何使用，没办法，有一些大学，大家都明白的，剩余的，异常处理、多线程、网络编程、内存处理、反射与注解、servlet等技术，都是现在应用比较多的技术

个人感觉，再整理一些基础的相关知识，甚至面试的时候底层的一些东西，在这本书中都可以找到相应的解答

需要这份文档的老铁，关注+转发后，私信“资料”二字即可查看获取方式