蒋振飞的博客 - Java入门08:接口与多态   
正在加载蒋振飞的博客...
V3.0
蒋振飞的博客

Java入门08:接口与多态

发布时间: 2018年09月12日 发布人: 蒋振飞 热度: 369 ℃ 评论数: 0

一、接口

1.接口的概述  

    ①接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的”类”。
    ②接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离,优化了程序设计。

2.接口的格式

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

// 定义格式
public interface 接口名 {
    抽象方法1;
    抽象方法2;
    抽象方法3;
}

3.接口的使用

    ①接口中的方法全是抽象方法,直接new接口来调用方法没有意义,Java也不允许这样干。
    ②类与接口的关系为实现关系,即类实现接口。实现的动作类似继承,只是关键字不同,实现使用implements。
    ③其他类(实现类)实现接口后,就相当于声明:”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。

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

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

4.接口中成员的特点

    ①接口中可以定义变量,但是变量必须有固定的修饰符修饰,public static final 所以接口中的变量也称之为常量,其值不能改变。
    ②接口中可以定义方法,方法也有固定的修饰符,public abstract。
    ③接口不可以创建对象。
    ④子类必须覆盖掉接口中所有的抽象方法后,子类才可以实例化,否则子类是一个抽象类。

 package day07;
/*
 * 接口的成员特点:
 * 		只能有抽象方法
 * 		只能有常量
 * 		默认使用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() {
		
    }
	
}

5.接口和类的关系

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

package day07;

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
    }
}

6.接口的思想

    ①举例:我们都知道电脑上留有很多个插口,而这些插口可以插入相应的设备,这些设备为什么能插在上面呢?主要原因是这些设备在生产的时候符合了这个插口的使用规则,否则将无法插入接口中,更无法使用。发现这个插口的出现让我们使用更多的设备。
    ②接口的出现方便后期使用和维护,一方是在使用接口(如电脑),一方在实现接口(插在插口上的设备)。例如:笔记本使用这个规则(接口),电脑外围设备实现这个规则(接口)。

7.接口优点

    ①类与接口的关系,实现关系,而且是多实现,一个类可以实现多个接口,类与类之间是继承关系,java中的继承是单一继承,一个类只能有一个父类,打破了继承的局限性。
    ②对外提供规则(USB接口)。
    ③降低了程序的耦合性(可以实现模块化开发,定义好规则,每个人实现自己的模块,提高了开发的效率)。

8.接口和抽象类的区别

    1) 共性

        不断的进行抽取,抽取出抽象的,没有具体实现的方法,都不能实例化(不能创建对象)。

    2) 区别1:与类的关系

        类与接口是实现关系,而且是多实现,一个类可以实现多个接口,类与抽象类是继承关系,Java中的继承是单一继承,多层继承,一个类只能继承一个父类,但是可以有爷爷类。

    3) 区别2:成员

        ①成员变量
            抽象类可以有成员变量,也可以有常量。
            接口只能有常量,默认修饰符public static final。
        ②成员方法
            抽象类可以有抽象方法,也可以有非抽象方法。
            接口只能有抽象方法,默认修饰符 public abstract。
        ③构造方法
            抽象类有构造方法,为子类提供。
            接口没有构造方法。

9.运动员案例

package day07;
/*  
 *  篮球运动员和教练
    乒乓球运动员和教练
    现在篮球运动员和教练要出国访问,需要学习英语
    根据所学的知识,分析出来哪些是类,哪些是抽象类,哪些是接口
 */
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("教抽球");
    }
   
}

二、匿名对象 & final

1.匿名对象定义

    匿名对象即无名对象,直接使用new关键字来创建对象

2.匿名对象的应用场景

    ①当方法只调用一次的时候可以使用匿名对象
    ②可以当作参数进行传递,但是无法在传参之前做其他的事情

3.匿名对象的使用

package day07;

public class AnonymousObejctDemo {
    public static void main(String[] args) {
        // Student s = new Student();
        // s.study();
        // s.study();
        // s.study();
       
        // new Student();// 匿名对象,没有变量引用的对象
        // new Student().study();
        // new Student().study();
        // new Student().study();
       
        // new Student().age = 18; 
        // 输出0,因为new分别创建了两个不同的对象
        // System.out.println(new Student().age);
       
       
        // Student s = new Student();
        // s.age = 18;
        // s.name = "张三";
        // method(s);
       
        method(new Student());
       
    }
   
    public static void method(Student s) {
       
    }
 
       
}

class Student {
    String name;
    int age;
   
    public void study() {
        System.out.println("好好学习,高薪就业");
    }
}

4.final关键字

    ①final:修饰符,可以用于修饰类、成员方法和成员变量
    ②final所修饰的类:不能被继承,不能有子类
    ③final所修饰的方法:不能被重写
    ④final所修饰的变量:是不可以修改的,是常量

package day07;
/*
 * 
 * 常量:
 *      字面值常量:1,2,3
 *      自定义常量:被final所修饰的成员变量,一旦初始化则不可改变
 * 
 * 注意:自定义常量必须初始化,可以选择显示初始化或者构造初始化
 * 
 *  
 */
public class FinalDemo {
    public static void main(String[] args) {
        // Animal a = new Animal();
        // a.eat();
       
        Dog d = new Dog();
        // d.eat();
       
        // d.num = 20;
        System.out.println(d.NUM);
    }
}
 
/*final*/ class Animal {
    public final void eat() {
        System.out.println("吃东西");
    }
}
 
class Dog extends Animal {
    /*public void eat() {}*/
   
    final int NUM;
   
    public Dog() {
        NUM = 10;
    }
}

三、多态

1.多态概述

    ①多态是继封装、继承之后,面向对象的第三大特性
    ②现实事物经常会体现出多种形态,如学生,学生是人的一种,则一个具体的同学张三既是学生也是人,即出现两种形态
    ③Java作为面向对象的语言,同样可以描述一个事物的多种形态。如Student类继承了Person类,一个Student的对象便既是Student,又是Person

2.多态的定义与使用格式

    ①多态的定义格式:就是父类的引用变量指向子类对象

父类类型  变量名 = new 子类类型();
变量名.方法名();

    ②普通类多态定义的格式

父类 变量名 = new 子类();
如:class Fu {}
class Zi extends Fu {}
// 类的多态使用
Fu f = new Zi();

    ③抽象类多态定义的格式

// 抽象类 变量名 = new 抽象类子类();
// 如:	
abstract class Fu {
    public abstract void method();
}

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

    ④接口多态定义的格式

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

3.多态成员的特点

    1)多态成员变量

        ①编译时期:参考的是引用型变量所属的类中是否有被调用的成员变量。没有,编译失败
        ②运行时期:也是调用引用型变量所属的类中的成员变量
        ③简单记:编译和运行都参考等号的左边。编译运行看左边

    2)多态成员方法

        ①编译时期:参考引用变量所属的类,如果没有类中没有调用的方法,编译失败
        ②运行时期:参考引用变量所指的对象所属的类,并运行对象所属类中的成员方法
        ③简而言之:编译看左边,运行看右边

package day 07;

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("我是子类静态方法");
    }
}

4.多态中向上转型与向下转型

    1) 向上转型

        当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。

父类类型  变量名 = new 子类类型();
如:Person p = new Student();

    2) 向下转型

        一个已经向上转型的子类对象可以使用强制类型转换的格式,将父类引用转为子类引用,这个过程是向下转型。如果是直接创建父类对象,是无法向下转型的

子类类型 变量名 = (子类类型) 父类类型的变量
如:Student stu = (Student) p;  // 变量p 实际上指向Student对象
package day7;

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("狗刨");
    }
}

5.多态的优缺点  

    ①优点:可以提高可维护性(多态前提所保证的),提高代码的可扩展性。
    ②缺点:无法直接访问子类特有的成员。

package day07;

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();
}

// 小米Note
class MiNote implements Phone{
    public void call() {
        System.out.println("小米Note打电话");
    }
}

// 红米
class RedMi implements Phone {
    public void call() {
        System.out.println("红米打电话");
    }
}

打赏 蒋振飞

取消

感谢您的支持,我会继续努力的!

扫码支持
一分也是爱     一块不嫌多

点击 支付宝 或 微信 打赏蒋振飞

打开支付宝扫一扫,即可进行扫码打赏哦

评论列表