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课

上述代码说明:子类的实例指向父类的引用,那么自动转换为父类,但实际调用的时候,是调用的是子类。

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来实现多态。

©️2020 CSDN 皮肤主题: 黑客帝国 设计师: 上身试试 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值