面向对象三大特征——多态

已于 2023-04-17 21:06:31 修改
阅读量253 收藏
点赞数
分类专栏： Java 文章标签： 开发语言 java
于 2023-03-27 01:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53616401/article/details/129710350
版权

目录

基本介绍

多态的注意事项和使用细节

多态的向上转型

 多态的向下转型

多态例题

思路分析：

动态绑定机制

多态数组

多态参数

多态的是什么

什么是多态 。多就是[多种]态[状态]，我们成为多态，可能这样看起来比较抽象，但是没事我们继续往下看

基本介绍

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上。一讲到多态，肯定会有运行类型和编译类型，那么什么是编译类型什么是运行呢，有这么一句话=编译类型看左边运行类型看右边

来看看具体的案例吧

Dog dog = new Animal();

上面的是一个非常简单的代码，那么根据上的的这样一句话，编译类型看等号的左边，运行类型看等号的右边，因此上面的这一句代码的

编译类型是：Dog

运行类型是：Animal

那么这个有什么作用呢，非常的重要，接下来马上就会讲到

多态的注意事项和使用细节

多态的向上转型

1)本质：父类的引用指向了子类的对象

2)语法：父类类型 引用名 = new 子类类型);

3)特点：编译类型看左边，运行类型看右边。 可以调用父类中的所有成员(需遵守访问权限)，不能调用子类中特有成员； 最终运行效果看子类的具体实现！

向上转型调用方法的规则如下:
(1)可以调用父类中的所有成员(需遵守访问权限)
(2)但是不能调用子类的特有的成员
(#)因为在编译阶段，能调用哪些成员,是由编译类型来决定的
animal.catchMouse();错误
(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法，然后调用，规则我前面我们讲的方法调用规则一致。

 多态的向下转型

1)语法：子类类型 引用名= （子类类型)父类引用；

2)只能强转父类的引用，不能强转父类的对象

3)要求父类的引用必须指向的是当前目标类型的对象

4)当向下转型后，可以调用子类类型中所有的成员（也要遵守访问权限）

//多态的向下转型
//(1)语法：子类类型 引用名 =（子类类型）父类引用;

向上转型和向下转型的代码演示:

package idea.polymorphic.detail;

/**
 * 演示向上转型
 */
public class PolyDetail01 {
    public static void main(String[] args) {
        //向上转型: 父类的引用指向了子类的对象
        //语法：父类类型 引用名 = new 子类类型();

        /*
        这就是一个向上转型
        此时我们看，Animal animal = new Cat(); 这句话的编译类型和运行类型是什么
        还记得我们的话嘛，编译类型看=左边 运行类型看=右边
        编译类型是 Animal
        运行类型是 Cat
        语法：父类类型 引用名 = new 子类类型();
         */
        Animal animal = new Cat();
        Object obj = new Cat();//这样也是可以的，因为Cat是Animal的子类，而Animal是Object的子类，因此这样也是满足向上转型的语法

        //向上转型调用方法的规则如下:
        //(1)可以调用父类中的所有成员(需遵守访问权限)
        //可以调用父类中的属性，但是私有的属性不能够访问
        System.out.println(animal.name);
        System.out.println(animal.age);
        //System.out.println(animal.id);因为id属性是private的，因此不能直接访问会报错

        //看看方法  都可以调用父类中的方法（需要遵守访问权限，如果是私有的方法也不能访问，和调用属性的规则一样）
        animal.eat();
        animal.run();
        animal.show();
        animal.sleep();

        //(2)但是不能调用子类的特有的成员
        //(#)因为在编译阶段，能调用哪些成员,是由编译类型来决定的
        //因为这是子类特有的方法，所以不能够去访问
        //animal.catchMouse();//错误的

        //(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法，然后调用，规则我前面我们讲的方法调用规则一致。
        //我们知道，在子类中也有一个eat()方法，该方法重写了父类的eat()方法，那么在使用animal去调用eat方法的时候，到底输出的是父类的方法呢，还是子类的方法
        //结果是子类的方法，因为最终运行起来，最后看的还是运行类型，而我们此时的运行类型是cat，那么在当程序运行起来
        animal.eat();


        //多态的向下转型
        //1)语法：子类类型 引用名= （子类类型)父类引用；
        //2)只能强转父类的引用，不能强转父类的对象
        //3)要求父类的引用必须指向的是当前目标类型的对象
        //4)当向下转型后，可以调用子类类型中所有的成员

        //只能强转父类的引用，不能强转父类的对象 这句话怎么理解我们看上面的这个代码    Animal animal = new Cat();
        //animal就是父类的引用，因为Animal是父类
        //所以向下转型就是 把animal强装成一个Cat
        Cat cat = (Cat) animal;
        //此时我们再来看编译类型和运行类型
        //编译类型是 Cat
        //运行类型是 Cat

        //向下转型后就可以去访问访问子类中的所以属性，但是也要遵守访问权限
        cat.catchMouse();//这样就不会报错了



    }
}

属性没有重写之说！属性的值看编译类型 

代码演示：

package idea.polymorphic.detail;

public class PolyDetail02 {
    public static void main(String[] args) {
        //属性没有重写之说！属性的值看编译类型

        //向上转型
        Base base = new son();
        /*
        这里输出的就是10，因为属性没有重写之说
        属性的值看编译类型  此时的编译类型是 Base  运行类型是 son
        所以此时输出的count就是10
         */
        System.out.println(base.count);

        son son = new son();
        /*
        这里输出的就是20，因为属性没有重写之说
        属性的值编译类型  此时的编译类型是 Base  运行类型是 son
        所以此时输出的count就是20
         */
        System.out.println(son.count);
    }
}

class Base {//父类
    int count = 10;
}

class son extends Base {//子类
    int count = 20;
}

instanceOf比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型

代码演示：

package idea.polymorphic.detail;

public class PolyDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof  BB);// true
        System.out.println(bb instanceof  AA);// true

        //aa 编译类型 AA, 运行类型是BB
        //BB是AA子类
        AA aa = new BB();
        //看的是运行类型 此时aa的运行类型是BB 而BB是AA的子类，所以他们是同一个对象
        System.out.println(aa instanceof AA);
        //看的是运行类型 此时aa的运行类型是BB 而BB就是BB，所以他们是同一个对象
        System.out.println(aa instanceof BB);

        //obj 编译类型 Object ， 运行类型是 Object
        Object obj = new Object();
        //看的是运行类型 此时obj的运行类型是Object 而obj不是AA的子类，所以他们不是同一个对象
        System.out.println(obj instanceof AA);//false
        String str = "hello";
        //System.out.println(str instanceof AA);
        //因为String是Object的子类所以返回true
        System.out.println(str instanceof Object);//true
    }
}

class AA {

}

class BB extends AA {

}

多态例题

思路分析：

我们要知道对于属性来说没有重写的概念，因此在多态中属性看的是。编译类型，而方法看的是运行类型，因此我们只需要分清楚一个对象实例的编译类型和运行类型，那么就不容易出错，在本例题中我们可以清楚的感受到编译类型和运行类型，仔细看代码中的注释，就可以清楚的知道为什么输出这样值

package idea.polymorphic;

/**
 * 讲解多态的例题
 */
public class polyExercise01 {
    public static void main(String[] args) {
        
        Sub s = new Sub();
        //s的编译类型是 Sub  运行类型是 Sub  因为属性看的是编译类型所以s.count输出的就是20
        System.out.println(s.count);//20
        //方法看的是运行类型 所以调用的是Sub中的display方法 因为是this.count 所以访问的就是本类中的属性
        s.display();//20
        
        Base b = s;
        //因为把s赋给了 b 此时 编译类型变成了 Base  运行类型变成了Sub
        System.out.println(b == s);//T  把s赋给了b 相当于 b 和 s 都指向同一块空见，所以返回true
        //属性看的是编译类型，此时编译b的编译类型是Base 所以b.count 输出的就是10
        System.out.println(b.count);//10
        //方法看的是运行类型 因为b的运行类型是 Sub 所以b.display()调用的还是Sub中的方法，因此输出的是20
        b.display();//20
    }
}

class Base {//父类
    int count = 10;

    public void display() {
        System.out.println(this.count);
    }
}

class Sub extends Base {//子类
    int count = 20;

    public void display() {
        System.out.println(this.count);
    }
}

动态绑定机制

1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

2.当调用对象属性时 ，没有动态绑定机制，哪里声明哪里使用

        System.out.println(a.sum());//?40 -> 30
        /*
        思路分析
        1.首先我们知道方法看的是运行类型，而a的运行类型是B 所以会去B类中去找sum()方法，但是B类中没有sum()方法，因为B类继承了A类，所以
          会去A类中查找，在A类中我们确实查找到了sum()方法，
        2.在A类的sum()方法中，有这么一句话return getI()+10; ，当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定，因此
          调用这个方法的是a，但是a的编译类型是B,因此会进行动态绑定，会先去B类中查找getI()方法，如果在B类中查找不到，才回去A类查找
        3.我们在B类中找到了getI()方法，里面有一句return i; 因为在调用属性时，没有动态绑定机制，所以返回的就是B类中的i，因此返回的就是20
          如果在B类中，没有i，那么就会到A类也就是父类中去查找
        4.因此最后a.sum(); 输出的就是30
         */

        System.out.println(a.sum1());//?30-> 20
        /*
        思路分析
        1.首先我们知道方法看的是运行类型，而a的运行类型是B 所以会去B类中去找sum1()方法，但是B类中没有sum1()方法，因为B类继承了A类，所以
          会去A类中查找，在A类中我们确实查找到了sum1()方法，
        2.在A类的sum1()方法中，有这么一句话return i + 10; ，因为在调用对象属性的时候，没有动态绑定机制，哪里声明哪里使用，所以这里的i
          时父类中的i 也就是A类中的i 因此a.sum1()方法输出的就是20
        3.如果一直找不到i,最后会报错
         */

package idea.polymorphic.DynamicBindingMechanism;

/**
 * 讲解动态绑定机制
 */
public class DynamicBinding {
    public static void main(String[] args) {
        //a 的编译类型 A, 运行类型 B
        A a = new B();//向上转型
        //结论
        //1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
        //2.当调用对象属性时 ，没有动态绑定机制，哪里声明哪里使用

        System.out.println(a.sum());//?40 -> 30
        /*
        思路分析
        1.首先我们知道方法看的是运行类型，而a的运行类型是B 所以会去B类中去找sum()方法，但是B类中没有sum()方法，因为B类继承了A类，所以
          会去A类中查找，在A类中我们确实查找到了sum()方法，
        2.在A类的sum()方法中，有这么一句话return getI()+10; ，当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定，因此
          调用这个方法的是a，但是a的编译类型是B,因此会进行动态绑定，会先去B类中查找getI()方法，如果在B类中查找不到，才回去A类查找
        3.我们在B类中找到了getI()方法，里面有一句return i; 因为在调用属性时，没有动态绑定机制，所以返回的就是B类中的i，因此返回的就是20
          如果在B类中，没有i，那么就会到A类也就是父类中去查找
        4.因此最后a.sum(); 输出的就是30
         */

        System.out.println(a.sum1());//?30-> 20
        /*
        思路分析
        1.首先我们知道方法看的是运行类型，而a的运行类型是B 所以会去B类中去找sum1()方法，但是B类中没有sum1()方法，因为B类继承了A类，所以
          会去A类中查找，在A类中我们确实查找到了sum1()方法，
        2.在A类的sum1()方法中，有这么一句话return i + 10; ，因为在调用对象属性的时候，没有动态绑定机制，哪里声明哪里使用，所以这里的i
          时父类中的i 也就是A类中的i 因此a.sum1()方法输出的就是20
        3.如果一直找不到i,最后会报错         
         */
        
    }
}

class A {//父类
    public int i = 10;
    //动态绑定机制:

    public int sum() {//父类sum()
        return getI() + 10;//20 + 10
    }

    public int sum1() {//父类sum1()
        return i + 10;//10 + 10
    }

    public int getI() {//父类getI
        return i;
    }
}

class B extends A {//子类
    public int i = 20;

//    public int sum() {
//        return i + 20;
//    }

    public int getI() {//子类getI()
        return i;
    }

//    public int sum1() {
//        return i + 10;
//    }
}

多态数组

数组体现多态，在下面的代码中我们创建了一个Person数组，因为数组也可以体现多态，因为Teacher类和Student都继承了Person类，所以Student和Teacher都可以存在在Person数组中

代码演示：

package idea.polymorphic.polyarr;

/**
 * 演示数组体现多态
 */
public class PolyArray {
    public static void main(String[] args) {
        //创建了一个Person数组，因为数组也可以体现多态，因为Teacher类和Student都继承了Person类，所以Student和Teacher都可以存在在Person数组中
        Person[] p = new Person[5];
        //初始化数组的值，数组中的类型各不相同，有Person类型的，Student类型的，Teacher类型的
        p[0] = new Person("jack", 10);
        p[1] = new Student("tom", 10, 100);
        p[2] = new Student("many", 10, 90);
        p[3] = new Teacher("A", 10, 10000);
        p[4] = new Teacher("B", 10, 20000);

        //遍历这个数组
        for (int i = 0; i < p.length; i++) {
            //调用数组中每一个元素的say()方法，因为有动态绑定机制的存在，在调用方法时，看的是运行类型，因此会自动的找到，对应类中的方法去调用
            System.out.println(p[i].say());
            if (p[i] instanceof Student) {//判断数组中的每个元素的运行类型是声明，如果是Student 那么就强转p[i]然后去调用Student类的方法，相当于向下转型
                ((Student) (p[i])).study();
            } else if (p[i] instanceof Teacher) {//判断数组中的每个元素的运行类型是声明，如果是Teacher 那么就强转p[i]然后去调用Teacher对应类的方法，相当于向下转型
                ((Teacher) p[i]).teach();
            } else {
                System.out.println("不做处理");
            }
        }


    }
}

Person类 

package idea.polymorphic.polyarr;

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

    public Person(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 String say() {//返回名字和年龄
        return name + "\t" + age;
    }
}

 Student类

package idea.polymorphic.polyarr;

public class Student extends Person {
    private double score;

    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
    //重写父类say

    @Override
    public String say() {
        return "学生 " + super.say() + " score=" + score;
    }

    //特有的方法
    public void study() {
        System.out.println("学生 " + getName() + " 正在学java...");
    }
}

Teacher类 

package idea.polymorphic.polyarr;

public class Teacher extends Person {
    private double salary;

    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
    //写重写父类的say方法

    @Override
    public String say() {
        return "老师 " + super.say() + " salary=" + salary;
    }
    //特有方法
    public void teach() {
        System.out.println("老师 " + getName() + " 正在讲java课程...");
    }
}

多态参数

思路分析：

test(jack);
test(tom);

        1.test()方法可以接受一个Employee对象，因为Worker和Manage都是Employee的子类，所以可以接受参数
        2.因为在调用方法的时候，看的是运行类型，因此我们传入一个worker对象，那么就会动态绑定到Worker类中的getAnnual()方法
          如果传入的是，Manager，那么就会动态绑定到Manager中

思路分析：

testWork(jack);
testWork(tom);

        1.testWork()方法可以接受一个Employee对象，因为Worker和Manage都是Employee的子类，所以可以接受参数
        2.这次我们要调用的是子类中的特有属性，因此要对传入的参数进行判断，如果e的类型是Worker，那么就强转，相当于向下转型，并且会去调用对应的方法

package idea.polymorphic.polyparameter_;

/**
 * 演示参数体现多态
 */
public class PloyParameter {
    public static void main(String[] args) {
        //这里我们创建了一个Worker对象
        Worker jack = new Worker("jack", 1000);
        //这里我们创建了一个Manager对象
        Manager tom = new Manager("tom", 2000, 1000);

        /*
        思路分析
        1.test()方法可以接受一个Employee对象，因为Worker和Manage都是Employee的子类，所以可以接受参数
        2.因为在调用方法的时候，看的是运行类型，因此我们传入一个worker对象，那么就会动态绑定到Worker类中的getAnnual()方法
          如果传入的是，Manager，那么就会动态绑定到Manager中
         */
        test(jack);
        test(tom);

        /*
        思路分析
        1.testWork()方法可以接受一个Employee对象，因为Worker和Manage都是Employee的子类，所以可以接受参数
        2.这次我们要调用的是子类中的特有属性，因此要对传入的参数进行判断，如果e的类型是Worker，那么就强转，相当于向下转型，并且会去调用对应的方法
         */
        testWork(jack);
        testWork(tom);

    }

    //该方法可以接受一个Employee 对象
    public static void test(Employee e) {
        System.out.println(e.getAnnual());
    }

    //该方法可以接受一个Employee 对象
    public static void testWork(Employee e) {
        if (e instanceof Worker) {
            ((Worker) e).work();
        } else if (e instanceof Manager) {
            ((Manager) e).manage();
        } else {
            System.out.println("不做任何处理 ");
        }
    }
}

employee类

package idea.polymorphic.polyparameter_;

public class Employee {
    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    //得到年工资的方法
    public double getAnnual() {
        return 12 * salary;
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

Manager类

package idea.polymorphic.polyparameter_;

public class Manager extends Employee {

    private double bonus;

    public Manager(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public void manage() {
        System.out.println("经理 " + getName() + " is managing");
    }

    //重写获取年薪方法
    @Override
    public double getAnnual() {
        return super.getAnnual() + bonus;
    }
}

Worker类

package idea.polymorphic.polyparameter_;

public class Worker extends Employee {

    public Worker(String name, double salary) {
        super(name, salary);
    }

    public void work() {
        System.out.println("普通员工 " + getName() + " is working");
    }

    @Override
    public double getAnnual() { //因为普通员工没有其它收入，则直接调用父类方法
        return super.getAnnual();
    }
}

_雨_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象-----多态
qq_46652775的博客
12-18 5722
1、多态的概念 （1）多态是面向对象的一个重要特征，指同一类事物同时具有多种形态，即同一类事物，在不同时刻，代表的对象不一样，指的是对象的多种形态。比如，对于笔记本电脑，它可以是苹果笔记本、华硕笔记本、弘基笔记本、神州笔记本。 （2）多态就是同一个行为具有多个不同表现形式或形态的能力，指的就是行为的多态。比如鸟类的飞行行为,鸽子,燕子,老鹰它们各自的飞行方式是不同的，再比如动物都有吃这个功能，但是它们吃的食物是不同的,老虎吃肉,牛吃草,猫吃猫粮,狗吃狗粮。 （3）多态就是同一个接口...
面向对象的三大特征之一:多态
naoguoteng的博客
04-11 697
目录 面向对象三大特征: 封装, 继承 , 多态. 1.多态 2.多态的前提 3.多态的表现形式及如何访问成员 4.多态的好处 5.多态的弊端以及解决方案 面向对象三大特征: 封装, 继承 , 多态. 1.多态 多态指的是一种事物，在不同时刻，所表现出的不同状态。 例如生活中猫是猫类的一种也是动物类的一种. 在Java中就是可以 Cat cat=new Cat(); (猫是猫类的一种),也可以Animal an=new Cat(); (猫是动物类的一种)...
面向对象的三大特性之——多态
qq_62712350的博客
08-22 1059
多态的概念：通俗来说，就是多种形态，重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程 进行重新编写,。重写的好处在于子类可以根据需要，定义特定 于自己的行为。也就是说子类能够根据需要实现父类的方法。父类子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型方法名(参数列表)要完全一致被重写的方法返回值类型可以不同，但是必须是具有父子关系的访问权限不能比父类中被重写的方法的访问权限更低。
java面向对象三大特征之一-------------多态
qq_48785525的博客
11-03 156
package com.zhiyou100.ploy; //定义一个父类 public abstract class Animal { // public abstract void eat(); } //子类 猫 class Cat extends Animal { //子类重写父类中的eat方法 @Override public void eat() { System.out.println("????吃????"); } //
面向对象 — 多态
m0_61410724的博客
06-12 1898
多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的。多态的前提是：1.继承。2.重写。多态的具体体现为：1.方法的多态（重写和重载就体现多态）。2.对象的多态。（1）本质：父类的引用指向了子类的对象。（2）语法：父类类型 引用名 = new 子类类型();（3）特点：编译类型看左边，运行类型看右边，可以调用父类类型中的所有成员（需要遵守
面向对象——多态详解
shouyeren_st的博客
08-14 1225
多态（Polymorphism）属于面向对象的三大特征之一，它的前提是封装形成独立体，独立体之间存在继承关系，从而形成多态机制。多态是同一个行为具有多个不同表现形式的能力。多态就是“同一个行为”发生在“不同对象上”会产生不同的效果。多种形态，多种状态，编译和运行有两个不同的状态编译期叫做静态绑定运行期叫做动态绑定现在我们再来回顾面向对象的三大特征：封装、基础、多态他们之间的关系是一环扣一环首先得封装成一个整体才有了继承的概念有了继承关系才有了多态的实现 ......
面向对象三大特性之一 多态
热门推荐
Steve_Abelieve
03-11 1万+
首先，我们看一下百科的解释：多态(Polymorphism)按字面的意思就是"多种状态"。在面向对象语言中，接口的多种不同的实现方式即为多态。通俗的讲，就是同一个东西表现出多种状态，在面向对象的描述中就是同一个函数接口，实现多种不同的表现方式。【静态多态】：编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型转换)，可推断出要调用那个函数，如果有对应的函数就调用该函数，否则出现编译错
Java基础38 面向对象三大特征之多态
chenjiap的博客
11-19 425
多态的概念及其多态数组等应用
面向对象理解——多态
LYQ
05-27 9791
何为多态
面向对象技术与方法（java）复习整理
liangyouniao的博客
06-12 304
BIT面向对象复习整理 自用分享
java创建线程的两种方式
baiqi123456的博客
07-16 1068
众所周知java是单继承的，当该类继承了其它父类时就没办法再通过继承Thread类的方法去创建线程了，只能通过实现Runnable的方式创建线程。（1）编写Animal类实现Runnable接口，并重写run方法（将我们的业务功能写在run方法中）（1）编写Animal类继承Thread类，并重写run方法（将我们的业务功能写在run方法中）演示编写一个动物类，构造器传参为动物的名字，run方法中输出该动物的名字100遍。（2）在主方法中创建动物对象，并启动该线程（调用start方法）...
面向对象—多态
qq_44346427的博客
10-17 3618
多态
面向对象的三大特点—多态
lwz18642660013的博客
10-27 603
什么是多态 从字面意思来理解，就是“多种状态”，换句话说，在java中同一个方法，根据传入的对象不同，产生了不同的行为方式或是结果，就叫多态。在之前我们学过了继承，我们知道子类可以调用父类的方法和成员变量（非私有化），那如果想通过父类调用子类的方法呢？做一个大胆的假设，我们是否可以将子类伪装成父类呢？（毕竟生活中父子一般都比较像，还是有一定的伪装可能的）那我们尝试一下以父类的方法创建方式创建一个...
面向对象的三大特征之一多态
qq_28629389的博客
03-28 1603
1. 什么是多态 多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。 对面向对象来说，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。 简单的说就是 在通过父类来获取他名下继承
面向对象的多态性
Tiffanya的博客
12-25 6026
学习目标： 1. Object类的toString()与equals(Object  obj)方法 2. 面向对象的多态性 3. 抽象类与接口   A.Object类      ·Object类是所有Java类的根基类(“祖先类”)      ·如果在类的声明中未使用extends关键字指明其基类，则        默认基类为Object类             a.to
【重学面向对象】篇一：到底什么是多态？
释然小师弟
02-04 1224
前言 接触Java这么久，我们一定都知道，作为面向对象阵营的典型代表，封装、继承、多态 (其实还应该包含抽象)是其三大基本特征 但是到底什么是多态，它的底层又是如何实现的，又有什么优缺点，可能就没那么容易说清楚 今天我们从它的近亲 C++ 语言来重新审视下，到底什么是多态 下面，正文开始！ 什么是多态 多态（Polymorphism）是面向对象的三大基本特征之一，多态是在 面向对象 的语境下，将数据模型封装为类对象，而对象之间又含有继承关系，一个基类（base class）可以有不同的派生类（derive.
简单介绍Java多态
qq_45097560的博客
06-13 325
在面向对象语言上多态是 多态(Polymorphism)按字面的意思就是"多种状态"。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述--多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(摘自"Delphi4编程技术内幕")。简单的说，就是一句话:允许将子类类...
开发语言的基本构成。
luj_1768的博客
07-24 758
许多人都对设计一套自有知识产权的开发语言感兴趣。那么，如何按照功能模块设计开发语言？
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 259
1.导入hutool的maven依赖。2.复制一下代码执行。
Java面向对象：封装、继承与多态解析
Java的三大特性——继承、封装和多态，是OOP的基础，它们使得程序设计更加灵活且易于维护。 **面向对象基础** 1. **类（Class）**：类是对象的蓝图或模板，它定义了一组相关的属性（变量）和行为（方法）。在Java中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值