JAVA面向对象（接口，引用数据类型，访问权限修饰符）

1.接口：interface
  interfance 接口名{}
  接口是如何实现的：
     接口不能直接实例化，需要另外一个关键字供其他类实现该接口：implements
     使用多态的形式进行实现，由具体的子类进行实例化，其实这是多态的一种，叫做接口多态
  1)接口中成员变量只能是常量，默认有修饰符public static final
  2)接口中成员方法妈也是有默认修饰符的public abstract
  3)接口中没有构造方法
  4）要想实例化接口，创建一个具体的类实现接口，并实现接口中所有的抽象方法
  5）接口与接口之间是继承关系，可以进行单继承，也可以进行多继承
  6）如果是一个具体的类实现接口，必须实现接口中所有的抽象方法
     如果是一个抽象类实现接口，可以选择性的实现方法，也可以不进行实现

接口中成员的特点:
   成员变量：
      只能是常量，并且是静态的
      JVM在真正运行之前会自动补齐修饰符：public static final
   构造方法：
      接口中没有构造方法
   成员方法：
      接口中的方法只能是抽象方法，没有方法体，连大括号都没有
      JVM在真正运行之前会自动补齐修饰符：public abstract

注意：
 1.当一个具体的类实现接口的时候，必须实现接口中所有的抽象方法
 2.当一个抽象类实现接口的时候，可以选择不实现接口中的方法，也可以选择性的实现

类与类，类与接口，接口与接口的关系
  类与类：
     存在继承关系，只能进行单继承，不可以进行多继承，但是可以是多层继承
  类与接口：
     实现关系，可以是单实现，也可以是一次性实现多个接口，也可以在继承一个类的同时，实现多个接口
  接口与接口：
     存在的是继承关系，可以进行单继承，也可以进行多继承

    
2.引用数据类型作为形式参数的时候
  当类作为参数的类型的时候，实际上需要的是该类的对象的地址值
  当抽象类作为参数的类型的时候，实际上需要的是该抽象类的子类的对象的地址值
  当接口作为形式参数的类型的时候，实际上需要的是实现该接口的类的对象的地址值
  
3.引用数据类型作为方法的返回值的时候
  当类作为方法的返回值类型的时候，实际上需要的是该类的对象
  当抽象类作为方法的返回值的时候，实际上需要的是该抽象类子类的对象
  当接口作为方法的返回值的时候，实际上需要的是实现该接口具体的类的对象
  
4.package import class的顺序

5.访问权限修饰符

权限修饰符：     同一类下     同一包子类中，其他类      不同包的子类      不同包的其他类
    public          √               √                     √                 √
    protected       √               √                     √
    默认的          √               √
    private         √

类及其组成可以用的修饰符：
            修饰符：
                访问权限修饰：public,protected,默认的,private
                状态修饰饰：static,final
                抽象修饰符：abstract

            类：
                访问权限修饰：public,默认的,
                状态修饰饰：final
                抽象修饰符：abstract
            成员变量：
                访问权限修饰：public,protected,默认的,private
                状态修饰饰：static,final
            构造方法：
                访问权限修饰：public,protected,默认的,private
            成员方法：
                访问权限修饰：public,protected,默认的,private
                状态修饰饰：static,final
                抽象修饰符：abstract

           常见的修饰符组合：
                成员变量：public static final 在接口中遇见
                成员方法：
                    1、public abstract
                    2、public static
                    3、public final

（1）将来看到当一个抽象类作为参数的类型的时候,实际上需要的是该类子类实现对象的地址值，利用多态的形式创建。 

（2）今后看到一个方法的返回值是一个抽象类类型的时候 ，需要返回的是该抽象类的子类对象。

（3）但凡今后看到一个方法的参数是一个类的类型进行传参的时候，实际上传的是该类的对象的地址值

（4）今后看到一个方法的返回值是一个类的类型的时候，实际上返回的是该类对象的地址值

（5）看到一个方法的参数类型是一个接口的时候，实际上需要的是该接口的实现类对象的地址值，利用接口多态的方式创建

（6）当接口作为返回值类型的时候，需要的是实现该接口的类的对象

接口测试：（猫钻火圈）

//猫钻火圈
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();
}
class Cat extends Animal{
    public Cat() {
    }

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

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

}
interface ZuanHuoQuan{
    void zuanHuo();
}
class TrainCat extends Cat implements ZuanHuoQuan{

    @Override
    public void zuanHuo() {
        System.out.println("猫钻火圈");
    }
}
public class InterfanceDemo1 {
    public static void main(String[] args) {
        Cat cat = new TrainCat();
        TrainCat trainCat =(TrainCat) cat;
        trainCat.zuanHuo();
        ((TrainCat) cat).zuanHuo();
    }
}

猫狗案例：（加入跳高的功能）

/*
        猫狗案例：加入跳高的功能
            分析：
                猫：
                    属性：姓名，年龄
                    行为：吃饭，睡觉
                狗：
                    属性：姓名，年龄
                    行为：吃饭，睡觉
            由于猫和狗存在共性，所以我们提取出来到一个新的类中
               动物：（抽象类）
                    属性：姓名，年龄
                    行为：吃饭(),睡觉()
               猫：继承自动物
               狗：继承自动物

           由于跳高是一个额外的功能，不是动物特有的，所以我们利用接口的方式去定义
               接口：
                    跳高
               部分的猫：实现接口
               部分的狗：实现接口

 */
abstract class Animal1{
    private String name;
    private int age;
    public void Animal1(){}

    public Animal1(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 abstract void sleep();
}
class cat extends Animal1{
    public void cat(){}

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

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

    @Override
    public void sleep() {
        System.out.println("猫蜷着睡觉");
    }
}
class dog extends Animal1 {
    public void dog(){}

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

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

    @Override
    public void sleep() {
        System.out.println("狗趴着睡觉");
    }
}
interface Jump{
    public abstract void jump();
}
class JumpCat extends Cat implements Jump{
    public void JumpCat(){}
    public JumpCat(String name,int age){
        super(name, age);
    }
    @Override
    public void jump() {
        System.out.println("猫跳高");
    }
}
class JumpDog extends dog implements Jump{

    public void JumpDog(){}

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

    @Override
    public void jump() {
        System.out.println("狗跳高");
    }
}
public class InterfanceDemo3 {
    public static void main(String[] args) {
        Animal1 animal1 = new dog("小白",2);
        animal1.eat();
        animal1.sleep();
        dog dog = new JumpDog("大白",3);
        ((JumpDog) dog) .jump();
        

    }
}