java面向对象（接口）

java面向对象（接口）

1、接口的特点

• 接口用关键字interface表示

  interface 接口名｛｝

• 类实现接口用implements表示

  class 类名 inplements 接口名｛｝

• 接口不能实例化

  如何实例化（按照多态的方式实例化，接口多态）

• 接口的子类

  可以是抽象类，但是意义不大

  可以是具体类，但要重写接口中的所有抽象方法（推荐方案）

//定义动物培训接口
interface AnimalTrain {
    public abstract void jump();
}

//抽象类实现接口
abstract class Dog implements AnimalTrain {
}

//具体类实现接口
class Cat implements AnimalTrain {
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

class InterfaceDemo {
    public static void main(String[] args) {
        //AnimalTrain是抽象的; 无法实例化
        //AnimalTrain at = new AnimalTrain();
        //at.jump();

        AnimalTrain at = new Cat();
        at.jump();
    }
}

2、接口成员特点

• 成员变量：只能是常量，并且是静态的；默认修饰符：public static final；建议手动给出

• 构造方法：接口没有构造方法

• 成员方法 ：不能带有方法主题，只能是抽象方法；默认修饰符：public abstract；建议自己手动给出；具体类实现接口时，其成员方法要带public

  interface Inter {
  public int num = 10;
  public final int num2 = 20;
  public static final int num3 = 30;
  
  //错误: 需要<标识符>
  //public Inter() {}
  
  //接口方法不能带有主体
  //public void show() {}
  
  //abstract void show(); //默认public
  public void show(); //默认abstract
  }
  
  //接口名+Impl这种格式是接口的实现类格式
  /*
  class InterImpl implements Inter {
  public InterImpl() {
      super();
  }
  }
  */
  
  class InterImpl extends Object implements Inter {
  public InterImpl() {
      super();
  }
  
  public void show() {}
  }
  
  //测试类
  class InterfaceDemo2 {
  public static void main(String[] args) {
      //创建对象
      Inter i = new InterImpl();
      System.out.println(i.num);
      System.out.println(i.num2);
      //i.num = 100;
      //i.num2 = 200;
      //System.out.println(i.num); //无法为最终变量num分配值
      //System.out.println(i.num2);//无法为最终变量num2分配值
      System.out.println(Inter.num);
      System.out.println(Inter.num2);
      System.out.println("--------------");
  }
  }

3、类，接口之间的关系

• 类与类：
  继承关系,只能单继承,可以多层继承。
• 类与接口：
  实现关系,可以单实现,也可以多实现。
  并且还可以在继承一个类的同时实现多个接口。
• 接口与接口：
  继承关系,可以单继承,也可以多继承。

interface Father {
    public abstract void show();
}

interface Mother {
    public abstract void show2();
}

interface Sister extends Father,Mother {

}

//class Son implements Father,Mother //多实现
class Son extends Object implements Father,Mother {
    public void show() {
        System.out.println("show son");
    }

    public void show2() {
        System.out.println("show2 son");
    }
}

class InterfaceDemo3 {
    public static void main(String[] args) {
        //创建对象
        Father f = new Son();
        f.show();
        //f.show2(); //报错

        Mother m = new Son();
        //m.show(); //报错
        m.show2();
    }
}

4、抽象类和接口的区别

• 成员区别

  • 抽象类：
    成员变量：可以变量，也可以常量
    构造方法：有
    成员方法：可以抽象，也可以非抽象

  • 接口：
    成员变量：只可以常量

    构造方法：无

    成员方法：只可以抽象

• 关系区别

  • 类与类
    继承，单继承
  • 类与接口
    实现，单实现，多实现
  • 接口与接口
    继承，单继承，多继承

• 设计理念区别
  抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
  接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

//定义跳高接口
interface Jumpping {
    //跳高功能
    public abstract void jump();
}

//定义抽象类
abstract class Animal {
    //姓名
    private String name;
    //年龄
    private int age;

    public Animal() {}

    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }

    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 void sleep() {
        System.out.println("睡觉觉了");
    }
}

//具体猫类
class Cat extends Animal {
    public Cat(){}

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

    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//具体狗类
class Dog extends Animal {
    public Dog(){}

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

    public void eat() {
        System.out.println("狗吃肉");
    }
}

//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
    public JumpCat() {}

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

    public void jump() {
        System.out.println("跳高猫");
    }
}

//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
    public JumpDog() {}

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

    public void jump() {
        System.out.println("跳高狗");
    }
}

class InterfaceTest {
    public static void main(String[] args) {
        //定义跳高猫并测试
        JumpCat jc = new JumpCat();
        jc.setName("哆啦A梦");
        jc.setAge(3);
        System.out.println(jc.getName()+"---"+jc.getAge());
        jc.eat();
        jc.sleep();
        jc.jump();
        System.out.println("-----------------");

        JumpCat jc2 = new JumpCat("加菲猫",2);
        System.out.println(jc2.getName()+"---"+jc2.getAge());
        jc2.eat();
        jc2.sleep();
        jc2.jump();

        //定义跳高狗略。
    }
}