精华内容
下载资源
问答
  • JAVA多态的作用、概念及用法理解,持续更新ing
    2021-08-07 19:41:27

    JAVA多态

    战神三考:Why、What、How
    1、为何用多态?
    2、多态是什么?
    3、多态怎么用?

    1、为什么要用多态

    	1)提高了代码的维护性 (通过继承和实现来保证)
    	2)提高了代码的扩展性 (通过多态来保证)
    	3)降低代码耦合度 
    

    2、多态基本概念

    	1.多态是继封装、继承之后,面向对象的第三大特性。
    
    	2.多态的理解:
    	现实事物经常会体现出多种形态,比如老虎,是一种猫科动物,蛇是一种冷血动物,
    	但老虎和蛇都是属于动物,也分别属于自己动物类别,当然猫科动物属类中还有很
    	多种,即动物在这里表现出了多种形态。                                                                                                            
    
    	Java作为面向对象的语言,同样可以描述一个事物的多种形态。
    	如Snake类继承了Animal类,一个Snake的对象便既是Snake,又是Animal。
    
    	3.多态体现为父类引用变量可以指向具体的子类对象。
    
    	4.前提条件:必须有父子继承关系或者实现关系。
    
    	注意:在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。
    
    	5.多态的定义与使用格式
    
    	定义格式:父类类型 变量名 = new 子类类型();
    
    	6.理解:
    
    	多态是同一个行为具有多个不同表现形式或形态的能力。
    
    	多态就是同一个接口,使用不同的实例而执行不同操作。
    

    3、多态怎么用

    3.1、多态中的成员特点

    // 上代码
    public class Animal {
        public String name = "animal";
    
    	@Override
        public void eat(){
            System.out.println("动物吃东西!");
        }
    }
    
    public class Tiger extends Animal {
        public String name = "tiger";
    
        @Override
        public void eat() {
            System.out.println("虎吃鸡!");
        }
        
        public void run() {
    		System.out.println("虎奔跑!");
    	}
    }
    
    public class Snake extends Animal {
        public String name = "snake";
        
        @Override
        public void eat() {
            System.out.println("蛇吞象!");
        }
    
    	public void run() {
    		System.out.println("蛇爬行!");
    	}
    }
    
    	1.多态成员变量:编译检查的时候检查Animal类中是否有此变量定义
    		Animal tiger = new Tiger(); 
    
    		System.out.println("name = " + tiger.name); // name 是Animal中的值,编译期只能取到父中的值
    	实际上述打印输出结果为: name = tiger
    
    	2.使用多态调用成员方法:编译时检查左边类型,运行时实际调用右边对象
    
        	Animal snake = new Snake();
    
        	System.out.println(sanke.eat()); // snake 的门面类型是 Animal,
        	
        但实际类型是Snake, 所以运行时调用的是Snake中重写后的方法。打印输出结果为: 蛇吞象!
    

    3.2、多态的转型和instanceof关键字

    	多态的转型分为向上转型和向下转型两种
    	向上转型:多态本身就是向上转型过的过程
        使用格式:父类类型 变量名=new 子类类型();
    
        适用场景:当不需要面对子类类型时,通过提高扩展性,或者使用父类的功能就能完成相应的操作。
    	
    	Amimal tiger = new Tiger();
    	
    	tiger.run(); // 这样写会报错,因为编译检查tiger是Animal类型,Animal中没有run方法。
    	
    	((Snake)tiger).run(); // 此时编译检查能通过,但是运行时会报错,因为tiger实际类型是Tiger类型,
    	此时强制类型转换成Snake,编译时检测tiger是Animal类型,Snake也是Animal的子类,所以
    	编译时无法发现老虎不能转化为蛇类型。
    
    	if (tiger instanceof Tiger) {
    		((Tiger) tiger).run() // 此时经过instanceof判断后才能进行强制类型转换,编译和运行时均能通过。
    	}
    
    	作用:用来判断某个对象是否属于某种数据类型。
    

    3.3、多态案例

    // 上代码
    public class Keeper {
        public void feed(Animal animal){
            animal.eat();
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Keeper GodXiu = new Keeper();
    
            Animal snake = new Snake();
    
            Animal tiger = new Tiger();
            GodXiu.feed(snake);
            GodXiu.feed(tiger);
        }
    }
    

    上述案例中输出打印结果:
    蛇吞象!
    虎吃鸡!

    4、个人思考总结

    	目前在日常开发中经常使用多态的地方就是使用集合的时候:
    
    		List list = new ArrayList();
            Map map = new HashMap();
    
    	今天的个人理解和分享就到这了,后续有新的感悟会继续补充更新!
    
    更多相关内容
  • 多态JAVA的三大特性之一,多态在JAVA中也有广泛的应用,本文简单介绍了JAVA中几种多态的应用场景供大家学习。 一、常用类 1.1集合中的add()方法可以添加任意类型的数据,原因是Object是所有数据类型的父类。 1.2当...


    前言

    多态是JAVA的三大特性之一,多态在JAVA中也有广泛的应用,本文简单介绍了JAVA中几种多态的应用场景供大家学习。


    一、常用类

    1.1集合中的add()方法可以添加任意类型的数据,原因是Object是所有数据类型的父类。
    在这里插入图片描述
    1.2当用增强for循环遍历集合时,使用Object类遍历所有元素
    在这里插入图片描述
    1.3String类中的valueOf(Object obj)方法
    在这里插入图片描述

      public static String valueOf(Object obj) {
            return (obj == null) ? "null" : obj.toString();
        }
    

    二、HttpServletRequest

    RequestFacade实现了HttpServletRequest接口,tomcat自动把RequestFacade封装到HttpServletRequest中,多态(父类引用指向子类对象)

    在这里插入图片描述
    输出HttpServletRequest发现是tomcat的RequestFacade实现类(多态)
    在这里插入图片描述


    三、数据库驱动

    JAVA定义了JDBC Driver接口,不同的数据库开发商按照规范实现该接口,这也是多态的一种表现形式(一个接口对应不同的实现类)。
    在这里插入图片描述

    // Mysql注册JDBC驱动程序
     Class.forName("com.mysql.cj.jdbc.Driver");  
     //SqlServer注册JDBC驱动程序
     Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver")
     
    

    总结

    本文简单的介绍了多态的几种应用场景,包括常用类的方法、HttpServletRequest的实现以及数据库驱动接口。接口与多态密切相关,由于接口可以有多个不同的实现类所以常常表现出多态性。


    展开全文
  • Java多态总结

    2022-02-20 21:43:44
    多态指的是: 向上转型: 子 === >父(upcasting) 又被称为自动类型转换。 父类型引用指向子类型对象。包括编译阶段和运行阶段: 编译阶段:绑定父类的方法——静态绑定 运行阶段:动态绑定子类型对象方法——动态...

    多态指的是:
    同一个行为具有多个不同的表现形式或者形态的能力(多种形态、多种状态)。
    向上转型:
    子 === >父(upcasting)
    父类引用指向子类对象叫向上转型。
    又被称为自动类型转换。
    父类型引用指向子类型对象。包括编译阶段和运行阶段:
    编译阶段:绑定父类的方法——静态绑定
    运行阶段:动态绑定子类型对象方法——动态绑定
    向下转型:
    父= = => 子(downcasting)
    又被称为强制类型转换。
    向下转型必须要进行“强制类型转换”。
    什么时候向下转型?
    当想要访问的方法是子类中特有的方法时,必须要进行向下转型。
    创建下面这些类和方法:

    class Animal
    {
    	public void move(){
    		System.out.println("Animal在移动");
    	}
    }
    class Cat extends Animal
    {
    	public void move(){
    		System.out.println("cat在走猫步");
    	}
    	public void catchMouse(){
    		System.out.println("猫在抓老鼠");
    	}
    }
    class Bird extends Animal
    {
    	public void move(){
    		System.out.println("Bird在飞翔");
    	}
    }
    

    当访问方法仅在子类中存在时,编译阶段的静态绑定出现问题,就会发生编译错误,如下:

    public static void main(String[] args)
    	{
    		Animal s = new Cat();
    		s.catchMouse();
    	}
    

    在这里插入图片描述
    所有必须要进行类型转换(向下转型):

    public static void main(String[] args)
    	{
    		Animal s = new Cat();
    		//s.catchMouse();
    		Cat s2 = (Cat)s;
    		s2.catchMouse();
    	}
    

    向下类型转换存在着危险,例如:

    public static void main(String[] args)
    	{
    		Animal s = new Bird();
    		Cat s2 = (Cat)s;
    		s2.catchMouse();
    	}
    

    AnimalCat存在继承关系,可以向下转型,编译没有问题。但是,在实际运行过程中,在堆内存中创建的是Bird类型的对象,CatBird没有继承关系,所以在运行时就会报错,如下:
    在这里插入图片描述
    如何避免这种异常的发生呢?
    需要用到一个运算符:instanceof
    第一:instanceof 可以在运行阶段动态判断引用指向的对象的类型。
    第二:instanceof语法:引用 instanceof 类型
    第三:instanceof运算符的运算结果只能是:true / false
    第四:假设 A instanceof B 的运算结果是true,那么表示:
    A指向堆内存中的Java对象是B类型。
    多态在软件开发中有什么作用呢?
    在软件开发中有一条基本原则"开闭原则(OCP)":对扩展开放,对修改关闭(尽量避免修改原有程序)。
    如果我们要模拟主人(Master)喂养宠物(Pet),现有宠物有Dog,Cat。
    在使用多态前

    public class Master{
    	public void feed(Dog d){......};
    	public void feed(Cat d){......};
    }
    

    以上代码看出,Master与Cat,Dog之间的关系十分紧密(耦合度高),导致扩展性很差,如果想要新添加一个宠物,必须要修改Master类。
    使用多态后:

    public class Master{
    	public void feed(Pet pet){......};
    }
    

    以上代码中:Master与Dog,Cat就脱离了关系,Master只关注Pet类,这样程序的扩展性就增强了。

    展开全文
  • java多态是如何实现的?java的多态和c++一样,是通过延时绑定(late binding)或者说运行时绑定(runtime binding)来实现的。当调用某一个对象引用的方法时,因为编译器并不知道这个引用到底指向的是变量声明时说明的...

    java多态是如何实现的?java的多态和c++一样,是通过延时绑定(late binding)或者说运行时绑定(runtime binding)来实现的。当调用某一个对象引用的方法时,因为编译器并不知道这个引用到底指向的是变量声明时说明的类型对象,还是该类型子类的对象。因此编译器无法为这次调用绑定到具体的某个方法。只有通过java中的运行时类型识别(rtti, runtime type identification)在运行时绑定到具体的方法。下面是一个具体的例子:

    class shape

    {

    public void draw()

    {

    print("shape");

    }

    }

    class triangle extends shape

    {

    public void draw()

    {

    print("triangle");

    }

    }

    public class polymorphism {

    public static void main(string[] args)

    {

    shape s=new triangle();

    s.draw();

    }

    结果是triangle

    s是一个shape引用,但是在运行时因为是triangle对象,所以还是调用了triangle的draw方法。

    java多态中的一些陷阱

    重写私有方法?java里面是不能重写私有方法的,这个其实很好理解,因为私有方法在子类是不可见的。子类没有继承父类的私有方法,更谈不上重写了。因此在子类中的同名方法是一个全新的方法。

    public class polymorphism {

    private void show()

    {

    print("show parent");

    }

    public static void main(string[] args)

    {

    polymorphism p=new privatemethod();

    p.show();

    }

    }

    class privatemethod extends polymorphism

    {

    public void show()

    {

    print("show derived");

    }

    }

    结果是 show parent

    字段和静态方法的多态?子类可以继承父类的非私有字段,子类的字段是否也具有多态性呢?我们来看一个实际的例子:

    class shape

    {

    protected int perimeter=1;

    public void draw()

    {

    print("shape");

    }

    public int getperimeter()

    {

    return perimeter;

    }

    }

    class triangle extends shape

    {

    int perimeter=3;

    public void draw()

    {

    print("triangle");

    }

    public int getperimeter()

    {

    return perimeter;

    }

    public int getsuperperimeter()

    {

    return super.perimeter;

    }

    }

    public class polymorphism {

    public static void main(string[] args)

    {

    shape s=new triangle();

    print("s.perimeter:"+s.perimeter);

    print("s.getperimeter:"+s.getperimeter());

    triangle t=new triangle();

    print("t.perimeter:"+t.perimeter);

    print("t.getperimeter:"+t.getperimeter());

    print("t.getsuperperimeter:"+t.getsuperperimeter());

    }

    }

    以下是运行结果:

    fc9bba6780a4cc42bc4300c8c48f00a9.png

    这个运行结果包含了以下信息:

    1.triangle对象向上转型成shape后字段直接访问都是由编译器确定的,因此不会表现出多态性,返回的是1。

    2.triangle对象向上转型成shape后调用方法访问字段是根据运行时对象类型延时绑定调用了triangle的getperimeter方法,返回的是3

    3.t对象中包含了两个perimeter字段,一个来自于他本身,一个来自于他的父类。同时用字段名去调用该字段时默认返回的是他本身的perimeter字段,要调用从父类继承的该字段,要用super.perimeter的方法。

    这个结果看起来多多少少让人有些疑惑,为了避免这种情况出现,我们一般都把字段声明为private(子类就无法继承),同时我们在子类中声明的字段最好不要与从父类继承的字段同名。

    静态方法是没有多态性的,因为静态方法是和类绑定的,不会存在不知道具体类型的情况。

    构造函数的多态性?

    构造函数是不具有多态性的,因为构造方法本身是静态方法(如果不是的话,就会陷入鸡生蛋,蛋生鸡的死循环了)。要引入我们的问题,先来看一下构造函数的调用顺序。

    1.为这个对象分配的存储空间都被初始化为0(对象初始化为null)

    2.父类的构造函数调用(这样才能保证在子类的构造函数中访问的字段被初始化)

    3.成员变量初始化

    4.子类的构造函数调用

    现在假设如果在第二步中,我们在父类的构造函数里调用了某个方法,这个方法是不是多态的?还是来看一个具体的例子:

    class shape

    {

    protected int perimeter=1;

    public shape()

    {

    draw();

    print("shape created");

    }

    public void draw()

    {

    print("draw shape "+perimeter);

    }

    }

    class triangle extends shape

    {

    int perimeter=3;

    public triangle()

    {

    print("triangle created");

    }

    public void draw()

    {

    print("draw triangle "+perimeter);

    }

    public int getperimeter()

    {

    return perimeter;

    }

    }

    public class polymorphism {

    public static void main(string[] args)

    {

    shape s=new triangle();

    }

    }

    运行结果:

    我们可以看到虽然triangle对象还没有构造完毕,draw方法仍是动态绑定到了triangle的draw方法。同时注意到perimeter的值还没有初始化为3,而是0。

    这样的结果就是我们在triangle对象还没有被初始化之前就访问了其中的字段。因此我们在实际应用中要避免在构造函数中调用其他方法,或者只调用私有方法(不会被继承,因此不会引发该问题)

    希望与广大网友互动??

    点此进行留言吧!

    展开全文
  • Java 多态

    2021-03-09 09:03:24
    1、引用多态当我们写面向对象程序的时候,一般父类的引用可以指向本类的对象。Animal a = new Animal(); //a是父类的引用指向的是本类的对象Animal b = new Dog(); //b是父类的引用指向的是子类的对象//注意:...
  • JAVA多态的使用规则

    2021-04-23 19:41:04
    } public static void main(String[] args) { //使用多态,将Son子类使用Father父类容纳 Father son = new Son(); System.out.println(son.name); //由原则1,等号左边时Father,所以得到Father的成员变量,输出-->...
  • Java多态——向上、向下转型
  • java多态——练习题

    千次阅读 2020-11-24 19:37:22
    } } 父类中的color和weight属性后面不需要被用到 父类的findArea()方法里面可以随便写,因为它的子类要重写这个方法 2. 子类Circle() package package2; class Circle extends GeometricObject{ ...
  • Java多态之向下转型

    2021-02-28 11:46:46
    Java多态之向下转型往期回顾:我们学习了向上转型和动态绑定的概念,可以知道继承关系中,将一个子类对象赋值给父类的引用变量,调用父类的方法,实际运行时,就可以根据子类中重写的方法执行不同的操作。...
  • java多态的使用

    2021-02-26 11:03:49
    首先,什么是多态?我们应该从什么角度来理解多态?其实,我们不妨把多态理解成一种事物的多种存在形态,比如,猫和狗都可以变成动物,而动物又可以变成猫和狗。为了充分理解多态,我们可以从以下这几个方面来理解...
  • java中的多态

    2021-02-28 18:18:50
    因为java语言的经典著作《Thinking in JAVA》里说:多态通过分离做什么和怎么做,从另一个角度将接口和实现分离开来。这里的接口泛指基类、接口类,因此多态应该基于类的继承或者接口的实现而...
  • Java多态机制实际中的应用

    千次阅读 2018-04-23 14:35:14
    这个时候就可以用到java多态机制,先定义一个公共接口,接口定义支付流程的各个方法,具体的支付方式实现该接口的方法。控制层,利用spring的注入获取支付类型和支付方式实现类的引用映射,根据请求需要的支付...
  • 不是多态的程序,但有继承和重写:classPerson{publicvoidSayHello(){System.out.println("父类");}}classStudentextendsPerson{publicvoidSayHello(){System.out.println("学生类");...不是多态的程序,但有继承和...
  • Java_多态

    2021-03-12 10:32:35
    定义:所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用编程时并不确定,而是程序运行期间才确定,即一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底...
  • JAVA多态的理解

    2022-03-24 20:54:23
    JAVA多态的理解以及使用。
  • Java多态

    2022-03-03 10:04:28
    这里写目录标题Java多态虚函数多态的实现方式方式一:重写(Override)方式二:接口方法三:抽象类与抽象方法抽象类抽象方法总结 Java多态 多态存在的三个必要条件: 1.继承:要有继承关系,子类继承父类 2.重写:子类...
  • java多态的特性

    2020-06-04 13:32:34
    多态 多态是同一个行为具有多个不同表现形式或形态的能力; 多态就是同一个接口,使用不同的实例而执行不同的操作; 多态性是对象多种表现形式的体现。 ...1.1多态的优点 ...1.3哪里用到多态 方法的重写...
  • 最近深入学习java,看到了动态绑定和多态这一章节,但遗憾的是,大部分的相关文章都停留于表面文字的描述。不得已,最后google了几篇英文文章,此总结下这个问题。 一、静态绑定和动态绑定的区别 在Java中,当你...
  • 大厂面试真题向来是求职者的最佳练兵场,华为在Java开发工程师招聘中有哪些技术性考察和倾向?那今天咱就给大家分享一下近期的华为5面面经! 注:以下所分享的华为面试问题,相关的答案我也整理出来了,且为了更加...
  • 多态 & java泛型

    2021-12-10 00:21:43
    java泛型1、回顾java的多态性1)什么是多态(“多”对1 + 不同“态” => 统一与差异)2)接口和抽象类的比较(同: 抽象方法、继承,异: 多态实现)2、泛型的本质 & 作用1)泛型的本质 - 类型参数化2)泛型的...
  • java多态简析

    2021-03-16 11:11:48
    在Java运行时多态性:继承和接口的实现一文中,我们曾详细介绍了Java实现运行时多态性的动态方法调度;今天我们再次深入Java核心,一起学习Java中多态性的实现。“polymorphism(多态)”一词来自希腊语,意为“多种...
  • Java多态(非常重要)

    2021-03-15 15:55:11
    多态(多种形态)的定义同一消息对不同类的对象做出的不同响应种类程序设计中一般说多态都是运行时多态多态施行的条件:1满足继承关系2父类引用指向子类对象(向上转型)向上转型向下转型(子类引用指向父类对象,此处...
  • java多态的讲解

    2022-02-23 11:03:21
    多态具备的三个条件: 1.继承 2.重写 3.向上转型,父类的对象保存子类的实例,父类的引用指向子类的对象 多态的基础语法: 1.学习多态基础语法之前,我们需要普及两个概念: 第一个:向上转型 子----->父...
  • 封装隐藏了类的内部实现机制,可以不影响使用的情况下改变类的内部结构,同时也保护了数据。对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法。继承是为了重用父类代码。两个类若存在IS-A的关系就...
  • 之前一直知道多态是什么东西,平时敲代码也经常用到多态,但一直没有真正了解多态底层的运行机制到底是怎么样的,这两天才研究明白点,特地写下来,跟各位同学一起进步,同时也希望各位大神指导和指正。多态的概念:...
  • Java的四个基本特性 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。 继承 : 继承是从已有类得到继承...
  • 继承和多态的相关Java源码下载,比较散,像覆盖和重载、对象类Object和它的toString()方法、多态性、动态绑定和一般程序设计、数组线性表ArrayList类、final类、方法和变量、数据域和静态方法的隐藏、调用父类的方法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,088
精华内容 18,435
关键字:

java多态在哪用到

java 订阅