java学习随笔---接口

灰太狼 2021-11-26 14:06 279阅读 0赞

接口的概念：接口就是一种**公共的规范标准**，只要符合标准，大家就可以通用。

**1.接口定义的基本格式**

> public interface 接口名称\{  
> //接口内容  
> \}

![在这里插入图片描述][20190724110329196.PNG]

**2.接口的抽象方法的定义**

>  *  接口中的抽象方法，修饰符必须是两个固定的关键字 public abstract；
>  *  这两个固定的关键字可以选择性地省略；

public interface Demo03InterfaceAbs { 
        
        public abstract void methodAbs1();
        
        abstract void methodAbs2();
        
        public void methodAbs3();
        
        void methodAbs4();
        
    }

--------------------

**3.接口的使用步骤**

> 1.  接口不能直接使用，必须有一个**实现类**来**实现**该接口。  
>     格式：public class 实现类名称 implements 接口名称\{  
>     \}
> 2.  接口的实现类必须覆盖重写接口中的所有抽象方法。
> 3.  创建实现类对象进行使用。

接口

public interface Demo03InterfaceAbs { 
    
        public abstract void methodAbs1();
    
    }

实现类

public class Demo03InterfaceAbsImpl implements Demo03InterfaceAbs { 
        @Override
        public void methodAbs1() { 
            System.out.println("这是接口的实现类");
        }
    }

实现类的对象

public class abs { 
        public static void main(String[] args) { 
            Demo03InterfaceAbsImpl impl = new Demo03InterfaceAbsImpl();
            impl.methodAbs1();
        }
    }

--------------------

**4.[接口的默认方法][Link 1]**

**5.接口的静态方法**

>  *  格式：public static 返回值类型 方法名称(参数列表)\{  
>     \}
>  *  不能通过接口实现类对象调用接口中的静态方法。
>  *  正确做法应该是通过接口名称直接调用静态方法。格式：接口名称.静态方法名(参数)；

接口
    public interface MyInterfaceStatic { 
        public static void staticMethod(){ //接口中静态方法的定义格式
            System.out.println("接口中的静态方法执行了");
        }
    }
    
    实现类
    public class MyInterfaceStaticImpl implements MyInterfaceStatic{ 
    
    }
    
    实现类对象
    public class staticMain { 
        public static void main(String[] args) { 
            MyInterfaceStatic.staticMethod();//不用创建对象直接通过类名.方法名调用
        }
    }

**6.接口的私有方法**

>  *  目的就是为了解决两个默认方法或两个静态方法之间的代码重复问题。
>  *  **普通私有方法**，解决多个默认方法之间的代码重复问题。  
>     格式：private 返回值类型 方法名称(参数列表)\{  
>     \}
>  *  **静态私有方法**，解决多个静态方法之间代码重复的问题  
>     格式：private static 返回值类型 方法名称(参数列表)\{  
>     \}**静态再调用的时候不用创建对象，只需要类名.方法名就行**

接口
    public interface MyInterfacePrivate { 
        public default void method1 (){ 
            System.out.println("我是jhon");
    /* System.out.println("AAA"); System.out.println("BBB"); System.out.println("CCC");*/
            methodCommon();//将重复的部分抽取出来，写成私有方法，然后再默认方法中调用私有方法
        }
        public default void method2 (){ 
            System.out.println("我是tom");
    /* System.out.println("AAA"); System.out.println("BBB"); System.out.println("CCC");*/
            methodCommon();//将重复的部分抽取出来，写成私有方法，然后再默认方法中调用私有方法
        }
        private void methodCommon(){ 
            System.out.println("AAA");
            System.out.println("BBB");
            System.out.println("CCC");
        }
    }
    
    实现类
    public class MyInterfacePrivateImpl implements MyInterfacePrivate{ 
    
    }
    
    实现类对象
    public class mainPrivate { 
        public static void main(String[] args) { 
            MyInterfacePrivateImpl impl = new MyInterfacePrivateImpl();
            impl.method1();
            impl.method2();
        }
    }

--------------------

7.接口常量定义和使用

> 格式public static final 数据类型 名称 = 值；  
> 一旦使用了final关键字，说明接口中的常量不可修改；  
> 接口中常量必须进行赋值。  
> 接口中常量的名称尽量使用大写，如果多个英文的话中间用\_隔开。

接口
    public interface MyInterfaceConst { 
        public static final int NUM = 10;
    }
    
    
    public interface MyInterfaceConst { 
        public static final int NUM = 10;
    }

**注意**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MzIyMzU3_size_16_color_FFFFFF_t_70]

**接口与接口之间的多继承**

>  *  类与类之间是单继承的。直接父类只有一个。
>  *  类与接口之间是多实现的。一个类可以实现多个接口。
>  *  接口与接口之间是多继承的。

注意

1.  多个父接口当中的**抽象方法**如果重复，没关系；
2.  多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖 重写。而且带着default关键字。

父类1
    public interface MyInterfaceA { 
        public default void methodA(){ 
            System.out.println("AAA");
        }
    }
    
    父类2
    public interface MyInterfaceB { 
        public default void methodA(){ 
            System.out.println("BBB");
        }
    }
    
    子类同时有父类两个相同的默认方法，、需要覆盖重写
    public interface MyInterface extends MyInterfaceA,MyInterfaceB { 
        @Override
        default void methodA() { 
    
        }
    }

[20190724110329196.PNG]: /images/20211126/e42ae50a858d4d0aa8a6e0e7a916fe6a.png
[Link 1]: https://blog.csdn.net/qq_44322357/article/details/97108601
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MzIyMzU3_size_16_color_FFFFFF_t_70]: /images/20211126/e4d8c19026b94bb0969c83245f39640e.png