面向对象 (接口 Interface)

1，面向对象(接口的概述及其特点)

• A:接口概述
  
  • 从狭义的角度讲就是指java中的interface
  • 从广义的角度讲对外提供规则的都是接口
• B:接口特点
  
  • a:接口用关键字interface表示
    
    • interface 接口名 {}
  • b:类实现接口用implements表示
    
    • class 类名 implements 接口名 {}
  • c:接口不能实例化
    
    • 那么，接口如何实例化呢?
    • 按照多态的方式来实例化。
  • d:接口的子类
    
    • a:可以是抽象类。但是意义不大。
    • b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

2，面向对象(接口的成员特点)

• A:接口成员特点
  
  • 成员变量；只能是常量，并且是静态的并公共的。
    * 默认修饰符：public static final
    * 建议：自己手动给出。
  • 构造方法：接口没有构造方法。
  • 成员方法：只能是抽象方法。
    * 默认修饰符：public abstract
    * 建议：自己手动给出。

    public class Demo2_Interface {

    public static void main(String[] args) {
        Demo d = new Demo();
        d.print();
        System.out.println(Inter.num);
    }

    }
    interface Inter{
    public static final  int num = 10 ;
    //public Inter(){}      接口中没有构造方法
    /*
     public void print(){    接口中不能定义非抽象方法

     }
     */
    public abstract void print();

    }
    class Demo/* extends Object*/ implements Inter{  //一个类不写继承任何类，默认继承Object类
    public void print(){
        System.out.println(num);
    }

    public Demo(){
        super();
    }
    }

3，面向对象(类与类,类与接口,接口与接口的关系)

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

public class Demo3_Interface {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}
interface InterA{
    public abstract void printA();
}
interface InterB{
    public abstract void printB();
}
interface InterC extends InterA,InterB{

}
class Demo extends Object implements InterA,InterB{
    public void printA(){
        System.out.println("printA");
    }
    public void printB(){
        System.out.println("printB");
    }
}

面向对象(抽象类和接口的区别)

• A:成员区别

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

• B:关系区别

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

• C:设计理念区别

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

• A:案例演示

  • 动物类：姓名，年龄，吃饭，睡觉。
  • 猫和狗
  • 动物培训接口：跳高

package owsdawdcx;

public class Test_Animal {

    public static void main(String[] args) {
        Cat c = new Cat ("加菲",8);
        c.eat();
        c.sleep();

        JumpCat  jc = new JumpCat("跳高猫",3);
        jc.eat();
        jc.sleep();
        jc.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 void setName(String name){
        this.name = name;
    }
    public String getName (){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }


    public abstract void eat();
    public abstract void sleep();

}
interface Jumping {
    public void jump();
}


class Cat extends Animal{
    public Cat(){}

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

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

class JumpCat extends Cat implements Jumping{
    public JumpCat (){}                         //空参构造

    public JumpCat(String name,int age){    //有参构造
        super(name,age);
    }

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