精华内容
下载资源
问答
  • JAVA中的多态是类的固有属性,多态是由类的继承,重写,向上转型而产生的一种特质。举个例子我们创建一个叫程序员的class,这个class可以被很多class所继承,比如说前段程序员,后端程序员,数据库程序员等等。假如一...

    JAVA中的多态是类的固有属性,多态是由类的继承,重写,向上转型而产生的一种特质。举个例子我们创建一个叫程序员的class,这个class可以被很多class所继承,比如说前段程序员,后端程序员,数据库程序员等等。假如一个程序员拥有debug这项技能,那么毫无疑问前端程序员,后端程序员和数据库程序员也理应具备这项技能。假设我们现在有一个class叫项目经理,其中有一个function是这个项目经理调用程序员进行debug,虽然这个项目经理手下并没有程序员,但是他有前端程序员,那么直接调用前段程序员也能完成debug这项任务。在java中这样的调用被称为向上转型,在一个function对一个类的调用,我们直接对这个function输入这个类的子类,java会自动完成子类向父类的向上转型。其实这种特性我认为是java中抽象设计的一种产物,举个例子,为什么写项目经理调用程序员进行debug这个function,我们不把parameter程序员改成前端程序员?假设我们这样设计,那么当项目经理需要进行数据库debug的时候我们就必须重新再写一个调用数据库程序员debug的function。因为数据库程序员和前段程序员是并行的关系,他们debug的领域也是平行无交叉的,所以他们debug function的重写也应该是完全不同的。那么向上转型这一特性就大大提升了代码的可复用性,调用程序员进行debug这个function可以用来调用各种程序员。

     

     

    下图是多态的例子:

    我们可以看到当mic和mf被调用时,他们的输出是不一样的,这是因为debug方法在mf和mic中被重写了。

    需要注意的是在进行向上转型后,其中子类独有的function无法被父类调用。举个例子,前段程序员有一个function是进行前端程序设计,然而后端程序员和数据库程序员显然是没有这个功能的。父类描述的所有程序员所共有的属性和function,所以前端程序设计这个function并不是所有程序员所共有的功能所以理应无法被其父类调用。

    注意看se在调用frontEndDesign这个function时报错。

    至于向下转型,我想了很久觉得理解其实用性并不高,因为这和实例一个子类的过程感觉并没有太大区别。如果硬要进行向下转型会让人觉得有点多此一举并且降低代码可读性。

    展开全文
  • 需求:主人养了一只狗一只猫,需要给它们进行喂食,(使用父类作为方法形参,子类作为实参传递使用) 首先建立动物类(父类) public class Animal { String name; int weigth; public void eat() { System.out....

    多态

    何为多态?同一种事物,由于条件不同,产生的结果也不同。
    多态:同一个引用类型,使用不同的实例而执行不同操作
    多态实现的前提:1,必须要有继承关系. 2,必须有方法重写. 3,必须是从父类对象指向子类对象.
    优点:1,拥有良好的扩展性 2,方便维护 3,使代码的灵活性更高。
    何时使用:在不确定是哪个类的实例会被去使用时,使用多态。

    多态案例详解

    需求:主人养了一只狗和一只猫,需要给它们进行喂食,(使用父类作为方法形参,子类作为实参传递使用
    首先建立动物类(父类)

    public class Animal {
    String name;
    int weigth;
    public void eat() {
    	System.out.println("父类~吃肉");
    }
    public void run() {
    	System.out.println("父类~跑步");
    }
    }
    

    建立狗类(子类)

    public class Dog extends Animal {
    	public void eat() {//写入狗类的方法
    		System.out.println("狗在咬骨头");
    	}
    	public void run() {//写入狗类的特有方法
    		System.out.println("狗在跑");
    	}
    }
    

    建立猫类

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

    然后,我们建立主人类

    public class Master {//主人类里放入主人需要做的事情
    	public void feed(Animal animal) {//用带参的方法指定父类类型 声明了一个animal变量
    		System.out.println("主人喂养");
    		animal.eat();
    		System.out.println("主人在溜");
    		animal.run();//猫类本身是没有run方法的,为了测试。
    	}
    }
    

    最后,进行测试,重点是这里我们要把对象实例化出来。

    public class Test {
    	public static void main(String[] args) {
    		//主人类对象
    		Master master = new Master();
    		//实例化宠物对象
    		Dog dog= new Dog();
    		Cat cat = new Cat();
    		master.feed(cat);//传入的参数进行的操作即为 cat.eat(); 把实参cat赋值与变量animal
    		master.feed(dog);
    	}
    }
    

    运行之后的结果为:我们先调用了主人类,然后使用主人类里的方法进行了子类方法的调用,如果子类没有这个方法,而父类有,那么会调用父类。(与继承一样,重写的方法优先级最高)
    在这里插入图片描述

    向上转型 <父类型> <引用变量名> = new <子类型>();(多态核心概念
    以上方的类为例
    Animal a = new Dog();
    此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法,不是父类的方法。
    注意:此时通过父类引用变量无法调用子类特有的方法,只能调用父类的属性方法
    向下转型 <子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
    Animal a = new Dog();
    Dog dog = (Dog)a把引用父类的实例a强制转换为子类类型
    将一个指向 子类对象的父类引用 赋给一个子类的引用, 即:父类类型转换为 子类类型。需强制类 型转换
    注意:在向下转型的过程中,如果没有转换为真实子类类型,会出现类型转换 异常

    关注我,点赞它,你就可以收到我持续更新的Java知识,快快来到阿斗学Java,教你最简单的java学习方法

    展开全文
  • 向下转型:Cat cat = (Cat) a,必须要先经过向上转型的变量–再向下转型,此时cat就拥有子类自己定义的特有方法cat.sleep() instanceof用法:a instanceof Cat 这里a必须是经过向上转型后的父类对

    向上向下转型

    在这里插入图片描述

    定义一个父类Animals包含eat()方法、age初始值为0

    然后再定义两个子类:DogCat,都重写了eat()方法和age,然后再分别有自己的特有方法狗咆叫bark(),猫睡觉sleep()

    向上转型:Animals a = new Cat()

    向下转型:Cat cat = (Cat) a,必须要先经过向上转型的变量–再向下转型,此时cat就拥有子类自己定义的特有方法cat.sleep()

    instanceof用法:a instanceof Cat 这里a必须是经过向上转型后的父类对象,而Cat是继承父类的子类

    // 父类
    public class Animals {
        public int age = 0;
    
        public void eat(){
            System.out.println("Eat...");
        }
    }
    
    // 子类 继承 父类 Animals
    public class Dog extends Animals {
        public int age = 10;
    
        @Override
        public void eat(){
            System.out.println("eat bone...");
        }
    
        public void bark(){
            System.out.println("dog bark...");
        }
    }
    
    public class Cat extends Animals{
        public int age = 2;
        @Override
        public void eat(){
            System.out.println("eat fish...");
        }
    
        public void sleep(){
            System.out.println("cat sleep...");
        }
    }
    
    

    有一个宠物店AnimalsShop将宠物放入后,统计个数,以及可以取出该宠物

    public class AnimalsShop {
        // 注意这里用的Animals泛型,加入宠物时,不关心宠物的具体类型
        private List<Animals> list = new ArrayList<Animals>();
        // 当加入一个宠物时,相当于进行了向上转型
        public void add(Animals a){
            list.add(a);
        }
    
        public int getSize(){
            return list.size();
        }
        // 取出的宠物也是经过向上转型的,此时类型为Animals
        public Animals getAnimal(int position){
            return list.get(position);
        }
    }
    
    public static final int DOG = 0;
    public static final int CAT = 1;
        @Test
        public void test4(){
            // 通过泛型进行向上转型将不同类型的动物加入集合,此时不需要动物的不同特性,只需要知道个数即可
            AnimalsShop as = new AnimalsShop();
            as.add(new Dog());
            as.add(new Cat());
    
            // 获取动物个数
            System.out.println(as.getSize());
    
            // 查看所有的宠物
            Dog dog = (Dog) as.getAnimal(DOG); // 直接向下转型,并不安全,因为可以编译通过但运行出错
            dog.eat();
            dog.bark();
    
            Animals a = as.getAnimal(CAT);  // 获取已经向上转型Cat
            System.out.println(a instanceof Dog); // false,向上转型的Cat和Dog不构成子类关系
            // ((已经经过向上转型的)父类对象 instanceof 子类 ) 来判断是否可以向下转型更安全,防止ClassCastException转换异常
            if(a instanceof Cat){
                Cat cat = (Cat) as.getAnimal(CAT);
                cat.eat();
                cat.sleep();
            }
    
        }
    

    向下转型的最大好处是:java的泛型编程,用处很大,Java的集合类都是这样的。
    参考博客

    Java向下转型的意义

    Java对象类型向上转型

    多态的特点

    多态的前提:

    • 存在继承或实现接口extendimplement
    • 重写方法@Override
    • 父类引用指向子类对象Animals a = new Cat()

    多态的特点:

    • 相同变量看父类a.age = 0
    • 重写方法看子类eat()看子类
    • 子类特有方法不可用a.sleep()不可用
        public static void animalEat(Animals a){
            a.eat();
        }
    
        @Test
        public void test3(){
            Animals a1 = new Dog();
            System.out.println(a1.age); // 1. 变量看父类
            a1.eat(); // 2. 方法看子类
    //        a1.bark();  3. 子类特有不可用
    
            Animals a2 = new Cat();
            a2.eat();
    
            // 当向上转型后,通过一个通用方法调用不同的子类,即可实现子类的方法
            animalEat(new Dog());
            animalEat(new Cat());
        }
    
    展开全文
  • 向上转型:符合“is a”,是安全的,子类向上到父类,多余的属性方法会丢弃向下转型:不安全的,用instanceof提前判断一下,以免抛出异常instanceof用法:result = object instanceof classresult:布尔类型object...

    向上转型:符合“is a”,是安全的,子类向上到父类,多余的属性和方法会丢弃

    向下转型:不安全的,用instanceof提前判断一下,以免抛出异常

    instanceof用法:

    result = object instanceof class

    result:布尔类型

    object:必选项,任意对象表达式

    class:必选项,任意已定义的对象类

    说明: 如果object是class或者其子类的一个实例,则instanceof运算符返回true,如果不是或者object是null,则返回false

    public class AnimalDemo {

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    Animal animal1 = new Dog("旺财");//向上转型

    Animal animal2 = new Cat("招财猫");

    animal1.eat();

    //animal1.sleep();因为向上转型,所以子类的sleep()丢弃了

    //父类的引用变量只能调用父类中有的方法,或者是子类重写父类的方法

    animal2.eat();

    //向下转型不安全,需要提前用instanceof判断一下,防止异常抛出

    if(animal2 instanceof Cat){

    System.out.println("111");

    Cat cat = (Cat)animal2;

    cat.sleep();

    }

    }

    }

    class Animal{

    private String name;

    public Animal(String name) {

    this.name = name;

    }

    public void eat() {//子类要重写

    System.out.println(name);

    }

    }

    class Dog extends Animal{

    public Dog(String name) {

    super(name);

    }

    public void eat() {

    System.out.println("吃狗粮");

    }

    public void sleep() {

    System.out.println("sleep");

    }

    }

    class Cat extends Animal{

    public Cat(String name) {

    super(name);

    }

    public void eat() {

    System.out.println("吃猫粮");

    }

    public void sleep() {

    System.out.println("sleep");

    }

    }

    展开全文
  • java对象转型和多态

    2021-03-06 01:25:10
    一个子类的对象可以当作基类的对象来使用称作向上转型,反之称作向下转型;instanceof 用来判断该引用型变量所“指向”的对象是否属于该类或者该类的子类。对象转型对象转型的便利之处:对象转型中父类引用可以指向...
  • Java多态 多态(Polymorphism)属于面向对象三大特征之一,它的前提是封装形成...● 如果当前在 Windows 下弹出的就是 Windows 帮助支持。 多态就是“同一个行为”发生在“不同的对象上”会产生不同的效果。 那么在ja
  • 11.1.重写重载的比较 名称 发生范围 方法名 形参列表 返回类型 ...子类重写的方法,返回类型父类...是面向对象的第三大特征,多态是建立在封装继承基础之上的。 多态的前提是 两个对象(类)存在继承关系 11.3.
  • 在讨论向上转型和向下转型之前,先复习下多态。如果有错误的地方,希望能够指出,大家共同进步!什么是多态多态(Polymorphism)即同一操作作用于不同的对象,可以有不同的解释,产生不同的结果。多态的分类多态一般...
  • Java的向上转型与向下转型 Java中父类强制转换成子类的原则
  • 应用在方法的形参中 package poly; ... /*多态的基本形式*/ Person person = new Chinese(); person.eat(); /* * 编译看左:是否编译报错要看等号左边的类中有没有调用的方法 * 运行看右:运
  • 向上转型 派生类对象转型为基类对象(包括指针对象),直接转化由编译器自动完成,不用cast,并且是绝对安全的。 内存里面:基类对象相当于只是换了个地址。换成了派生类对象中存储基类成员的内存地址。但是派生类...
  • Perm gen 空间 **发生频率:**3颗星 造成原因 Perm gen 空间包含: 类的名字、字段、方法 与类相关的对象数组类型数组 JIT 编译器优化 当 Perm gen 空间用尽时,将抛出异常。 解决方案 使用 -XX: MaxPermSize ...
  • //向上转型,f1引用指向Son对象 Son s1 = (Son)f1; // 向下转型,f1引用指向Son对象 Father f2 = new Father(); Son s2 = (Son) f2; // Error,子类引用不能指向父类对象 解释一下这个:Son s1 = (Son)f1; 首先f1...
  • 向上转型、向下转型(多态)一. 一个类只有一个直接父类,但是会有很多的间接父类二. 向上转型的定义三. 向上转型的特点四. 向下转型定义五. 向下转型的特点六. 避免向下转型报错的办法七. 多态性 一. 一个类只有一...
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼[size=12px][size=18px] 这两天一直在看别人争论关于多态向上转型和向下转型,然后就根据自己的理解谢了这篇帖子,请高手指正一下,不胜感激//父类Pet1. class Pet{2. ...
  • java多态向上转型

    2021-06-12 08:46:01
    在本篇内容里小编给大家整理的是一篇关于java多态向上转型的概念及实例分析,对此有兴趣的朋友们可以跟着学习下。 1、说明 向上转型就是把一个子类引用给一个父类引用,也就是父类引用 引用了子类的对象,即...
  • 在我的理解:java的向上和向下转型可以看成是类型的转换。public class Person {public void eat(){System.out.println("Person eatting...");}public void sleep() {System.out.println("Person sleep...");}}...
  • 示例代码:show()方法是动态多态的体现,参数为父类对象,instanof运算符判断某对象是否是类的实例,然后转换为下转型对象调用子类新增的方法。public class TestAnimalDemo {public static void main(String[] args...
  • 前言:在看完狂神说Java的关于重写 多态 向上转型和向下转型的视频之后,我感到了极大的困惑难以理解,于是我去看了很多不同的视频,最终总结出一套究极容易理解运用的模式 用心看完,你也应该会有很大的收获 PS...
  • 这篇文章主要介绍了简单了解Java多态向上转型相关原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下多态性是面向对象的第三大特征。多态的优点改善代码的组织...
  • 注:向上转型 只能调用父类拥有的 想下转型则可以调用 子类特有的 第一种:向上转型 public class Main { public static void main(String[] args) { MaoMao m = new MaoMao(); Fun(m); // 向上转型 不能调用子类...
  • Java 向上转型的内存分析
  • 多态的定义与使用格式多态的定义格式:就是父类的引用变量指向子类对象父类类型 变量名 = new 子类类型();变量名.方法名();普通类多态定义的格式父类 变量名 = new 子类();如: class Fu {}class Zi extends Fu {}//...
  • 多态和转型

    2021-05-20 10:26:08
    多态 同一个对象,在不同时刻表现出来的不同形态 前提 要有继承或实现关系 要有方法的重写 要有父类引用指向子类对象 格式 父类类型 变量名 = new 子类对象;//父类类型:指子类对象继承的父类类型,或者实现的...
  • 父类引用指向子类对象中,若要调用子类独有的方法需要使用向下转型来强制类型转换为子类引用。 举例: //父接口 USB接口 public interface USB{ void service(); } //子实现类优盘类 实现usb接口 public class ...
  • 定义多态: 是指对同一方法的调用,由于编译时类型运行时类型不一致可能会有不同的行为前提条件继承或者实现【二选一】方法的重写【意义体现:不重写,无意义】父类引用指向子类对象【格式体现】2. 多...
  • 对象的向上转型,其实就是多态写法; 格式:父类名称 对象名= new 子类名称(); 含义:右侧创建一个子类对象,把它当做父类来看待使用。 注意事项:向上转型一定是安全的。从小范围转向了大范围,从小范围的猫,向上...
  • public class sd{ public static void main... //父类引用指向子类对象,超人提升为i,向上转型 System.out.println(p.name); p.tanshengyi(); Superman m=(Superman)p;//向下转型 m.fly(); } } class Pe.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,952
精华内容 11,180
关键字:

向上转型和多态的区别