Java 接口和多态

小兔网

说明: 作者： King; 分类：计算机; 日期：2021年7月13日

一、接口

1.1 接口的概述

接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的类。

接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。

1.2 接口的格式&使用

1.2.1 接口的格式

与定义类的 class 不同，接口定义时需要使用 interface 关键字。

定义接口所在的仍为 .java 文件，虽然声明时使用的为 interface 关键字的编译后仍然会产生 .class 文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。

定义格式：

public interface 接口名 {    抽象方法1;    抽象方法2;    抽象方法3;}

1.2.2 接口的使用

接口中的方法全是抽象方法，直接 new 接口来调用方法没有意义，Java也不允许这样干。

类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用 implements。

其他类(实现类)实现接口后，就相当于声明： 我应该具备这个接口中的功能。实现类仍然需要重写方法以实现具体的功能。

格式：

class 类 implements 接口 {    重写接口中方法}

在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。

1.2.3 案例代码一

实例

/* * Java语言的继承是单一继承，一个子类只能有一个父类（一个儿子只能有一个亲爹） * Java语言给我们提供了一种机制，用于处理继承单一的局限性的，接口 *  * 接口：接口是一个比抽象类还抽象的类，接口里所有的方法全是抽象方法，接口和类的关系是实现，implements * interface *  * 格式： *         interface 接口名 { *  *         } *  */public class InterfaceDemo {    public static void main(String[] args) {        BillGates gates = new BillGates();        gates.code();    }}  class Boss {    public void manage() {        System.out.println("管理公司");    }} class Programmer {    public void code() {        System.out.println("敲代码");    }} //比尔盖茨class BillGates extends Programmer {    }

1.3 接口中成员的特点

1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解fnal关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

1.3.1 案例代码二

实例

/* * 接口的成员特点： *         只能有抽象方法 *         只能有常量 *         默认使用public&abstract修饰方法 *         只能使用public&abstract修饰方法 *         默认使用public static final来修饰成员变量 *  * 建议：建议大家手动的给上默认修饰符 *  * 注意： *         接口不能创建对象（不能实例化） *         类与接口的关系是实现关系，一个类实现一个接口必须实现它所有的方法  */public class InterfaceDemo2 {    public static void main(String[] args) {        //Animal a = new Animal();        //Animal.num;    }}  interface Animal {    public static final int num = 10;        public abstract void eat();} class Cat implements Animal {     public void eat() {            }    }

1.4 接口和类的关系

A:类与类之间: 继承关系,一个类只能直接继承一个父类,但是支持多重继承
B:类与接口之间: 只有实现关系,一个类可以实现多个接口
C:接口与接口之间: 只有继承关系,一个接口可以继承多个接口

1.4.1 案例代码三

实例

/* *  * 类与类：继承关系，单一继承，多层继承 * 类与接口：实现关系，多实现 * 接口与接口的关系：继承关系，多继承 */public class InterfaceDemo3 {    public static void main(String[] args) {            }} interface InterA extends InterB {    public abstract void method();} interface InterB {    public abstract void function();} interface InterC extends InterA {    } class Demo implements InterC {     @Override    public void method() {        // TODO Auto-generated method stub            }     @Override    public void function() {        // TODO Auto-generated method stub            }}

a.成员变量抽象类可以有成员变量，也可以有常量接口只能有常量，默认修饰符public static finalb.成员方法抽象类可以有抽象方法，也可以有非抽象方法接口只能有抽象方法，默认修饰符 public abstractc.构造方法抽象类有构造方法，为子类提供接口没有构造方法

/* * 篮球运动员和教练乒乓球运动员和教练现在篮球运动员和教练要出国访问,需要学习英语请根据你所学的知识,分析出来哪些是类,哪些是抽象类,哪些是接口 */public class InterfaceTest { public static void main(String[] args) { //创建篮球运动员对象 BasketBallPlayer bbp = new BasketBallPlayer(); bbp.name = "女兆月日"; bbp.age = 35; bbp.gender = "男"; bbp.sleep(); bbp.study(); bbp.speak(); System.out.println("-------------"); //创建乒乓球教练对象 PingpangCoach ppc = new PingpangCoach(); ppc.name = "刘胖子"; ppc.age = 40; ppc.gender = "男"; ppc.sleep(); ppc.teach(); //ppc.speak(); }} class Person { String name;//姓名 int age;//年龄 String gender;//性别 //无参构造 public Person() {} //有参构造 public Person(String name,int age,String gender) { this.name = name; this.age = age; this.gender = gender; } //吃 public void eat() { System.out.println("吃饭"); } //睡 public void sleep() { System.out.println("睡觉"); }} //学习说英语interface SpeakEnglish { public abstract void speak();} //运动员abstract class Player extends Person { //学习 public abstract void study();} //教练abstract class Coach extends Person { //教 public abstract void teach();} //篮球运动员class BasketBallPlayer extends Player implements SpeakEnglish{ @Override public void study() { System.out.println("学扣篮"); } @Override public void speak() { System.out.println("说英语"); } }//乒乓球运动员class PingpangPlayer extends Player { @Override public void study() { System.out.println("学抽球"); } }//篮球教练class BasketBallCoach extends Coach implements SpeakEnglish { @Override public void teach() { System.out.println("教扣篮"); } @Override public void speak() { System.out.println("说英语"); } }//乒乓球教练class PingpangCoach extends Coach { @Override public void teach() { System.out.println("教抽球"); } }

abstract class Fu { public abstract void method();}class Zi extends Fu { public void method(){ System.out.println(“重写父类抽象方法”); }}//类的多态使用Fu fu= new Zi();

interface Fu { public abstract void method();}class Zi implements Fu { public void method(){ System.out.println(“重写接口抽象方法”); }}//接口的多态使用Fu fu = new Zi();

/* * 多态的前提： * 子父类的继承关系 * 方法的重写 * 父类引用指向子类对象 * * 动态绑定：运行期间调用的方法，是根据其具体的类型 * * * * */public class PoymorphicDemo { public static void main(String[] args) { /*Cat c = new Cat(); c.eat();*/ //父类引用 Animal a //指向 = //子类对象 new Cat() Animal a = new Cat(); a.eat(); }} class Animal { public void eat() { System.out.println("吃东西"); }} class Cat extends Animal { public void eat() { System.out.println("猫吃鱼"); }}

/* * * 多态的成员特点: * 成员变量编译时看的是左边，运行时看的左边 * 成员方法编译时看的是左边，运行时看右边 * 静态方法编译时看的是左边，运行时看的也是左边 * * * 编译时看的都是左边，运行时成员方法看的是右边，其他（成员变量和静态的方法）看的都是左边 * */public class PoymorphicDemo2 { public static void main(String[] args) { Dad d = new Kid(); //System.out.println(d.num); //d.method(); d.function();//使用变量去调用静态方法，其实相当于用变量类型的类名去调用 }} class Dad { int num = 20; public void method() { System.out.println("我是父类方法"); } public static void function() { System.out.println("我是父类静态方法"); }} class Kid extends Dad { int num = 10; public void method() { System.out.println("我是子类方法"); } public static void function() { System.out.println("我是子类静态方法"); }}

/* * * 多态中的向上转型和向下转型: * * 引用类型之间的转换 * 向上转型 * 由小到大(子类型转换成父类型) * 向下转型 * 由大到小 * 基本数据类型的转换 * 自动类型转换 * 由小到大 * byte short char --- int --- long --- float --- double * 强制类型转换 * 由大到小 * * * */public class PoymorphicDemo3 { public static void main(String[] args) { Animal2 a = new Dog();//向上转型 //a.eat(); Dog d = (Dog)a;//向下转型 d.swim(); }} class Animal2 { public void eat() { System.out.println("吃东西"); }} class Dog extends Animal2 { public void eat() { System.out.println("啃骨头"); } public void swim() { System.out.println("狗刨"); }}

/* * * 多态的优缺点 * 优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性缺点：无法直接访问子类特有的成员 */public class PoymorphicDemo4 { public static void main(String[] args) { MiFactory factory = new MiFactory(); factory.createPhone(new MiNote()); factory.createPhone(new RedMi()); } } class MiFactory { /*public void createPhone(MiNote mi) { mi.call(); } public void createPhone(RedMi mi) { mi.call(); }*/ public void createPhone(Phone p) { p.call(); } } interface Phone { public void call();} //小米Noteclass MiNote implements Phone{ public void call() { System.out.println("小米Note打电话"); }} //红米class RedMi implements Phone { public void call() { System.out.println("红米打电话"); }}

Java 接口和多态

一、接口

1.1 接口的概述

1.2 接口的格式&使用

实例

1.3 接口中成员的特点

实例

1.4 接口和类的关系

实例

1.5 接口的思想

1.6 接口优点

1.7 接口和抽象类的区别

1.8 运动员案例

实例

二、多态

2.1 多态概述

2.2 多态的定义与使用格式

实例

2.3 多态成员的特点

实例

2.4 多态中向上转型与向下转型

实例

2.5 多态的优缺点

实例

最新文章

热门文章