开发三年，Java中接口的使用你得知道，不然你还想涨薪，mysql使用入门

}
}

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;

// 接口中的抽象方法: 供实现类重写的
p

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

ublic 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 {