Java 接口（笔记）

1. 接口

（1）概述：

（2）接口的特点

关键字Interface表示

/*
    接口关键字：interface
    接口与类之间：implement
    创建抽象接口的对象：与接口之间创建父类对象，通过重写子类的成员方法创建与接口的对象
*/

//Jumpping接口
public interface Jumpping{    //接口关键字 Interface
    public abstract void jump();    //抽象方法
}






//创建Cat类
public class Cat implements Jumpping{    //类与接口之间：关键字implements
   
     @Override
    public void jump(){
        System.out.println("猫可以跳高了");
    }
}




//测试类
public class JumppingDemo{
    public static void main(String[] args){
    //创建接口对象
        //错误的(接口为抽象的，不能被实例化)    Jumpping j = new Jumpping();
    Jumpping j = new Cat();           //多态的方法
    j.jump();

    }
}

（3）接口的成员特点

/*
    接口：
    成员变量：只能是常量(final修饰)【默认修饰符：public static final】
    接口实现类(一般为InterImpl)：
    接口中的成员变量默认被final修饰，在其它类中无法直接赋值；可以通过 类.变量 直接访问
    (public static final) 成员变量直接写，如：int num3 = 30 ;

  
    
    
*/
    /*
     接口（接口主要对行为进行抽象，没有具体存在）里面不能有构造方法

    所有构造方法默认访问父类的都是无参构造

    类Object是层次结构的根，每个类都有Object作为超类（每个类都直接或间接地继承Object）

    接口（接口主要对行为进行抽象，没有具体存在）里面不能有构造方法

    */
    public class InterImple extends Object implements Inter{    

    }
    //等价于
    public class InterImpl implements Inter{

    }


    /*
    成员方法：【默认修饰符：public abstract】
    接口里面不能有非抽象方法(abstract)
    */
    //接口里面的方法默认带了 public abstract
    public abstract void method();
//等价于
    void method();

案例：猫和狗

package CatAndDog4;
//Cat类
public class Cat extends Animal implements Jumpping{
    //构造方法：无参、带参
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }

    //成员方法：重写eat方法，重写Jump方法
    @Override
    public void eat() {
        System.out.println("猫吃东西");
    }
    @Override
    public void jump(){
        System.out.println("猫跳高");
    }

}




//Animal类
public abstract class Animal {
    //成员变量：姓名、年龄
    private String name;
    private int age;


    //构造方法：无参、带参
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //成员方法：get/set方法，eat方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}






//测试类
public class AnimalDemo {
    //main方法
    public static void main(String[] args){
    //创建对象，调用方法
    Jumpping j = new Cat();
    j.jump();   //接口只能调接口里面的方法
    System.out.println("-------------------");


    //法1：无参构造法
    Animal a = new Cat();
    a.setAge(18);
    a.setName("加菲");
    System.out.println(a.getName() + ", " + a.getAge());
    a.eat();    //抽象类只能调抽象类里面的方法
    System.out.println("-------------------");

        // 法2：带参构造法
    a = new Cat("加菲猫",16);
    System.out.println(a.getName() + ", " + a.getAge());
    a.eat();    //抽象类只能调抽象类里面的方法
    System.out.println("-------------------");


    //法3：这种方法最好（Cat类里面的方法最多，既是子类又有接口）
        Cat c = new Cat();
        c.setAge(18);
        c.setName("加菲猫");
        System.out.println(a.getName() + ", " + a.getAge());
        c.jump();
        c.eat();
    }
}

（4）类和接口的关系

   //接口Inter1
     public interface Inter1{

    }

    //接口Inter2
     public interface Inter2{

    }

    //接口Inter3 继承多个接口
     public interface Inter3 extends Inter1,Inter2{

    }

    //myself类继承Object类的时候实现多个接口
    public class myself extends Object implements Inter1,Inter2,Inter3{

    }

（5）抽象类和接口的区别

 

 案例：运动员和教练

 

package AthletesAndCoaches;
//说英语接口
public interface SpeakEnglish {
    //成员方法：
    public abstract void speakEnglish();

}





//抽象人类
public abstract class Person {
    //成员变量：姓名、年龄
    private String name;
    private int age;
    //构造方法（无参、带参）
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //成员方法：get/set、eat
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}





//抽象教练类，继承人类
public abstract class Coach extends Person{

    //构造方法（无参、带参）
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    //成员方法：teach()
    public abstract void teach();


}





//抽象运动员类，继承人类
public abstract class Player extends Person{        //
    //构造方法
    public Player() {
    }

    public Player(String name, int age) {
        super(name, age);
    }
    //成员方法：抽象learn()
    public abstract void learn();

}






//具体篮球运动员类，继承运动员类
public abstract class BasketballPlayer extends Player{
    //构造方法
    public BasketballPlayer() {
    }

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }
    //成员方法：重写eat();重写learn()
    @Override
    public void eat(){
        System.out.println("篮球运动员在吃");
    }
    @Override
    public void learn(){
        System.out.println("篮球运动员学");
    }

}





//篮球教练类，继承教练
public class BasketballCoach extends Coach{
    //构造方法
    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }
    //成员方法；重写teach()、重写eat()
    @Override
    public void teach(){
        System.out.println("教篮球");
    }
    @Override
    public void eat(){
        System.out.println("吃篮球教练");
    }


}






//具体乒乓球教练类，继承Coach类，继承Coach接口
public class PingPangCoach extends Coach implements SpeakEnglish{
    //构造方法
    public PingPangCoach() {
    }

    public PingPangCoach(String name, int age) {
        super(name, age);
    }
    //成员方法：重写eat()、重写teach()

    @Override
    public void teach(){
        System.out.println("教乒乓球");
    }
    @Override
    public void eat(){
        System.out.println("吃乒乓球教练");
    }
    @Override
    public void speakEnglish(){
        System.out.println("乒乓球教练讲英语");
    }

}









//具体乒乓球运动员类，继承运动员类，实现说英语接口
public class PingPangPlayer extends Player implements SpeakEnglish  {
    //构造方法：无参、带参
    public PingPangPlayer() {
    }

    public PingPangPlayer(String name, int age) {
        super(name, age);
    }
    //成员方法：重写eat()、重写learn()、重写speakEnglish()
    @Override
    public void eat(){
        System.out.println("吃乒乓球运动员");
    }
    @Override
    public void learn(){
        System.out.println("乒乓球运动员学");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球运动员讲英语");
    }
}









//测试类
public class Demo {
    public static void main(String[] args){
        //创建对象
        //乒乓球运动员
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("张继科");
        ppp.setAge(18);
        System.out.println(ppp.getName() + ppp.getAge());
        ppp.eat();
        ppp.learn();
        ppp.speakEnglish();

    }

}