API

1.接口的补充

接口不能new对象
接口中属性只能是常量，常量并不是对象的成员属性。接口中的方法只能是抽象的方法，没有方法体。
对象要有成员属性，每个对象的成员属性值都不一样。要有成员方法，每个对象的成员方法，对象的引用都能调用。
如果接口能new对象，那么接口对象的属性是没有的，接口对象的方法都是不能执行的。它违背对象的定义。
接口的本身就是一个抽象的定义。
抽象类为什么也不能new对象呢？道理是一样的。一旦抽象类中有抽象方法之后，这个方法不能被对象的引用调用。

public interface eat {
    void eat1();
    void student();
}

public class Son implements eat{

    public Son(){
        System.out.println("子类构造");
    }
    public void eat1() {
        System.out.println("儿子吃东西");
    }
    public void student(){
        System.out.println("儿子学习");
    }

}

public class Main {
    private int id;
    private String name;


    public static void main(String[] args){
        Son f = new Son();
        f.eat1();
        f.student();
    }
    public String toString() {
        return "id= " + id + ", " + "name= " + name;
    }
}
---------------------------------------------------------------
子类构造
儿子吃东西

以上是接口的使用方法
但我又想到如果一个类同时继承父类和接口会有什么影响
于是自己试了一下，也去博客搜了些资料

public interface eat {
    void eat1();
    void student();
}

public class Father {
    public void student(){
        System.out.println("父类学习");
    }
}

public class Son extends Father implements eat{

    public Son(){
    }
    public void eat1() {
        System.out.println("儿子吃东西");
    }
    public void student(){
        System.out.println("儿子学习");
    }

}

public class Main {
    private int id;
    private String name;


    public static void main(String[] args){
        Son s = new Son();
        Father f = new Father();
        s.eat1();
        s.student();
        f.student();
    }
    public String toString() {
        return "id= " + id + ", " + "name= " + name;
    }
}
-----------------------------------------------------------------
儿子吃东西
儿子学习
父类学习

一.如果实现类所实现的多个接口当中，存在重名的抽象方法：

1.参数列表+返回值 都相同：实现类只要实现一次此方法即可

2.参数列表相同+返回值类型不同：实现类无法直接实现两个方法（IDE报错），因为不满足方法重载原则。

interface A{
    int method();
}
 
interface B{
    void method();
}
 
public class C implements A, B {
    public int method() {   //报错，因为不满足方法重载原则
        return 0;
    }
}

3.参数列表不相同：实现类可以分别实现两个方法，可以方法重载

interface A{
    void method(int b);
}
 
interface B{
    void method();
}
 
public class C implements A, B {
 
    @Override
    public void method(int b) {
        
    }
 
    @Override
    public void method() {
 
    }
}

二、父类与接口中存在同名方法

1、若子类没有重写该方法，则默认会优先调用父类中的方法，不会报错。

interface A{
    void method();
}
 
class B{
    public void method(){
        System.out.println("父类B中的方法被调用！");
    }
}
 
class C extends B implements A {
    
}
 
public class Test{
    public static void main(String[] args) {
        C c = new C();
        c.method();
    }
}

2、若子类重写了该方法，则相当于同时重写了父类以及接口中的方法。调用的是子类重写后的方法

interface A{
    void method();
}
 
class B{
    public void method(){
        System.out.println("父类B中的方法被调用！");
    }
}
 
class C extends B implements A {
    @Override
    public void method() {
        System.out.println("子类中的方法被调用！");
    }
 
    public static void main(String[] args) {
        C c = new C();
        c.method();
    }
}
----------------------------------------------------
子类中的方法被调用！

以上内容是摘自https://blog.csdn.net/qq_37649504/article/details/115347250

一个来实现了一个接口同时继承了一个父类，若再父类和接口中出现同名同类型成员变量会怎么样？
1.若父类和接口中成员为public （接口中只能为public）则无法编译出现错误
2.若父类中成员为private则没什么事，因为父类private 类型成员对外部是不可见的
3.父类和接口中有同名static方法时只会调用父类中的
4.父类中方法和接口中default方法同名时只会调用接口中的方法(接口中默认方法会覆盖父类中public同名方法)
———————————————— 版权声明：本文为CSDN博主「CodeBoy1024」的原创文章，遵循CC 4.0
BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/anwarkanji/article/details/90274006

接口隔离
我们知道，接口定义之后，实现类一定要实现接口中所有的抽象方法。
问题来了，如果一个接口，有5个方法，它的某一个实现类只要用到其中的一个，那么另外4个也一定要实现，否则编译都过不去。那么就会造成代码的冗余。
所以，接口要隔离，接口的功能要单一。

听杰哥说了依赖倒置和一些例子 ，于是又去网上找了些资料

依赖倒置

是程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。
面向过程的开发，上层调用下层，上层依赖于下层，当下层剧烈变动时上层也要跟着变动，这就会导致模块的复用性降低而且大大提高了开发的成本。
面向对象的开发很好的解决了这个问题，一般情况下抽象的变化概率很小，让用户程序依赖于抽象，实现的细节也依赖于抽象。即使实现细节不断变动，只要抽象不变，客户程序就不需要变化。这大大降低了客户程序与实现细节的耦合度。

总结：依赖倒置原则
A.高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。
B.抽象不应该依赖于具体，具体应该依赖于抽象。

接口的引用指向实现类的对象

这种写法其实Java多态的表现形式（一个接口类型的引用变量来引用实现接口的类的实例，当这个引用调用方法时，它会根据实际引用的类的实例来判断具体调用哪个方法）

多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）

为什么一般都使用 接口引用指向子类对象 ,而不用 实现类本身 引用呢？

问题就在于接口可以有多个实现类，如果现在你使用这个实现类接收，也许哪一天你需要换成其它的实现类呢？

这时你只要将new的实现类对象换成你想要的就行了， 其它地方的代码根本不需要改动。

注意事项

没有在接口定义的方法（实现类增加的方法）是不可以被访问到的

在接口的实现类中该实现方法的类型和参数必须与接口中所定义的精确匹配。

2 API 和 API帮助文档

什么是API，什么是API帮助文档
API：application programming Interface 说白了API就是SUN公司提供的java源代码
API帮助文档，是通过javadoc指令，将java源代码中/** */注释的内容提取出来，形成了这个帮助文档。
以后，我们要用的时候，是直接看API还是用帮助文档？文档
以后我们开发怎么使用SUN公司提供的API呢？导包、调用方法。导包，创建实例(有的甚至不用)，然后“.”方法。
————————————————
版权声明：本文为CSDN博主「solo_jie」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/solo_jie/article/details/113428864

@Override : 这是一个注解。加上这个注解的，说明这个方法是父类中的方法，被子类重写了。这个方法的原型在父类中，子类重写了父类的方法。