学习笔记 java学习（四）

接口
1.接口的关键字是interface
2.接口中的方法都是抽象方法–只定义规则不实现
3.我们需要给接口配备对应的实现类XXXImpl，实现类有两种：
1）抽象类–不实现/实现部分–不可以创建对象
2）普通实现类–实现所有的抽象方法–创建本类对象进行功能调用–最常用
入门案例：
1.接口：

/**1.通过interface关键字来定义接口*/
public interface Inter {
    /**2.接口中可以有普通方法吗？  不可以*/
    //public void eat(){}
    /**3.接口中可以有抽象方法吗？--可以，接口中的方法都是抽象方法*/
    public abstract void run();
    public abstract void play();
}

2.接口实现类:

/**本类用作Inter接口的实现类*/
/**1.接口实现类需要通过implements关键字与接口建立实现关系*/
//方法一：不实现或实现部分，用抽象类
//abstract public class InterImpl implements Inter
public class InterImpl implements Inter{
    //方法二：将接口中的所有方法全部实现
    public void run(){
        System.out.println("啊啊啊啊啊");
    }
    public void play(){
        System.out.println("啊啊");
    }
}

3.测试类–有main(),可以创建对象进行测试

/**本类用于测试接口实现类的测试类*/
public class TestInter {
    public static void main(String[] args) {
        //2.测试创建接口对象
        /**接口不可以创建对象*/
        //Inter i=new Inter();
        //2.创建多态对象进行测试
        /*Inter i = new InterImpl();
        i.play();
        i.run();*/
        //3.创建实现类对象进行测试
        InterImpl i2=new InterImpl();
        //3.1实现类对象调用方法测试
        i2.play();
        i2.run();
    }
}

接口中关于构造方法
1、接口没有构造函数
2、一个类没有明确指定父类，那就默认继承顶级父类Object
3、接口实现类使用的就不是接口中的构造方法，接口没有构造，使用的是父类的构造

/**1.接口中没有构造方法*/
    //2.测试接口中是否有构造方法
    //public Inter2(){}

//4.创建实现类的构造方法
    public  Inter2Impl(){
        super();
        System.out.println("我是实现类构造方法");
    }

接口中关于静态常量的测试
接口中没有成员变量，接口中的常量都是static final的静态常量

public static void main(String[] args) {
        Inter2Impl i = new Inter2Impl();
        System.out.println(i.age);
        System.out.println(Inter2.age);
      //x i.age=100;
    }

   //接口中没有成员变量
 /**2.1接口中的变量实际上是静态的，因为可以通过接口名直接调用
  * 2.2接口中的变量实际上是final常量，因为不能被重新赋值
  * 2.3接口中的都是静态常量static与final可以简写，会自动拼接*/
int age=10;

接口中的成员方法
接口中的成员方法都是抽象方法，可以将前面的public abstract省略掉

//4.测试接口中的抽象方法
    /**接口中都是抽象方法，而且public和abstract可以简写*/
    void eat();

java接口的多继承多实现
java中可以实现接口的多继承用extends A,B的样式
Java中多实现用implements a,b表示
例题：

interface D extends A,B{
    
}

package Inter;

public class Interself {
    public static void main(String[] args) {
        C c=new C();
        c.eat();
        c.run();
        c.jump();
        c.shout();
    }
}
interface A{
    void run();
    void jump();
}
interface B{
    void eat();
    void shout();
}
class C implements A,B{

    @Override
    public void run() {
        System.out.println("我会跑");
    }

    @Override
    public void jump() {
        System.out.println("我会跳");
    }

    @Override
    public void eat() {
        System.out.println("我会吃");
    }

    @Override
    public void shout() {
        System.out.println("我会叫");
    }
}