精华内容
下载资源
问答
  • 虚方法&非虚方法

    千次阅读 2016-11-15 09:21:39
    虚方法:只能被invokestatic和invokespecial指令调用的方法,称为虚方法,常见的虚方法有:静态方法、私有方法、实例构造器、父类方法四种。 虚方法:除非虚方法以外的其它方法。 注意:被final修饰的方法,虽然是...

    非虚方法:只能被invokestatic和invokespecial指令调用的方法,称为非虚方法,常见的非虚方法有:静态方法、私有方法、实例构造器、父类方法四种。

    虚方法:除非虚方法以外的其它方法。

    注意:被final修饰的方法,虽然是invokevirtual指令调用,但依然为非虚方法,代码如下:


    Java代码:


    public class User {
    
        private Long userId;
    
        public User() {
        }
    
        public User(Long userId) {
            this.userId = userId;
        }
    
    
    }


    public class SuperClass {
    
    
        public void superMethod(){
    
        }
    
    }


    public class InvokeMethods extends SuperClass {
    
        public static void main(String[] args) {
            InvokeMethods finalMethodTest = new InvokeMethods();
            //调用被final修饰的方法
            finalMethodTest.finalMethod();
            //调用被static修饰的方法
            InvokeMethods.staticMethod();
            //调用被private修饰的方法
            finalMethodTest.privateMethod();
            //调用父类方法
            finalMethodTest.superMethod();
            //调用构造器
            User user = new User();
        }
    
        public final void finalMethod(){
    
        }
    
        public static void staticMethod(){
    
        }
    
        private void privateMethod(){
    
        }
    
    }



    字节码:


    // class version 52.0 (52)
    // access flags 0x21
    public class demo/InvokeMethods extends demo/SuperClass  {
    
      // compiled from: InvokeMethods.java
    
      // access flags 0x1
      public <init>()V
       L0
        LINENUMBER 6 L0
        ALOAD 0
        INVOKESPECIAL demo/SuperClass.<init> ()V
        RETURN
       L1
        LOCALVARIABLE this Ldemo/InvokeMethods; L0 L1 0
        MAXSTACK = 1
        MAXLOCALS = 1
    
      // access flags 0x9
      public static main([Ljava/lang/String;)V
       L0
        LINENUMBER 9 L0
        NEW demo/InvokeMethods
        DUP
        INVOKESPECIAL demo/InvokeMethods.<init> ()V
        ASTORE 1
       L1
        LINENUMBER 11 L1
        ALOAD 1
        INVOKEVIRTUAL demo/InvokeMethods.finalMethod ()V //final方法的调用
       L2
        LINENUMBER 13 L2
        INVOKESTATIC demo/InvokeMethods.staticMethod ()V //静态方法调用
       L3
        LINENUMBER 15 L3
        ALOAD 1
        INVOKESPECIAL demo/InvokeMethods.privateMethod ()V //私有方法调用
       L4
        LINENUMBER 17 L4
        ALOAD 1
        INVOKEVIRTUAL demo/InvokeMethods.superMethod ()V //调用父类方法
       L5
        LINENUMBER 19 L5
        NEW demo/User
        DUP
        INVOKESPECIAL demo/User.<init> ()V //调用类构造器
        ASTORE 2
       L6
        LINENUMBER 20 L6
        RETURN
       L7
        LOCALVARIABLE args [Ljava/lang/String; L0 L7 0
        LOCALVARIABLE finalMethodTest Ldemo/InvokeMethods; L1 L7 1
        LOCALVARIABLE user Ldemo/User; L6 L7 2
        MAXSTACK = 2
        MAXLOCALS = 3
    
      // access flags 0x11
      public final finalMethod()V
       L0
        LINENUMBER 24 L0
        RETURN
       L1
        LOCALVARIABLE this Ldemo/InvokeMethods; L0 L1 0
        MAXSTACK = 0
        MAXLOCALS = 1
    
      // access flags 0x9
      public static staticMethod()V
       L0
        LINENUMBER 28 L0
        RETURN
        MAXSTACK = 0
        MAXLOCALS = 0
    
      // access flags 0x2
      private privateMethod()V
       L0
        LINENUMBER 32 L0
        RETURN
       L1
        LOCALVARIABLE this Ldemo/InvokeMethods; L0 L1 0
        MAXSTACK = 0
        MAXLOCALS = 1
    }
    


    展开全文
  • 虚方法 特点: &amp;amp;lt;1&amp;amp;gt;虚方法必须使用virtual修饰 &amp;amp;lt;2&amp;amp;gt;虚方法同抽象方法(adstract)一样使用override关键字重写 &amp;amp;lt;3&amp;amp;gt;...

    虚方法

    特点:
    <1>虚方法必须使用virtual修饰
    <2>虚方法同抽象方法(adstract)一样使用override关键字重写
    <3>虚方法在子类中可以实现,也可以不实现。
    <4>虚方法必须有方法体哪怕是空的
    <5>虚方法不能使用sealed修饰,否则不能重写。

    重点内容
    虚方法与抽象方法的区别:
    <1>关键字不同抽象方法(abstract)虚方法(virtual)
    <2>抽象方法必须在抽象类中,而虚方法不需要
    <3>抽象方法在父类中不可以实现,虚方法可以实现
    <4>抽象方法子类必须实现抽象方法,虚方法可以选择实现或者不实现

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace ConsoleApp1
    {
        //定义一个Person类
        public class Person
        {
            //定义方法跑,使用virtual修饰
            public virtual  void PerRun()
            {
                Console.WriteLine ("正长运动");
            }
    
        }
        //定义学生类继承人类
        public class Student:Person
        {
            public override void PerRun()
            {
                Console.WriteLine ( "百米冲刺");
            }
        }
    
    
        class Program
        {
            static void Main(string[] args)
            {
                //使用父类调用子类
                Person p = new Student ( );
                p.PerRun ( );
                Console.ReadKey ( );
    
    
            }
        }
    }
    
    展开全文
  • asp.net 虚方法、抽象方法、接口疑问等说明。
  • 今天在云和学院学了很多,我这次只能先总结一下C#中的虚方法和抽象的运用。 理论: 虚方法: 用virtual修饰的方法叫做虚方法 虚方法可以在子类中通过override关键字来重写 常见的虚方法:ToString() Equals 抽象...
  • 虚方法是.NET中的重要概念,可以说在某种程度上,虚方法使得多态成为可能。 然而虚方法的使用却存在着很大学问,如果滥用的话势必对程序产生很大的负面影响。比如下面这个例子: public class Puzzle { public ...
  • 主要介绍了C#虚方法的声明和使用实例教程,对于初学者理解C#的虚方法有一定的帮助,需要的朋友可以参考下
  • 虚方法的解释

    2016-01-13 17:33:41
    虚方法实际上介绍virtual 修饰符,我们称之为虚方法,反之为非虚。使用了virtual 修饰符后,不允许再有static, abstract, 或override 修饰符。
  •  静态的方法是非虚方法(Java中的非虚方法有private,final,static,构造器,非虚方法无需根据具体的对象遍历方法区的方法表,决定调用关系)  也是说,对于静态类型方法的调用,是其声明类型的,如Parent c = ...
  • 利用实例巧妙区分“抽象方法”和“虚方法”!

    千次阅读 多人点赞 2020-07-08 08:39:47
    最近在开发中,get到了虚方法这个名词,由于当时是在抽象类中用到,并且抽象方法和虚方法的使用有那么一丝丝的相近,之前也有了解过虚方法,但是对其概念比较模糊,所以今天在这里记录一下抽象方法和虚方法的区别。...

    抽象方法是指定义在抽象类中的方法,需要在子类中被实现的方法。而虚方法是指可以被子类覆盖的方法,或者说是可以被重写的方法。

    目录

    什么是抽象方法和虚方法?

    抽象方法和虚方法的区别

    举例分析方法的不同

    抽象方法

    虚方法


    Hello!我是灰小猿!

    最近在开发中,get到了虚方法这个名词,由于当时是在抽象类中用到,并且抽象方法和虚方法的使用有那么一丝丝的相近,之前也有了解过虚方法,但是对其概念比较模糊,所以今天在这里记录一下抽象方法和虚方法的区别。

     

    什么是抽象方法和虚方法?

    通俗上来讲,抽象方法是指定义在抽象类中的方法,需要在子类中被实现的方法。

    而虚方法是指可以被子类覆盖的方法,或者说是可以被重写的方法。

     

    抽象方法和虚方法的区别

    抽象方法:只有方法名,没有方法体,方法名前用abstract关键字定义,必须在抽象类中声明,子类必须重写并实现父类中的抽象方法。

    虚方法:有方法名和方法体,方法名前用virtual关键字定义,并不是必须在抽象类中声明,可以在任何非密封类中声明,但是当子类继承了父类后,存在于父类中的虚方法可以被重写,也可以不被重写。

    关于抽象类的深入了解,小伙伴可以移步至我的这篇文章“抽象类到底抽不抽象?实例对比一看便知!

     

    举例分析方法的不同

    下面举个栗子说明一个抽象方法和虚方法的不同用途,以下代码使用C#语言编写,Java等语言思路类似。

     

    抽象方法

    比如说有一个基类“动物类”,同时有两个子类“鸟类”和“鸡类”。这两个类都有公共和特有的属性和方法。

    如鸡和鸟都会叫,但是叫声不同,

    鸡叫:咯咯咯

    鸟叫:叽叽叽

    我们就可以在基类“动物类”中定义一个约束“鸟类”和“鸡类”的抽象方法“叫声”。让这两个类分别实现该方法。

    抽象方法的实现代码如下:

    定义抽象类“动物类”实现抽象方法

    //定义抽象类“动物类”
        abstract class Animal
        {
            //定义抽象方法“叫声”
            abstract public void cry();
        }

    定义“鸟类”,并且继承自“动物类”,实现“动物类”中的抽象方法。

    //定义子类“鸟类”,并且继承自“动物类”
     class Fowl : Animal
        {
            //实现“动物类”中的抽象方法cry
            public override void cry()
            {
                Console.WriteLine("鸟叫:叽叽叽");
            }      
    
        }

    定义“鸡类”,并且继承自“动物类”,实现“动物类”中的抽象方法。

     //定义“鸡类”,并且继承自“动物类”
        class Chicken : Animal
        {
            //实现“动物类”中的抽象方法cry
            public override void cry()
            {
                Console.WriteLine("鸡叫:咯咯咯");
            }
        }

    主类中分别调用“鸟类”和“鸡类”实现该叫声方法

    class Program
        {
            static void Main(string[] args)
            {           
                //新建一个对象对“鸟类”实例化
                Fowl fowl = new Fowl();
                //新建一个对象对“鸡类”实例化
                Chicken chicken = new Chicken();
    
                fowl.cry();     //实现“鸟类”中叫声方法
                chicken.cry();  //实现“鸡类”中叫声方法
            }
        }

    运行结果:

     

    虚方法

    还有比如鸡和鸟都会飞,而且都是扇动翅膀飞行,但是鸟飞的很高,鸡飞的很低,这就是在飞行这个方法上,“鸡类”和“鸟类”既有公共特征也有不同特征,

    那么就可以将飞行这个方法定义为虚方法,分别在“鸡类”和“鸟类”中重写该方法,但是会保留该方法中原有的公共特征“扇动翅膀”,添加自己特有的特征“飞行高度”。

    虚方法的实现代码如下:

    由于虚方法并不是必须在抽象类中声明,而是可以在任何非密封类中声明,所以将飞行这一动作声明在基类“动物类”中。

    //定义基类“动物类”
        class Animal
        {
            //定义抽象方法“叫声”
            public void fly()
            {
                Console.WriteLine("扇动翅膀飞行");
            }
        }

    在“鸟类”中重写飞行方法,加入该类特有的特征:

     //定义子类“鸟类”,并且继承自“动物类”
        class Fowl : Animal
        {
            //重写“动物类”中的方法fly,并用bew关键字对基类中的fly方法进行隐藏
            public new void fly()
            {
                Console.WriteLine("扇动翅膀飞行");
                Console.WriteLine("鸟飞的很高");
            }    
        }

    在“鸡类”中重写飞行方法,加入该类特有的特征:

    //定义“鸡类”,并且继承自“动物类”
        class Chicken : Animal
        {
            //重写“动物类”中的方法fly,并用bew关键字对基类中的fly方法进行隐藏
            public new void fly()
            {
                Console.WriteLine("扇动翅膀飞行");
                Console.WriteLine("鸡飞的很低");
            }
        }

    在主类中分别调用“鸟类”和“鸡类”实现该飞行方法:

       class Program
        {
            static void Main(string[] args)
            {         
                //新建一个对象对“鸟类”实例化
                Fowl fowl = new Fowl();
                //新建一个对象对“鸡类”实例化
                Chicken chicken = new Chicken();
    
                fowl.fly();     //实现“鸟类”中飞行方法
                chicken.fly();  //实现“鸡类”中飞行方法
            }
        }

    运行结果:

    觉得不错记得点赞关注哟!

    大灰狼陪你一起进步!

     

    展开全文
  • 实现多态:虚方法

    2012-03-25 21:11:33
    实现多态:虚方法
  • 虚方法: 1、在父类方法的返回值前加 virtual 关键字,标记为虚方法,表示这个方法可以被子类重写。 2、虚方法必须有方法体,方法体中可以没有任何内容。 3、子类可以根据需求选择性的是否重写虚方法。如果需要重写...
  • 面向对象——虚方法

    千次阅读 2020-04-13 09:25:06
    通过virtual关键字修饰的方法称为虚方法虚方法可以被子类重写。例如程序中经常用的ToString()方法就是一个虚方法,它可以在其子类中重写,实现输出自定义格式的字符串。 注意:1、virtual修饰符不能与static、...

    通过virtual关键字修饰的方法称为虚方法。虚方法可以被子类重写。例如程序中经常用的ToString()方法就是一个虚方法,它可以在其子类中重写,实现输出自定义格式的字符串。

    注意:1virtual修饰符不能与staticabstract或者override修饰符同时使用。

    2、虚方法不能是私有的,所以virtual修饰符不能与private修饰符同时使用。

    例:使用virtual修饰符声明一个虚方法,用来计算两个数的和

    Public virtual int Add( int x,int y)

    {

             Return x+y;

    }

    2、重写方法:如果一个方法声明中含有override修饰符,则称该方法为重写方法,它主要用来使用相同的签名重写继承的虚方法。虚方法主要用来引入新方法,重写方法则使从积累继承而来的虚方法专用化。

    例:public override int Add(int x, int y)

    {return x+y;}

    注意:override修饰符不能与newstatic或者virtual修饰符同事时使用。另外、重新方法只能用于重写基类的虚方法,不能用来单独声明方法。

    例:

      public partial class Form1 : Form

        {

            public Form1()

            {

                InitializeComponent();

            }

            /// <summary>

            /// 建立的虚方法,可以在子类中被重写

            /// </summary>

            class Operation

            {

                public virtual double operation(int x,int y)

                {

                    return x * y;

                }

            }

            /// <summary>

            /// 在子类中重写虚方法

            /// </summary>

            class Addition : Operation

            {

                public override double operation(int x, int y)

                {

                    return (x + y);

                }

            }

     

            private void Form1_Load(object sender, EventArgs e)

            {

                comboBox1.SelectedIndex = 0;

            }

            private void txtNum1_KeyPress(object sender, KeyPressEventArgs e)

            {

                if (!(e.KeyChar <= '9' && e.KeyChar >= '0') && e.KeyChar != '\r' && e.KeyChar != '\b')

                {

                    e.Handled = true;

                }

            }

            private void txtNum2_KeyPress(object sender, KeyPressEventArgs e)

            {

                if (!(e.KeyChar <= '9' && e.KeyChar >= '0') && e.KeyChar != '\r' && e.KeyChar != '\b')

                {

                    e.Handled = true;

                }

            }

            private void button1_Click(object sender, EventArgs e)

            {

                if (txtNum1.Text == "" || txtNum2.Text == "")

                {

                    MessageBox.Show("请输入数字", "警告", MessageBoxButtons.OK, MessageBoxIcon.Error);

                }

                else

                {

                    if (comboBox1.SelectedIndex == 0)

                    {

                        Operation multiplication = new Operation();//原始虚方法进行乘法运算

                        txtResult.Text = multiplication.operation(Convert.ToInt32(txtNum1.Text.Trim()), Convert.ToInt32(txtNum2.Text.Trim())).ToString();

                    }

                    else

                    {

                        Operation Addition = new Addition();

                        txtResult.Text = Addition.operation(Convert.ToInt32(txtNum1.Text.Trim()), Convert.ToInt32(txtNum2.Text.Trim())).ToString();

                    }

                }

            }

        }

    展开全文
  • java之虚方法

    万次阅读 2018-02-01 14:19:11
    我的理解:所谓的虚方法就是java类在继承中,在上转型中,java类对象实际调用的方法是子类重写的方法;也就是编译器和jvm调用的不是同一个类的方法; Emloyee.java package lianxi; public class Emloyee {...
  • Java 多态和虚方法与非虚方法的调用

    千次阅读 2019-03-06 09:42:53
    虚方法的调用 package w5; class TestVirtualInvoke { static void doStuff( Shape s ){ s.draw(); } public static void main( String [] args ){ Circle c = new Circle(); Triangle t = new Triangle()...
  • CSharp之虚方法(virtual)

    千次阅读 2019-05-20 09:42:42
    虚方法是实现多态基本方法之一 虚方法通过virtual关键字修饰 虚方法在父类中必须有方法体,在继承类中可以重写(override),也可不重写 虚方法所在类可以被实例化 父类虚方法在派生类中通过base....
  • 虚方法和抽象方法的区别

    千次阅读 热门讨论 2016-01-28 21:25:14
    在查阅资料的过程中,偶然看到了虚方法和抽象方法,对其做个小结。    对比学习:  虚方法必须有实现部分,抽象方法不可以有实现部分;
  • java中虚方法

    千次阅读 2019-04-17 21:51:27
    Java的虚方法 虚方法出现在Java的多态特性中,父类与子类之间的多态性,对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Overriding)。 在Java中,子类可继承...
  • 重写虚方法四则运算

    2013-07-30 22:42:02
    重写虚方法是C#里必须掌握的,该例简单易懂适合C#初学者。
  •  虚方法实现多态  父类声明方法时加 virtual关键字表示这是一个虚方法  子类声明方法时加override关键字表示这个方法是重写父类中的虚方法  声明对象时 使用父类类型 声明对象变量 使用子类类型 构造...
  • 抽象方法和虚方法的区别? 抽象方法和虚方法的使用场合?
  • C#中CLR虚方法的多态调用C#中CLR虚方法的多态调用C#中CLR虚方法的多态调用C#中CLR虚方法的多态调用C#中CLR虚方法的多态调用
  • C#中虚方法(virtual)详解

    千次阅读 2020-06-17 22:47:36
    虚方法如何定义? 虚方法怎么声明? 虚方法的规则是什么? 虚方法如何进行调用? 虚方法的作用是什么? 虚方法有什么好处? 虚方法使用时注意什么?
  • 什么是虚方法

    千次阅读 2014-05-30 17:11:53
    虚方法使用起来比较简单,但很难理解,对于一个没有
  • 利用实例巧妙区分“抽象方法”和“虚方法”!.pdf
  • 引言 ...要想子类重写父类的方法能被父类看到,那就需要虚方法虚方法就是一个基本的多态结构。 虚方法的作用 在父类中使用virtual定义的方法和函数,父类句柄在指向子类对象时,可以动态索引到子
  • C#中的虚方法

    千次阅读 2013-12-26 01:42:22
    当类中的方法声明前加上virtual, 该方法称为虚方法虚方法可以被重载。 如果对方法使用了virtual修饰符后,将不再允许有static,abstract或override修饰符对方法进行定义。 对于非虚方法,无论被其所在类的实例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 233,719
精华内容 93,487
关键字:

虚方法