Java中的接口
一、接口概述
接口就是一种公共的规范标准，只要符合标准，大家都可以通用
Java中的接口更多体现在对行为的抽象
二、接口的特点
1、接口用关键字interface修饰：
public interface 接口名 {}
2、类实现接口用implements表示：
public class 类名 implements 接口名 {}
3、接口不能实例化：
接口如何实例化？参照多态的方式，通过实现类对象实例化，这叫接口多态。
多态的形式：具体类多态，抽象多态，接口多态
多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象
4、接口的实现类：
要么重写接口中的所有抽象方法
要么是抽象类
5、参考代码：
package com.itheima_01;
/*
定义了一个接口 跳高
*/
public interface Jumpping {
public abstract void jump();
}
package com.itheima_01;
/*
定义一个猫类 来实现接口
*/
//此处不能使用关键字extends （那是类与类之间的继承）
//implements 实现
public class Cat implements Jumpping{
@Override
public void jump(){
System.out.println("猫可以跳高了");
}
}
package com.itheima_01;
/*
抽象类 来实现接口时不需要重写抽象方法
但是这个抽象类的子类在在实现方法时还是需要重写的
*/
public abstract class Dog implements Jumpping{
/* @Override
public void jump(){
}*/
}
package com.itheima_01;
/*
测试类
*/
public class JumppingDemo {
public static void main(String[] args){
// Jumpping j = new Jumpping(); 接口也是一个抽象内容不能直接实例化
//通过接口的实现类来 创建接口对象
Jumpping j = new Cat();
j.jump();
}
}
三、接口的成员特点
1、成员变量：
只能是常量
默认修饰符：public static final
2、构造方法：
接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在的
一个类如果没有父类，默认继承自Object类
3、成员方法：
只能是抽象方法
默认修饰符：public abstract
关于接口中的方法，JDK8和JDK9中有一些新特性（后面再学）
4、参考代码：
package com.itheima_02;
/*
接口
*/
public interface Inter {
//1、成员变量
public int num = 10;
public final int num2 = 20;
//接口成员变量 默认语句（包括访问权限修饰符）
//public static final int num3 = 30; //通过颜色（IDEA中）可以看到前面可以不写
int num3 = 30;
//2、接口是没有构造方法的
/*
可以想到一点，构造方法一般就是用于 构造对象 和 初始化成员变量
1、对于初始化成员变量而言：接口中的成员变量默认就是 静态且最终态，即无需初始化！
可以说没有具体存在
2、对于构造对象：
其一，本类无法直接构造对象。
其二，在实现类（类比子类）调用构造函数时执行默认语句super();
可以调用超类（Object） 一个类有父类间接继承Object 无父类直接继承Object
*/
// public Inter(){}
/* //3、接口里面是不能有抽象方法的
public void show(){}*/
//4、接口里面可以有抽象方法
public abstract void method();
//在接口中 默认方法为抽象方法可以 可以省略权限修饰符和状态修饰符
void show();
}
package com.itheima_02;
/*
接口的实现类：一般在接口名后加上Impl
*/
//public class InterImpl implements Inter{ } 等价于
public class InterImpl extends Object implements Inter{ //添加了extends Object
//
public InterImpl(){
super();
}
//重写抽象方法
@Override
public void method(){
System.out.println("method");
}
@Override
public void show(){
System.out.println("show");
}
}
package com.itheima_02;
/*
测试类
*/
public class InterfaceDemo {
public static void main(String[] args) {
Inter i = new InterImpl();
// i.num = 20; 无法修改 （在接口中成员变量默认被final修饰了）
//为了方便测试，在类中用public来修饰的
System.out.println(i.num);
// i.num2 = 40; 在类中被final修饰了
System.out.println(i.num2);
//可以通过接口名 直接访问（所以又说明了接口中的成员变量也被static修饰了）
System.out.println(Inter.num);
}
}
四、接口的案例
1、猫和狗：
利用重写方法多的类（一般是 子类/实现类都是 的那个类）
package com.itheima_03;
/*
定义一个跳高接口
*/
public interface Jumpping {
//一个跳高的抽象方法
public abstract void jump();
}
package com.itheima_03;
/*
定义一个抽象类来做 接口类的实现类
*/
//public abstract class Animal implements Jumpping {
public abstract class Animal {
//成员变量
private String name;
private int age;
//构造方法
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
//set/get/show成员方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return this.age;
}
public void show() {
System.out.println(getName() + "," + getAge());
}
//定义Animal类特有的抽象方法
public abstract void eat();
}
package com.itheima_03;
/*
定义一个猫类 继承Animal抽象类
*/
public class Cat extends Animal implements Jumpping{
//构造方法
public Cat(){}
public Cat(String name, int age){
//调用父类有参构造
super(name, age);
}
//重写抽象方法
@Override
public void jump(){ //父类是抽象类 并且在实现接口时 拿到了jump这个抽象方法
System.out.println("猫可以跳高了");
}
@Override
public void eat(){
System.out.println("猫吃老鼠");
}
}
package com.itheima_03;
/*
定义一个狗类继承 Animal抽象类
*/
public class Dog extends Animal implements Jumpping{
//构造方法
public Dog(){}
public Dog(String name, int age){
//调用父类有参构造
super(name, age);
}
//重写抽象方法
@Override
public void jump(){ //父类是抽象类 并且在实现接口时 拿到了jump这个抽象方法
System.out.println("狗可以跳高了");
}
@Override
public void eat(){
System.out.println("狗吃骨头");
}
}
package com.itheima_03;
/*
定义一个测试类测试 接口的使用
这种情况下：Animal类继承使得 子类在调用构造函数时可以找到父类 而无需去直接调用Object超类
!!!使用时 利用重写抽象方法最多 的类创建对象利于调用
（虽然也能够通过抽象父类来实现接口 从而使用父类引用调用重写方法，但是对于子类中的特有方法还是有点。。自己具体看。。）
*/
public class AnimalDemo {
public static void main(String[] args){
//定义一个猫类
Animal a1 = new Cat();
a1.setName("Tom");
a1.setAge(10);
a1.show();
a1.eat();
//a1.jump(); //报错
//通过向下转型 父类引用转换为子类对象来调用（子类中重写了方法）
//((Cat)a1).jump();
Jumpping j1 = new Cat();
j1.jump();
System.out.println("---------------------");
Animal a2 = new Cat("加菲猫", 8);
a2.show();
a2.eat();
//a2.jump(); 报错
//通过向下转型 父类引用转换为子类对象来调用（子类中重写了方法）
//((Cat)a2).jump();
Jumpping j2 = new Cat(); //带参数也行
j2.jump();
System.out.println("---------------------");
//直接使用 重写最多的本类
Cat c = new Cat();
c.setName("黑猫");
c.setAge(3);
c.show();
c.eat();
c.jump();
System.out.println("---------------------");
Cat c2 = new Cat("白猫", 6);
c2.show();
c2.eat();
c2.jump();
System.out.println("---------------------");
//定义一个狗类
Dog d = new Dog();
d.setName("来福");
d.setAge(7);
d.show();
d.eat();
d.jump();
System.out.println("---------------------");
Dog d2 = new Dog("旺财", 6);
d2.show();
d2.eat();
d2.jump();
}
}