JAVA SE之多态

于 2021-04-25 19:49:03 发布
阅读量271 收藏
点赞数
原文链接：https://blog.csdn.net/qq_44823091/article/details/89364443
版权

多态

1 多态(动态绑定机制)

1.1 多态的概述

A:多态概述
某一个事物，在不同时刻表现出来的不同状态。
举例： Cat c=new Cat();
Animal a=new Cat();
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();
B:多态前提
a:要有继承关系。
b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。
父 f = new 子();

public class MyTest {
    public static void main(String[] args) {
        Animal an=new Cat();
        an.eat();
    }
}
class Animal{
    public void eat(){
        System.out.println("吃饭");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼干");
    }
}

1.2 多态的成员访问特点

多态中的成员访问特点
a:成员变量
编译看左边，运行看左边。
b:构造方法
创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
c:成员方法
编译看左边，运行看右边。
d:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)

public class MyTest {
    public static void main(String[] args) {
        Animal an = new Cat();
        an.eat();
        System.out.println(an.a);
        an.sleep();
    }
}

class Animal {
    int a = 100;

    public static void sleep() {
        System.out.println("睡觉");
    }

    public void eat() {
        System.out.println("吃饭");
    }

    public Animal(){
        System.out.println("Animal构造方法");
    }
}

class Cat extends Animal {
    int a=200;
    public static void sleep() {
        System.out.println("睡觉觉");
    }
    public void eat() {
        System.out.println("吃鱼干");
    }
}

1.3 多态的好处和弊端

A:多态的好处
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)

B:多态的弊端

1.4 向上转型和向下转型

A:通过多态的弊端引出问题
不能使用子类特有的功能
B:解决问题
a:把父类的引用强制转换为子类的引用。(向下转型)

public class MyTest2 {
    public static void main(String[] args) {
        Animal an = new Cat();//向上转型
        an.eat();
        System.out.println(an.a);//100
        Cat cat=(Cat) an;//向下转型
        System.out.println(cat.a);//200
    }
}

1.5 多态内存图

在这里插入图片描述

2 抽象类

2.1 抽象类的概述

A:抽象类概述
回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。
为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。
所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。
同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
B:抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
C:案例演示
抽象类特点

public class MyTest3 {
    //抽象类，不能直接创建对象
    // Animal animal = new Animal();

    //abstract 抽象的，修饰类和方法的
    //1. 一旦一个类中有了抽象方法，此类必须为抽象类
    //2.抽象类中，可以没有抽象方法
    //3.抽象类中可以有抽象法和非抽象方法。
    //4.抽象类中的抽象方法，强制子类必须重写父类中所有的抽象方法。
    //5.抽象类中的非抽象方法，一般作为子类继承使用，当然子类可以重写，但是不具备强制性。
    //6.抽象类中有构造方法。
    //抽象类的子类：1.要全部重写父类中的抽象方法，2.你自己是个抽象类。
    public static void main(String[] args) {
        
    }
}
abstract class A{
    public abstract void show();
}
class B extends A{
    @Override
    public void show(){
        System.out.println("abc");
    }
}

2.2 抽象类的成员特点

A:抽象类的成员特点
a:成员变量：既可以是变量，也可以是常量。
b:构造方法：有。
用于子类访问父类数据的初始化。
c:成员方法：既可以是抽象的，也可以是非抽象的。
B:案例演示
抽象类的成员特点
C:抽象类的成员方法特性：
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情，提高代码复用性。

2.3 抽象类的案例

2.3.1 抽象类练习猫狗案例

public class MyTest {
    public static void main(String[] args) {
        Animal an = new Cat();
        an.eat();
        System.out.println(an.a);
        an.sleep();
        Animal an2=new Dog();
        an2.eat();
    }
}

abstract class Animal {
    int a = 100;

    public static void sleep() {
        System.out.println("睡觉");
    }

    public abstract void eat() ;

    public Animal(){
        System.out.println("Animal构造方法");
    }
}

class Cat extends Animal {
    int a=200;
    public static void sleep() {
        System.out.println("睡觉觉");
    }
    public void eat() {
        System.out.println("吃鱼干");
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("吃骨头");
    }
}

2.3.2 抽象类练习老师案例

具体事物：基础班老师，就业班老师
共性：姓名，年龄，讲课。

public class MyTest {
    public static void main(String[] args) {
        Teacher t1=new Jichu();
        t1.age=20;
        t1.name="mike";
        System.out.println(t1.age);
        System.out.println(t1.name);
        t1.teach();
        System.out.println("===========================");
        Teacher t2=new Jiuye();
        t2.name="Luccy";
        t2.age=25;
        System.out.println(t2.age);
        System.out.println(t2.name);
        t2.teach();
    }
}
abstract class Teacher{
    String name;
    int age;
    public abstract void teach();
}
class Jichu extends Teacher{
    @Override
    public void teach() {
        System.out.println("教基础课");
    }
}
class Jiuye extends Teacher{
    @Override
    public void teach() {
        System.out.println("教应用课");
    }
}

2.3.3 抽象类练习员工案例

假如我们在开发一个系统时需要对员工(Employee)类进行设计，员工包含3个属性：姓名、工号以及工资(salary)。
经理(Manager)也是员工，除了含有员工的属性外，另为还有一个奖金(bonus)属性。
然后定义工作的方法.
请使用继承的思想设计出员工类和经理类。

public class MyTest2 {
    public static void main(String[] args) {
        Employee A=new Manager();
        A.name="Mike";
        A.num=1;
        A.salary=19999;
        A.work();
        Manager M=(Manager) A;
        M.bonus=9999;
        System.out.println(A.name);
        System.out.println(A.salary);
        System.out.println(A.num);
        System.out.println(M.bonus);
    }
}


public abstract class Employee {
    int salary;
    String name;
    int num;
    public abstract void work();
}



public class Manager extends Employee {
    @Override
    public void work() {
        System.out.println("工作");
    }
    int bonus;
}

3 接口

3.1 接口的概述

A:接口概述
继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了。
但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。
而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。
所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。
所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可
B:接口特点
a:接口用关键字interface表示 格式: interface 接口名 {}
b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
c:接口不能实例化
那么，接口如何实例化呢?
按照多态的方式来实例化。
d:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

3.2 接口的成员特点

成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
默认修饰符：public abstract
建议：自己手动给出。

3.3 类与类,类与接口,接口与接口的关系

a:类与类：
继承关系,只能单继承,可以多层继承。
b:类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
c:接口与接口：
继承关系,可以单继承,也可以多继承。

3.4 抽象类与接口的区别

A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。 接口中定义的是该继承体系的扩展功能。

注意：JDK1.8之后在接口中提供了用default修饰的方法，可以给出功能的具体实现，子类可以继承下去用
JDK1.8之后在接口中也可以定义静态方法，直接使用接口名来调用

3.5 接口的案例

猫狗案例加入跳高功能分析及其代码实现

动物类：姓名，年龄，吃饭，睡觉。
动物培训接口：跳高
猫继承动物类
狗继承动物类
部分猫继承猫类并实现跳高接口
部分狗继承狗类并实现跳高接口

public class MyTest3 {
    public static void main(String[] args) {
        Animal dog=new Dog();
        dog.eat();
        Dog dogg=(Dog) dog;
        dogg.jump();
    }
}

public abstract class Animal {
    public abstract void eat();
}

public class Dog extends Animal implements JumpInterface{
    @Override
    public void jump() {
        System.out.println("跳高");
    }

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

}


public interface JumpInterface {
    public abstract void jump();
}
七千零一转
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值