类的关系和多态

最新推荐文章于 2022-09-08 16:14:08 发布

沙皮狗你不懂

最新推荐文章于 2022-09-08 16:14:08 发布

阅读量203

点赞数 1

文章标签：多态

本文链接：https://blog.csdn.net/rq12345688/article/details/110354629

版权

类的关系

有一个人，叫张三，他们家养了两只宠物，张三可以喂养宠物，张三可以开关家里的包括门，电视，电脑
类的关系分类
- 继承关系：子类继承父类，符合is-a的关系，实现通过extends关键字
- 实现关系：实现类实现接口。符合like-a的关系。通过关键字implements实现（体现在行为上）
- 依赖关系：A类依赖于B这个类，某个类借助其他类的行为或者属性，我们就说这个类依赖于被利用的类。一般体现在代码上是以参数的形式出现的。
- 关联关系：两个类共同完成一件事，没有任何一个都不行。两个类我们就是说是关联关系。一般体现在代码上是以属性的方式出现的。
- 聚合关系：两个类的关系类似于组合关系，在代码上的体现跟组合关系是一样的。只是在语义上两个类的关系比组合关系更紧密。
- 组合关系：两个类的关系类似于关联关系。在代码上的体现是一样的。只是在语义上两个类的关系比关联关系更紧密。
- 依赖、关联、聚合、组合关系可以符合has-a的关系

多态的概念

多态是面向对象三大特性之一。前面学习了封装、继承
封装为了隐藏类的内部实现。可以在不影响使用的情况下改变类的内部结构。其次保护了数据。让外部不能随意访问。外部只能通过它给的访问方法进行访问
继承是为了重用父类的代码。两个类如果存在is-a的关系就可以使用继承。其次继承也是多态的继承条件。

小明家养宠物。养了一只猫，还有一只狗。以后还有可能养其他宠物。进行代码实现。

package com.iotek.entity;

/**
 * @Author: 廾匸
 * @Date: 2020/10/29 20:42
 * @Description: 人类
 * @version: 1.0
 */
public class Person {
    private String name;
    private int age;

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

    public Person() {
    }

    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 feet(Cat cat) {
        System.out.println(name+"开始喂"+cat.getName());
        cat.eat();
        cat.play();
        cat.cd();
    }
    public void feet(Dog dog) {
        System.out.println(name+"开始喂"+dog.getName());
        dog.eat();
        dog.play();
        dog.dd();
    }
}
/**
 * @Author: 廾匸
 * @Date: 2020/10/29 20:38
 * @Description: 宠物类
 * @version: 1.0
 */
public class Pet {
    private String name;
    private int age;

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

    public Pet() {
    }

    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 play() {
        System.out.println("玩");
    }
    public void eat() {
        System.out.println("吃");
    }

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
/**
 * @Author: 廾匸
 * @Date: 2020/10/29 20:40
 * @Description: 猫类
 * @version: 1.0
 */
public class Dog extends Pet {
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void play() {
        System.out.println("狗玩猫");
    }

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

    public void dd() {
        System.out.println("狗看门");
    }
}
/**
 * @Author: 廾匸
 * @Date: 2020/10/29 20:40
 * @Description: 猫类
 * @version: 1.0
 */
public class Cat extends Pet {
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void play() {
        System.out.println("猫玩皮球");
    }

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

现在你拿到的代码就是上面的代码，要求现在小明家养鳄鱼。
所以以上代码可以看出，目前是没有问题的，可以试想需求，但是后期如果需求增加或者需求改变，要加一个宠物的时候，需要添加一个新的类，要继承与我的宠物类，同时还要改变Person这个类，需要一个方法喂养新的宠物
多态就可以在设计之初解决这个问题

多态

多：多个，多种，不同
态：不是状态，形态，动作，结果
相同的行为，作用在某一类不同的对象上，可能会有不同的结果，得到不同的效果。系统在编译阶段并不能确定具体执行的方法，而是在运行阶段才确定
英雄联盟上的R这个键位来说。如果英雄是大保健，R，德玛西亚，英雄是瞎子，R一库，寒冰，R，正中眉心
- 我的R实际上并不是针对某个英雄的，而是对英雄这一类的，而不同的英雄对象，体现效果不同。
之前的代码中。Person这个类对于不同的宠物行为是相同的。对象不同，有狗，有猫，有鳄鱼，产生的结果表现形式不同，这里我们用了方法的重载。而这种用重载实现的多态我们称为静态多态。但是有问题，后期如果要加宠物，必须修改Person这个类，要加一个重载的方法，这违反开闭原则。

多态的必要条件

类之间要有继承或者实现关系。
要有方法的重写
父类型的引用持有子类型的对象（里式替换原则）
- 就是在编译时类型与运行时类型不同。对于我们想要实现的不同的表现，通过在运行时动态的确定，而不是我们在代码上通过改变代码实现。
优点：使得代码结构更清晰，提高了代码的可维护性，利于后期扩展程序。
允许不同的类的对象，对于同一消息（行为）作出响应，同一行为，根据作用对象的不同，采用多种不同的形式

对于之前的代码，用多态来实现

/**
 * @Author: 廾匸
 * @Date: 2020/10/29 20:42
 * @Description: 人类
 * @version: 1.0
 */
public class Person {
    private String name;
    private int age;

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

    public Person() {
    }

    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 feet(Pet pet) {
        System.out.println(name+"开始喂养"+pet.getName());
        pet.eat();
        pet.play();
    }
}
/**
 * @Author: 廾匸
 * @Date: 2020/10/29 20:38
 * @Description: 宠物类
 * @version: 1.0
 */
public class Pet {
    private String name;
    private int age;

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

    public Pet() {
    }

    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 play() {
        System.out.println("玩");
    }
    public void eat() {
        System.out.println("吃");
    }

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
/**
 * @Author:廾匸
 * @Date: 2020/10/29 20:52
 * @Description:
 * @version: 1.0
 */
public class E extends Pet {
    public E(String name, int age) {
        super(name, age);
    }

    @Override
    public void play() {
        System.out.println("鳄鱼玩了");
    }

    @Override
    public void eat() {
        System.out.println("鳄鱼吃东西");
    }
}
/**
 * @Author: 廾匸
 * @Date: 2020/10/29 20:40
 * @Description: 猫类
 * @version: 1.0
 */
public class Dog extends Pet {
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void play() {
        System.out.println("狗玩猫");
    }

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

    public void dd() {
        System.out.println("狗看门");
    }
}
/**
 * @Author: 廾匸
 * @Date: 2020/10/29 20:40
 * @Description: 猫类
 * @version: 1.0
 */
public class Cat extends Pet {
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void play() {
        System.out.println("猫玩皮球");
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void cd() {
        System.out.println("抓老鼠");
    }
}
/**
 * @Author: 廾匸
 * @Date: 2020/10/29 16:55
 * @Description: 测试jdbc
 * @version: 1.0
 */
public class Demo {
    public static void main(String[] args) {
        Person person = new Person("小明",15);
        Pet pet1 = new Dog("旺财",3);
        Pet pet2 = new Cat("小花",5);
        Pet pet3 = new E("小鳄",8);
        person.feet(pet1);
        person.feet(pet2);
        person.feet(pet3);
    }
}

上下转型

向上转型

父类型引用持有子类型对象。将子类转为父类型变量
向上转型会丢掉自己独有的属性或者行为。
向上转型都是安全的，符合is-a的关系。

向下转型

将父类型对象转为子类型对象
向下转型重新持有独有的行为或者属性。
不安全。有可能转不了。可以借助instanceof进行判断以后再进行转换
要发生向下转型，必须先发生向上转型

动态绑定、静态绑定

绑定：方法的调用表示式跟方法体进行绑定。
静态绑定：编译阶段就已经确定调用与具体的执行。对应的就是静态多态。主要方法的重载
动态绑定：编译阶段并不确定具体执行的方法体，而是在运行阶段才确定要执行的方法体。对应的就是动态多态

继承中子类构造中为什么要用父类的构造，作用是什么

作用：为父类中的属性进行赋值
认为父类构造在子类构造中的第一行，所以先创建了父类的对象，然后再扩大内存
实际就是子类对象在包裹父类对象，属性调用过程中，先在子类属性中找，如果找到就返回，如果没有找到
开始在父类对象中找
另一种认为没有创建父类对象。按照子类大小申请空间
在子类构造中先调用父类的构造，对父类的属性进行赋值，然后
执行子类自己的构造，对子类自己的属性赋值，
结束以后直接返回引用地址

创建对象的过程

加载父类
加载子类
申请空间
对父类属性进行默认初始化
对子类属性进行默认初始化
对父类属性静态初始化
对父类属性进行构造初始化
对子类属性进行静态初始化
对子类属性进行构造初始化
返回对象的地址

提高题目分析

public class A {
    public String show(D obj) {
        return ("A and D");
    }
    public String show(A obj) {
        return ("A and A");
    } 
}
public class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    public String show(A obj){
        return ("B and A");
    } 
}
public class C extends B{
}
public class D extends B{
}
public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));     
    }
}

某一对象调用方法时
- 先在自己类中找，如果没有找到、
- 往父类中找。父类中找到就运行
- 父类也没有找到，回到自己类中，找参数父类的方法。
- 假设在自己类中就找到了
- 看实际对象的类型，然后在子类中看这个方法有没有重写
- 如果没有重写，就用自己这个类中的方法。
- 如果重写了，就用子类中的重写以后的方法。

父子类中构造，普通代码块，静态代码块

单个类中：
- 静态代码块（一次）
- 普通代码块（构造一次，调用一次）
- 构造（调用一次，执行一次）
继承关系中：
- 父类的静态代码块（一次）
- 子类静态代码块（一次）
- 父类的普通代码块
- 父类的构造
- 子类的普通
- 子类的构造

沙皮狗你不懂

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
类的关系和多态

类的关系有一个人，叫张三，他们家养了两只宠物，张三可以喂养宠物，张三可以开关家里的包括门，电视，电脑类的关系分类继承关系：子类继承父类，符合is-a的关系，实现通过extends关键字实现关系：实现类实现接口。符合like-a的关系。通过关键字implements实现（体现在行为上）依赖关系：A类依赖于B这个类，某个类借助其他类的行为或者属性，我们就说这个类依赖于被利用的类。一般体现在代码上是以参数的形式出现的。关联关系：两个类共同完成一件事，没有任何一个都不行。两个类我们就是说是关联关系。
复制链接

扫一扫