Java 接口与内部类

1、什么是接口？

1、接口中成员变量的访问特点

2、接口中成员方法的访问特点

3、接口是没有构造方法的

4、猫和狗接口代码演示

5、接口和类的关系

6、接口练习案例

2、什么是内部类

1、概念

2、成员内部类

3、静态内部类

4、局部内部类

5、匿名内部类

1、什么是接口？

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
Java中的接口更多的体现在对行为的抽象！

1.接口 用关键字interface 修饰
public interface 接口名{}

2.类实现接口用 implements 表示
public class 类 implements 接口 {}

3.接口不能够实例化
接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。
多态的形式：具体类多态，抽象类多态，接口多态。

4.多态的前提：有继承或者实现关系；有方法重写;有父(类/接口引用)指向(子/实现)类对象

5.接口的实现类，要么重写接口中所有的抽象方法、要么是抽象类

package jiekopudemo01;

public interface Animal {
    //接口Animal
    public abstract void eat();
}




package jiekopudemo01;

public class Catimpl implements Animal {
    @Override
    public void eat() {
        System.out.println("我们是好人呀！");

        //Catimpl是实现类  ， 实现了我们的Anamil接口！

        /**
         * 实现类必须要重写接口中所有的方法！
         */
    }
}




package jiekopudemo01;

public class Test {
    public static void main(String[] args) {
        //接口是不能进行实例化的
        // Animal animal = new Animal();
        //程序会提示报错！

        Catimpl catimpl = new Catimpl();
        catimpl.eat();
    }
}

1、接口中成员变量的访问特点

2、接口中成员方法的访问特点

不需要写  public abstract  的

因为在接口处写方法默认就是抽象方法

如果想在接口中定义非抽象方法，那么就要嫁一个关键字-->default
但是此方法只限于jdk以后的版本，jdk8以前是不能使用这个方法的！

3、接口是没有构造方法的

在接口中，不能直接构造方法使用
接口中的抽象类是有抽象方法的！

4、猫和狗接口代码演示

接口

package jiekopudemo03;

public interface JumpInterface {
    /**
     * 跳高方法  -- 将publci abstract
     */
    void jump();
}



Animal类

package jiekopudemo03;

public abstract class Animal implements JumpInterface {
    private String name;//姓名！
    private int age;//年龄！

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

    public Animal() {
    }

    /**
     * 如果加上abstract  -- 相当于有了一个jump抽象方法！
     */


    public abstract void eat();


    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

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



猫类

package jiekopudemo03;

import com.sun.xml.internal.stream.events.NamedEvent;

public class Cat extends Animal {
    public Cat(String name, int age) {
        //构造方法第一行默认调用父类中的午无参构造方法 -- super()

        super(name, age);

    }

    @Override
    public void jump() {
        System.out.println("我是猫类！我在跳高！");
    }

    @Override
    public void eat() {
        System.out.println("我是猫咪！我在吃鱼！");
    }


}



狗类

package jiekopudemo03;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("我是狗类，我在干饭！");
    }

    @Override
    public void jump() {
        System.out.println("我是狗类，我在跳高！");
    }
}



测试类


package jiekopudemo03;

public class AnimalDemo {
    public static void main(String[] args) {
        JumpInterface cat = new Cat("小猫", 2);
        cat.jump();
        //cat.eat  // 报错！  编译看左边，JumpInterface接口中没有eat方法！

        System.out.println("------------------");
        Animal cat2 = new Cat("大猫", 5);
        System.out.println(cat2.getName() + ", " + cat2.getAge());
        cat2.eat();//不会报错是因为Animal类中有eat抽象方法！
        cat2.jump();
        System.out.println("--------------------");
        Animal dog = new Dog();
        dog.setName("我是小狗");
        dog.setAge(12);
        System.out.println(dog.getName() + ", " + dog.getAge());
        dog.eat();
        dog.jump();
    }
}

5、接口和类的关系

小结：

1、类与类之间的关系：一个类只能单继承一个父类，不能同时继承n多个不同的父类！   可以多层继承父类，但不能同时继承多个父类！

2、类与接口之间的关系：一个类可以实现n多个不同的接口    也就是说，在一个类中可以加入多个接口！

3、接口与接口的关系：一个接口是可以继承n多个不同的接口的！  接口和接口之间是可以进行多继承的！

如果接口1继承接口2和接口3，那么接口1中就会继承接口2和接口3的方法！

小结

成员区别
1.1、在抽象类中的是有变量和常量的，有构造方法的，有抽象方法也有非抽象方法
1.2、在接口中，只有常量、抽象方法！但是在JDK8往后，在接口中就可以定义非抽象方法
  
关系区别 
2.1、类与类只能进行单继承
2.2、类与接口可以实现单继承和多继承

设计区别
抽象类是对类进行抽象，包括属性的行为(对事物的抽象)
接口是对行为进行抽象，主要是对行为的抽象

我们可以通过接口的形式附加很多功能！

6、接口练习案例

抽象类

package jiekopudemo04;

public abstract class Door {
    /**
     * 开门的抽象方法
     */
    public abstract void opendoor();


    /**
     * 关门的抽象方法
     */
    public abstract void closedoor();
}



接口
package jiekopudemo04;

public interface FR {
    void fr();//人脸识别功能！
}




package jiekopudemo04;

public interface Alarm {
    void alarm();//报警功能！
}



door1类
package jiekopudemo04;

public class door1 extends Door implements Alarm {
    @Override
    public void opendoor() {
        System.out.println("我是door1，我可以开门！");
    }

    @Override
    public void closedoor() {
        System.out.println("我是door1，我可以关门！");
    }

    @Override
    public void alarm() {
        System.out.println("我是door1，我可以报警！！！");
    }
}



door2类
package jiekopudemo04;

public class door2 extends Door implements FR {
    @Override
    public void opendoor() {
        System.out.println("我是door2，我可以开门！");
    }

    @Override
    public void closedoor() {
        System.out.println("我是door2，我可以关门！");
    }

    @Override
    public void fr() {
        System.out.println("我是door2，我有人脸识别功能！");
    }
}



测试类

package jiekopudemo04;

public class Test {
    public static void main(String[] args) {
        Door door1 = new door1();
        door1.opendoor();
        door1.closedoor();
        Alarm alarm = new door1();
        alarm.alarm();

        System.out.println("---------------------------");

        Door door2 = new door2();
        door2.closedoor();
        door2.opendoor();
        FR fr = new door2();
        fr.fr();
    }
}

2、什么是内部类

1、概念

在类的内部定义的类为内部类。

package AnimalParent05;

public class opop {
    //外部类
    private int age = 11;
    public int code = 12;


    //内部类
    public class opop1 {
        public void opop1() {
            System.out.println("我是内部类");
            System.out.println(age);
            System.out.println(code);
        }
    }

    public void opop() {
        opop1 opop1 = new opop1();
        opop1.opop1();
    }
}

package AnimalParent05;

public class Test {
    public static void main(String[] args) {
        opop opop = new opop();
        opop.opop();
    }
}