Java面向对象之接口与多态

接口简介

当一个抽象类中所有的方法都是抽象的，那么就叫接口。接口中的抽象方法需要我们自己去实现，仅仅只是个架子。当然接口在jdk1.8中的特性，使得接口中也可以去实现方法。

接口的好处：

1.接口使代码分层，很清晰，使得代码可读性增强，同时使代=代码灵活性高，维护性强。

2.接口弥补了单继承得局限性。之前类得继承只能是单继承，而改成接口，就可以多继承了。

接口默认就是抽象的，不需要abstract修饰,同样的，他不能被实例化。也就是不能创建对象。

1.接口关键字 inferface

接口定义举例：

 inferface  Person{
     //PI这不是属性，是变量。接口中的变量前面 public static final 是默认隐藏的，不写也没事
	public static final double PI=3.14;
	public  void sleep();

	public void eat();

}

变量规范： 所有字母大写，单词之间用下划线。 如： PI_HELLO

2.导入接口使用的关键字：implements

语法 class <类名> implements <接口名>{

}

接口可以多级继承：（类也可以）

interface A{
    
}
interface B extends A{
    
}
interface C extends B{
    
}

接口间还可以多继承（类之间不可以）

interface A{
    public void method1();
    public void method2();
}
interface B{
    public void method2();
    public void method3();
}
interface C entends A，B{
   
    }

//导入接口C
class Test implements C{
    //抽象方法实现
    public void method1(){
        //..
    }
    public void method2(){
        //..
    }
    public void method3(){
        //...
    }
    
}

---

接口C继承了A，B两个接口，发现A，B中都有method2方法， 那么Test类中实现method2方法时是把method2两个方法重合了。因此不会编译错误。3.接口中多定义静态的方法，因为static修饰的方法，称之为类的方法，多使用在工具类中，这样我们就可以直接通过 <类名>.<方法>来直接调用方法。否则要创建对象来调用很麻烦。

3.接口在 jdk1.8之后的特性， 接口中的方法不再是抽象的，可以是静态的方法。

4.接口中的静态方法

因为static修饰的方法，称之为类（接口的）的方法，多使用在工具类（接口）中，这样我们就可以直接通过 <类名（接口名）>.<方法>来直接调用方法。否则要创建对象来调用很麻烦。

interface A{
    public static void method1(){
        System.out.println("我不是抽象方法");
    }
    
}
class Test{
    public static void main(String[] args){
    	//这是可以直接通过<接口名>.<方法名>调用的
    	A.method1();
	}
}

5.接口中的默认方法

关键字：default

也就是接口中通过default修饰的方法，可以在使用这个接口的类中 可以去实现它，也可以不去实现他，也可以通过调用对象来实现

interface Person{
    public default void method1(){
        System.out.println("我不是抽象方法");
    }
    
}
class Student implements Person{
   
    /**把这个方法的实现 注释掉， 编译也是不会错的。同样可以通过Student类进行创建对象，对方法进行调用。
    public void method1(){
       System.out.println("我不是抽象的方法");
   }*/
}
class Test{
     public static void main(String[] args){
    	Student s=new Student();
        s.method1();
	}
}

6.父子类之间的转换

1.子类转换成父类

class Teacher{

	String name;

	public void teach(){

		System.out.println("在教课");

	}

}
class JavaTeacher extends Teacher{
    //teach方法的覆写
    public void teach(){
        System.out.println("在教Java课");
     }
    public void PlayJava(){
        System.out.println("Java老师在玩Java");
    }
}
public class Test{
    public static void main(String[] args){
    	//子类自动转换为父类，但实际调用的时候，调用的是子类
        Teacher jt=new JavaTeacher();
        jt.name="张三";
        jt.teach();
        jt.PlayJava();
    }
}
// 代码结果： 在教java课

上述代码说明：父类引用Teacher指向子类对象JavaTeacher 。当父类和子类有相同方法被重写的时候，实际调用的都是JavaTeacher子类的方法
2.父类转换为子类

class Teacher{

	String name;

	public void teach(){

		System.out.println("在教课");

	}

}
class JavaTeacher extends Teacher{
    //teach方法的覆写
    public void teach(){
        System.out.println("在教Java课");
     }
    public void PlayJava(){
        System.out.println("Java老师在玩Java");
    }
}
public class Test{
    public static void main(String[] args){
    	//子类自动转换为父类，但实际调用的时候，调用的是子类
        Teacher jt=new JavaTeacher();
   
        jt.PlayJava();
    }
}
//代码结果：编译错误

上述代码说明：jt对象的真身是JavaTeacher,类型是Teacher，我们说实际jt实际调用的时候是调用的是JavaTeacher类，但是JavaTeacher类的特有的方法，是调用不了的。需要真正转换JavaTeacher类。

通过强制转换就可以调用子类特有的方法PlayJava方法了。

public class Test{
    public static void main(String[] args){
    	//子类自动转换为父类，但实际调用的时候，调用的是子类
        Teacher jt=new JavaTeacher();
   		//将真身为Javateacher的父类，强制真正转换为JavaTeacher类。
        JavaTeacher jt=(JavaTeacher)jt;
        jt.PlayJava();
    }
}

多态

多态是同样的行为具有不同的表现。

实现多态的三个必要条件：

• 要有继承
• 重写
• 父类引用指向子类对象

向上转型：通俗解释是将子类转换为父类。

1.通过继承该类的父类实现多态

来看一个案例：

class Teacher{

	String name;
}

class JavaTeacher extends Teacher{
    public void teach(){
        System.out.println("在教java课");
    }
   
}

class PHPTeacher extends Teacher{
    public void teach(){
        System.out.println("在教PHP");
    }
    
}
class Leader{
    public void check(JavaTeacher jt){
        System.out.println("开始讲课");
        jt.teach();
        System.out.println("给"+jt.name+"老师打分");
        }
    public void check(PHPTeacher pt){
        System.out.println("开始讲课");
        pt.teach();
        System.out.println("给"+pt.name+"老师打分");
    }
}
public class Test{
    public static void main(String[] args){
    	//子类自动转换为父类，但实际调用的时候，调用的是子类
        JavaTeacher jt=new JavaTeacher();
       	jt.name="张三";
        PHPTeacher pt=new PHPTeacher();
        pt.name="李四";
 		Leader leader=new Leader();
        leader.check(jt);
        leader.check(pt);
    }
}

上述代码说明：我们如果需要用Leader类的check方法来检查每一位老师，这里对Java和PHP两个老师分别写了一个方法，来检查。 但是如果有很多老师的话，那么我们需要写很多方法了，这就很麻烦。

那么有 什么办法来用同样的check方法，来对不同类的老师进行执行呢？

我们就通过多态的方式。

我们只需要更改为如下代码

class Leader{
    public void check(Teacher t){
        System.out.println("开始讲课");
        jt.teach();
        System.out.println("给"+t.name+"老师打分");
        }
    
}

代码说明：我们通过JavaTeacher 和PHPTeacher的父类Teacher作为参数传入check来实现多态。