笔记11-多态&抽象类&接口

最新推荐文章于 2022-05-09 14:57:00 发布

Saito__Asuka

最新推荐文章于 2022-05-09 14:57:00 发布

阅读量181

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/qq_36463278/article/details/107527811

版权

笔记专栏收录该内容

72 篇文章 1 订阅

订阅专栏

多态

多态概述

同一个对象,在不同时刻表现出来的不同形态

举例: 猫
我们可以说猫是猫: 猫 cat = new 猫();
也可以说: 动物 animal = new 猫();
这里猫在不同的时刻表现出了不同的形态,这就是多态

多态的前提和体现

有继承 /实现关系
有方法重写
有父类引用指向子类对象

多态

//父类
public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}
//子类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
//测试类
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();//输出猫吃鱼
    }
}

多态中成员访问特点

成员变量: 编译看左边,执行看右边
成员方法: 编译看左边,执行看右边

为什么成员变量和成员方法的访问不一样呢?
因为成员方法有重写,而成员变量没有

public class Animal {
    public int age =10;
    public  void eat(){
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal {
    public int age =20;
    public int weight = 30;

    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();

        System.out.println(a.age);
        //成员变量编译运行都看父类指向父类
        //System.out.println((a.weight);
        a.eat();
        //成员方法编译看父类,运行看子类
        //a.playGame();
    }
}

多态的好处和弊端

多态的好处: 提高了程序的扩展性
具体体现:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型进行操作
多态的弊端: 不能使用子类的特有功能

//父类
public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
}
package com.itdemo_11;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
     public void lookDoor(){
        System.out.println("狗看门");
    }
}

/*
动物操作类
 */
public class AnimalOperator {
    /*
    public void useAnimal(Cat c){//Cat c = new Cat();
        c.eat();
    }
    public void useAnimal(Dog d){//Dog d = new Dog()
        d.eat();
    }
    */

    public void useAnimal(Animal a){
        //animal a = new Cat();
        //Animal a = new Dog()
        a.eat();
        //不能访问子类特有功能
//        a.lookDoor();
    }
}


//测试类
public class AnimalDemo {
    public static void main(String[] args) {
        //创建动物操作类,调用方法
        AnimalOperator ao = new AnimalOperator();
        Cat c = new Cat();
        ao.useAnimal(c);

        Dog d = new Dog();
        ao.useAnimal(d);
    }
}

多态中的转型

向上转型
从子到父
父类引用指向子类对象
向下转型
从父到子
父类引用转为子类对象

package com.itdemo_12;

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

package com.itdemo_12;

public class Cat extends Animal {
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void game(){
        System.out.println("猫捉迷藏");
    }
}

package com.itdemo_12;

public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat();//向上转型
        a.eat();
        //子类的特有方法报错
//        a.game();

        /*
        //因重复new Cat() 所以不用这种方法
        //创建cat类的对象
        Cat c = new Cat();
        c.eat();
        c.game();
        */

        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.game();

        //或者直接
        ((Cat) a).game();
    }
}

内存多态的转型

在这里插入图片描述

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void Game(){
        System.out.println("猫捉迷藏");
    }
}
public class Dog extends Animal{
   @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }
}


public class AnimalDemo {
    public static void main(String[] args) {
        //多态
//      向上转型
        Animal a = new Cat();
        a.eat();
//      a.Game();//报错

//        向下转型
        Cat c = (Cat) a;
        c.eat();
        c.Game();

//        向上转型
        a = new Dog();
        a.eat();

        //向下转型
        //classCostException类型转换异常
        Cat cc = (Cat)a;
        cc.eat();
        cc.Game();
    }
}

案例:猫和狗

需求: 请采用多态的思想实现猫和狗的案例,并在测试类中进行测试
思路:

定义动物类(Animal)
成员变量: 姓名,年龄
构造方法: 无参,带参
成员方法: get/set方法,吃饭()
定义猫类(Cat),继承动物类
构造方法: 无参,带参
成员方法: 重写吃饭();
定义狗类(Dog),继承动物类
构造方法:无参,带参
成员方法:重写吃饭()
定义测试类(AnimalDemo),写代码测试

//父类
public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void eat(){
        System.out.println("动物吃东西");
    }
}

//子类
public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

//测试类
public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类对象进行测试
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        //创建狗类对象进行测试
        Animal a1 = new Dog();
        a1.setName("二哈");
        a1.setAge(3);
        System.out.println(a1.getName()+","+a1.getAge());
        a1.eat();
    }
}

抽象类的概述

当我们在做子类共性功能抽取时,有些方法在父类中并没有具体的体现,这个时候就需要抽象类了!
在java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类!

public  abstract class Animal01 {
    /*
    //有些方法在父类中没有具体的体现
    public void eat(){
        System.out.println("吃东西");
    }
    */
    //所以需要抽象类
    public abstract void eat();
}


public class AnimalDemo01 {
    public static void main(String[] args) {
        /*不能直接引用抽象类
        Animal01 a = new Animal01();
        a.eat();
        */
    }
}

抽象类的特点

抽象类和抽象方法必须使用abstract关键字修饰
//抽象类的定义
public abstract class 类名{ }
//抽象方法的定义
public abstract void eat();
抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
抽象类不能实例化
抽象类如何实现实例化? 参照多态的方式,通过子类对象实例化,这叫抽象类多态
抽象类的子类
要么重写抽象类中的所有抽象方法
要么是抽象类

public abstract class Animal02 {
    //抽象方法只能存在抽象类中
    public abstract void  eat();
    //抽象类中可以有非抽象方法
    public void sleep(){
        System.out.println("睡觉");
    }
}

/*
//非抽象化子类继承未重写抽象方法报错
public class Cat01 extends Animal02 {
    @Override
    public void sleep() {
        super.sleep();
    }
}
*/
//子类继承抽象方法并调用抽象方法不报错
/*
public  class  Cat01 extends Animal02{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
*/
//子类也是抽象类继承不调用正确
public class Cat01 extends Animal02{
    @Override
    public void eat() {
        System.out.println("吃");
    }

    @Override
    public void sleep() {
        System.out.println("睡");
    }
}

public class AnimalDemo02 {
    public static void main(String[] args) {
        /*
        //抽象类不能实例化
        Animal02 a = new Animal02();
        */

        Animal02 a = new Cat01();
        a.eat();
        a.sleep();
    }
}

抽象类的成员特点

成员变量
可以是变量
也可以是常量
构造方法
有构造方法,但是不能实例化
那么,构造方法的作用是什么呢?用于子类访问父类数据的初始化
成员方法
可以有抽象方法: 限定子类必须完成某些动作
也可以有非抽象方法: 提高代码复用性

public abstract class Animal {
    //
    private int age =20;
    //final 最终量,常量不可更改
    private final String city ="北京";

    public Animal(){ }

    public Animal (int age){
        this.age =age;
    }

    public void show(){
        age = 40;
        System.out.println(age);
//        city="上海";
        System.out.println(city);
    }
    public abstract void eat();
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

案例: 猫和狗
需求:请采用抽象类的思想实现猫和狗的案例,并在测试类中进行测试
思路:

定义动物类(Animal)
成员变量: 姓名,年龄
构造方法: 无参,带参
成员方法: get/set方法,吃饭();
定义猫类(Cat),继承动物类
构造方法: 无参,带参
成员方法: 重写吃饭(){…}
定义狗类(Dog),继承动物类
构造方法: 无参,带参
成员方法: 重写吃饭(){…}
定义测试类(AnimalDemo),写代码测试

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}

public class Cat extends Animal {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}


public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象,按照多态的方式
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(3);
        System.out.println(a.getName()+"."+a.getAge());
        a.eat();
        System.out.println("-------------");

        a = new Cat("罗宾",4);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        System.out.println("-------------");

        Animal a1 = new Dog();
        a1.setName("欧弟");
        a1.setAge(2);
        System.out.println(a1.getName()+","+a1.getAge());
        a1.eat();
        a1 = new Dog("罗宾",4);
        System.out.println(a1.getName()+","+a1.getAge());
        a1.eat();

    }
}

接口

接口概述

接口就是一种公共的规范标准,只要符合规范标准,大家都可以通用
java中的接口更多体现在对行为的抽象

接口的特点(记忆)

接口用关键字interface修饰
public interface 接口名{ }
类实现接口用implements表示
public class 类名 implements 接口迷你{ }
接口不能实例化
接口如何实例化呢? 参照多态的方式,通过实现类对象实例化,这叫接口多态
多态的形式: 具体类多态, 抽象类多态, 接口多态
接口的子类
要么重写接口中的所有抽象方法
要么子类也是抽象类

/*
定义了一个接口
 */
public interface Jumping {
    public abstract void jump();
}

//类继承接口通过implements连接实现
public class Cat implements Jumping {
    @Override
    public void jump() {
        System.out.println("猫会跳");
    }
}

public class JumpingDemo {
    public static void main(String[] args) {
        //不能直接实例化
        // Jumping j = new Jumping();
        Jumping j = new Cat();
        j.jump();
    }
}

接口的成员特点

成员变量
只能是常量
默认修饰符: public static final
构造方法
接口没有构造方法,因为接口主要是对行为进行抽象的,是没有具体存在
一个类如果没有父类,默认继承自Object类
成员方法
只能是抽象方法,
默认修饰符: public abstract
关于接口中的方法, JDk8和JDK9中有些新特性

接口类

/*
定义接口
 */
public interface Inter {
    public int num =10;
    public final int num2 = 30;
    public static final int num3 =20;
    //接口中默认为常量,final
    int num4 =20;
    
   
    /*  //接口中,成员方法是抽象的
    public Inter(){};
    public void show(){
    }
    */
    //抽象方法没哟方法体
    public abstract void show();
//    默认为抽象
    void shows();
}

实现类

//实现类
public class InterImpl implements Inter {
    public InterImpl() {
    }
//必须将接口中的成员方法全部重写
    @Override
    public void show() {
        System.out.println("show");
    }

    @Override
    public void shows() {
        System.out.println("shows");
    }
}

```测试类
```java
public class InterfaceDemo {
    public static void main(String[] args) {
        Inter i= new InterImpl();
        //final静态常量,
        //i.num =20;
        System.out.println(i.num);
        System.out.println(Inter.num);
    }
}

案例: 猫和狗
需求: 对猫和狗进行训练,他们就可以跳高了,这里加入了跳高功能,请采用抽象类和接口来实现猫狗案例,并在测试类中进行测试
思路:

定义一个动物类(Animal)
构造方法: 无参,带参.
成员变量: 姓名,年龄
成员方法: set/get方法,吃法
定义一个接口 ,
成员方法 : 跳高()
定义一个猫类,继承动物类,实现接口
构造方法: 无参,带参
成员方法: 重写吃饭方法,重写跳高方法
定义一个狗类,继承动物类,实现接口
构造方法: 无参,带参
成员方法:重写吃饭方法,重写跳高方法

动物类 (父类)

//抽象类
public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //抽象方法
    public abstract void eat();
}

接口

public interface Jumping {
    public abstract void jump();
}

子类

public class Cat extends Animal implements Jumping {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void jump(){
        System.out.println("猫会跳");
    }
}

测试类

package com.itdemo_18;

public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象,调用方法
        Jumping j = new Cat();
        j.jump();
        System.out.println("--------");

        //无参
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(3);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
//        a.jump();
        ((Cat) a).jump();

        //带参
        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("-----------");

        //真正使用方法
        Cat c  = new Cat();
        c.setName("萌萌");
        c.setAge(4);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

类和接口的关系

类和类的关系
继承关系,只能单继承,但是可以多层继承
类和接口的关系
实现关系,可以单继承, 也可以多实现,还可以在继承一个类的同时实现多个接口
接口和接口的关系
继承关系, 可以单继承, 也可以多继承

//接口可以多继承 也可单继承
public interface Inter03 extends Inter01,Inter02 {
}

//类和接口可以单继承也可以多实现
public class InterImpl extends Object implements Inter01,Inter02,Inter03 {
}

抽象类和接口的区别

成员区别
抽象类 : 变量,常量; 有构造方法; 有抽象方法; 也有非抽象方法
接口 : 常量 ;抽象方法
关系区别
类与类 ; 继承;单继承
类与接口 ; 实现, 可以单实现,多实现
接口,接口 : 继承 ,单继承 ,多继承
设计理念区别
抽象类 : 对类抽象,包括属性, 行为
接口 : 对行为抽象,主要是行为
门和警报的例子

在这里插入图片描述

案例:运动员和教练
需求: 我们现在有乒乓球运动员和篮球运动员,乒乓球教练和篮球教练,为了出国交流, 跟乒乓球相关的人员都要学习英语, 请用所学知识分析, 这个案例纵有哪些具体类, 哪些抽象类,哪些接口,并用代码实现
分析:
具体类: 乒乓球运动员篮球运动员乒乓球教练篮球教练
抽象类运动员学习教练教()
抽象类人姓名 ,年龄吃饭
接口学习英语

思路:

定义英语接口成员方法说英语
定义抽象人类成员变量 :姓名,年龄构造方法,无参,带参,成员方法 get/set方法,吃饭
定义抽象教练类继承人类构造方法无参带参 ,成员方法教
定义抽象运动员类继承人类构造方法无参带参,成员方法学英语
定义具体篮球教练类继承教练类构造方法,无参带参,成员方法重写吃饭,重写交
定义乒乓球教练具体类继承教练类实现说英语接口构造方法无参带参,成员方法,重写吃饭,重写交重写说英语
定义具体篮球运动员类继承运动员类构造方法无参带参,成员方法:重写吃饭,重写学习
定义具体乒乓球运动员类继承运动员类构造方法无参带参 ,成员方法重写吃饭, 重写学习,重写说英语
定义测试类,写代码测试

package com.itdemo_19;
/*抽象类 人类*/
public abstract class People {
    private String name;
    private int age;

    public People() {
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}

package com.itdemo_19;
/*抽象类 子类 教练类*/
public abstract class Coach extends People {
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract  void teach();
}

public abstract class Player extends People {
    public Player() {
    }

    public Player(String name, int age) {
        super(name, age);
    }
    public abstract void study();
}

package com.itdemo_19;

public interface SpeakEnglish {

    public abstract void speak();
}

package com.itdemo_19;

public class BasketballCoach extends Coach {
    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练教篮球");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃东西");
    }
}

package com.itdemo_19;

public class BasketballPlayer extends Player {
    public BasketballPlayer() {
    }

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃东西");
    }

    @Override
    public void study() {
        System.out.println("篮球运动员学篮球");
    }
}

package com.itdemo_19;

public class PingPangCoach extends Coach  implements SpeakEnglish{
    public PingPangCoach() {
    }

    public PingPangCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃东西");
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练教乒乓");
    }

    @Override
    public void speak() {
        System.out.println("教练说英语");
    }
}

package com.itdemo_19;

public class PingPongPlayer extends Player implements SpeakEnglish{
    public PingPongPlayer() {
    }

    public PingPongPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("吃东西");
    }

    @Override
    public void study() {
        System.out.println("学乒乓");
    }
    public void speak(){
        System.out.println("说英语");
    };
}

package com.itdemo_19;

public class Test {
    public static void main(String[] args) {
        BasketballCoach bc = new BasketballCoach();
        bc.setName("赤木");
        bc.setAge(32);
        System.out.println(bc.getName()+","+bc.getAge());
        bc.eat();
        bc.teach();

        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("赤木");
        bp.setAge(32);
        System.out.println(bp.getName()+","+bp.getAge());
        bp.eat();
        bp.study();

        PingPangCoach ppc = new PingPangCoach();
        ppc.setName("赤木");
        ppc.setAge(32);
        System.out.println(ppc.getName()+","+ppc.getAge());
        ppc.eat();
        ppc.teach();
        ppc.speak();

        PingPongPlayer ppp = new PingPongPlayer();
        ppp.setName("赤木");
        ppp.setAge(32);
        System.out.println(ppp.getName()+","+ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speak();

        ppp = new PingPongPlayer("萌萌",23);
        System.out.println(ppp.getName()+","+ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speak();
    }
}

Saito__Asuka

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
笔记11-多态&抽象类&接口

多态多态概述同一个对象,在不同时刻表现出来的不同形态举例: 猫我们可以说猫是猫: 猫 cat = new 猫();也可以说: 动物 animal = new 猫();这里猫在不同的时刻表现出了不同的形态,这就是多态多态的前提和体现有继承 /实现关系有方法重写有父类引用指向子类对象多态//父类public class Animal { public void eat(){ System.out.println("动物吃东西"); }}//子类
复制链接

扫一扫