向上转型 向下转型 重写 多态 ---java

目录

一. 向上转型

1.1 概念

1.2 语法格式 

1.3 动态绑定引入 

1.4 重写的引入 

 1.5向上转型的使用方式

 方式一: 直接赋值

方式二: 通过传参,进行向上转型(多态引入)

方法三:通过返回值, 进行向上转型 

二. 重写

2.1 概念

2.2 重写的格式

2.3 重写的规则

【重写和重载的区别】

 【重写的设计原则】

三. 多态

3.1概念

3.2多态实现条件

3.3 多态的优缺点

 四. 向下转型

4.1 概念

4.2 语法格式

4.3 使用方法

---

一. 向上转型

1.1 概念

实际就是创建一个子类对象，将其当成父类对象来使用。 父类引用接收子类对象. 

1.2 语法格式 

父类类型 对象名 = new 子类类型 () ;

例:

 Animal animal = new Dog("旺财",10);

//animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

1.3 动态绑定引入 

 看下述代码:

看到: animal不能访问barks(), 因为在Animal类中没有.

结论:父类引用只能调用父类自己的方法,不能调用子类的.

接下来, dog类中也定义一个eat()方法:

看到:调用了Dog类中的eat()方法

结论:当父类和子类都有eat()方法时,此时通过animal调用eat()方法,调用的是子类中的方法. 

此时发生的动作叫做动态绑定.

动态绑定:编译的时候, 调用父类的eat方法  运行的时候, 绑定到了子类的eat方法中

静态绑定:编译的时候 已经确定调用哪个方法

1.4 重写的引入 

 拿出父类和子类中的eat()进行对比:

发现:

1. 方法名相同

2. 参数列表相同(顺序, 个数, 类型)

3. 返回值相同

 此时发生了重写.(后面讲)二. 重写

 1.5向上转型的使用方式

对上述代码再添加一个Bird类

 方式一: 直接赋值

方式二: 通过传参,进行向上转型(多态引入)

当我们在方法中加入animal.eat(); 如下:

 

看到:

同一个引用 调用了同一个方法

但因为发生了向上转型 引用的对象不一样 所表现的行为不一样

--->我们把这种思想叫做多态.(后面讲)三. 多态

方法三:通过返回值, 进行向上转型 

二. 重写

2.1 概念

2.2 重写的格式

1. 方法名相同

2. 参数列表相同(顺序, 个数, 类型)

3. 返回值相同

2.3 重写的规则

1. 当父类中的方法被 final 修饰时, 此方法不能被重写. 这个方法叫做密封方法.

2. 可以在子类方法前加入 @Override 注解来显式指定, 表示此方法是重写方法, 有了这个注解能帮我们进行一些合法性校验.

3. 当父类的方法被 static 修饰时,  此方法不能被重写. 

4.  子类重写方法的访问权限不能比父类中被重写的方法的访问权限更低。

访问修饰限定符:子类 >= 父类

例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected.

5. 当父类中的方法被 private 修饰时, 此方法不能被重写.(private只能在同一类中使用)

6. 父类与子类返回值类型可以不同，但是必须是具有父子关系的  

父类:

子类:

 

 父类与子类返回值类型可以不同，但构成了父子关系, 也是可以的.

*7. 在构造方法中, 避免调用重写的方法. 

例如下述代码:

结果: 

 

看到:

当在父类的构造方法当中,调用父类和子类同名的方法的时候, 此时也会发生动态绑定, 运行时,绑定到了子类的方法中. 

也意味着, 构造方法内, 也会发生动态绑定.

 但为什么num值为0呢?

在之前的学习中, 我们了解到实例化一个对象之后, 简单来说会发生两件事情:

1. 分配内存空间

2. 调用合适的构造方法

所以在new D()之后,为d这个对象分配了一块空间, 也就是为num也分配了空间, 在调用构造方法时, 我们学过顺序:

1. 父类的实例

2. 父类的构造

3. 子类的实例

4. 子类的构造

所以我们首先调用了父类的构造方法, 在方法中调用了子类的func(), 打印了num, 此时num默认值为0, 只有当执行到子类的实例这一步时, num才被初始化为1.

执行顺序如下图:

【重写和重载的区别】

 

 【重写的设计原则】

三. 多态

3.1概念

通俗来说，就是多种形态， 具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状 态。

3.2多态实现条件

1. 必须在继承体系下

2. 子类必须要对父类中方法进行重写

3. 通过父类的引用调用重写的方法

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。

例:

class Animal{
    String name;
    int age;
 
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(this.name +"正在吃...");
    }
}
 
class Dog extends Animal{
 
    public Dog(String name, int age) {
        super(name, age);
    }
 
    public void eat(){
        System.out.println(this.name +"正在吃狗粮...");
    }
 
    void bark(){
        System.out.println(name + "汪汪汪~~~");
    }
}
 
class Bird extends Animal{
    public Bird(String name, int age) {
        super(name, age);
    }
 
    public void fly(){
        System.out.println(this.name+"正在飞...");
    }
    public void eat(){
        System.out.println(this.name+"正在吃鸟粮...");
    }
}
//分割线
public class test {
            // 注意：此处的形参类型必须是父类类型才可以
    public static void fun(Animal animal){
      animal.eat();
        // 编译器在编译代码时，并不知道要调用Dog 还是 Bird 中eat的方法
        // 等程序运行起来后，形参animal引用的具体对象确定后，才知道调用那个方法
    }
    public static void main(String[] args) {
        Dog dog = new Dog("旺财",10);
        fun(dog);
        Bird bird = new Bird("布谷",1);
        fun(bird);
    }
}

 

3.3 多态的优缺点

例下述代码: 

class Shape {

        //属性 ....

        public void draw () {

                System . out . println ( " 画图形！ " );

        }

}

class Rect extends Shape {

        @Override

        public void draw () {

                System . out . println ( " ♦ " );

        }

}

class Cycle extends Shape {

        @Override

        public void draw () {

                System . out . println ( " ● " );

        }

}

class Flower extends Shape {

        @Override

        public void draw () {

                System . out . println ( " ❀ " );

        }

}

我们现在需要打印多个形状. 如果不基于多态, 实现代码如下:  

public static void drawShapes () {

        Rect rect = new Rect ();

        Cycle cycle = new Cycle ();

        Flower flower = new Flower ();

        String [] shapes = { "cycle" , "rect" , "cycle" , "rect" , "flower" };

        for ( String shape : shapes ) {

                if ( shape . equals ( "cycle" )) {

                        cycle . draw ();

                } else if ( shape . equals ( "rect" )) {

                        rect . draw ();

                } else if ( shape . equals ( "flower" )) {

                        flower . draw ();

                }

        }

}

如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单.

public static void drawShapes () {

// 我们创建了一个 Shape 对象的数组 .

        Shape [] shapes = { new Cycle (), new Rect (), new Cycle (), new Rect (), new Flower ()};

//向上转型

        for ( Shape shape : shapes ) {

                shape . draw ();

        }

}

 四. 向下转型

4.1 概念

4.2 语法格式

父类类型 对象名 = new 子类类型() ;//向上转型

子类类型 对象名 = (子类类型) 父类对象名 ;//向下转型

4.3 使用方法

1.

结果: 

2. 

 

结果: 

程序可以通过编程，但运行时抛出异常---因为：animal2实际指向的是鸟, 不能强转成狗

所以:

Java 中为了提高向下转型的安全性，引入了 instanceof ，判断这个对象是否属于这个类型, 如果该表达式为 true ，则可以安全转换。

结果: 

 强转失败

今天的分享就到这里, 谢谢大家的点赞支持!