精华内容
下载资源
问答
  • 多态性名词解释
    千次阅读
    2018-07-10 13:10:46

    1.SNP

    SNP:Single Nucleotide Polymorphisms单核苷酸多态性,主要是指在基因组水平上由单个核苷酸的变异所引起的DNA序列多态性

    2.InDel

    InDel (insertion-deletion) 插入缺失标记,指的是两种亲本中在全基因组中的差异,相对另一个亲本而言,其中一个亲本的基因组中有一定数量的核苷酸插入或缺失

    3.SNV

    SNV:单核苷酸位点变异(single nucleotide variants)在研究癌症基因组变异时,相对于正常组织,癌症中特异的单核苷酸变异是一种体细胞突变(somatic mutation).

    4.BQSR:碱基质量重打分(Bsae Quality Score Recalibration)


    更多相关内容
  • 文章目录一、多态性是什么?二、使用注意事项三、多态性应用举例三、虚拟方法调用总结 一、多态性是什么? 多态性,是面向对象中最重要的概念,在Java中的体现:对象的多态性: 父类的引用指向子类的对象。可以直接...


    一、多态性是什么?

    多态性,是面向对象中最重要的概念,在Java中的体现:对象的多态性:
    父类的引用指向子类的对象。可以直接应用在抽象类和接口上

    二、使用注意事项

    Java引用变量有两个类型:编译时类型和运行时类型。编译时类型由声明
    该变量时使用的类型决定,运行时类型由实际赋给该变量的对象决定。简
    称:编译时,看左边;运行时,看右边。

    若编译时类型和运行时类型不一致,就出现了对象的多态性(Polymorphism)
    多态情况下,
    “看左边”:看的是父类的引用(父类中不具备子类特有的方法)
    “看右边”:看的是子类的对象(实际运行的是子类重写父类的方法)

    对象的多态 —在Java中,子类的对象可以替代父类的对象使用
    1)一个变量只能有一种确定的数据类型
    2)一个引用类型变量可能指向(引用)多种不同类型的对象

    Person p = new Student();
    Object o = new Person();//Object类型的变量o,指向Person类型的对象
    o = new Student(); //Object类型的变量o,指向Student类型的对象
    

    子类可看做是特殊的父类,所以父类类型的引用可以指向子类的对象:向
    上转型(upcasting)。

    一个引用类型变量如果声明为父类的类型,但实际引用的是子类对象,那么该变量就不能再访问子类中添加的属性和方法

    Student m = new Student();
    m.school = “pku”; //合法,Student类有school成员变量
    Person e = new Student(); 
    e.school = “pku”; //非法,Person类没有school成员变量
    /*属性是在编译时确定的,编译时e为Person类型,没有school成员变量,因而编
    译错误。*/
    

    三、多态性应用举例

    方法声明的形参类型为父类类型,可以使用子类的对象作为实参调用该方法

    public class Test {
    		public void method(Person e) {
    		// ……
    		e.getInfo();
    }
    public static void main(Stirng args[]) {
    		Test t = new Test();
    		Student m = new Student();
    		t.method(m); // 子类的对象m传送给父类类型的参数e
    	}
    }
    

    三、虚拟方法调用

    正常的方法调用

    Person e = new Person();
    e.getInfo();
    Student e = new Student();
    e.getInfo();
    

    虚拟方法调用(多态情况下)
    子类中定义了与父类同名同参数的方法,在多态情况下,将此时父类的方法称为虚拟方法,父类根据赋给它的不同子类对象,动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

    Person e = new Student();
    e.getInfo(); //调用Student类的getInfo()方法
    

    编译时类型和运行时类型
    编译时e为Person类型,而方法的调用是在运行时确定的,所以调用的是Student类的getInfo()方法。——动态绑定


    总结

    多态作用:提高了代码的通用性,常称作接口重用
    前提:1)需要存在继承或者实现关系 2)有方法的重写

    成员方法:
    编译时:要查看引用变量所声明的类中是否有所调用的方法。
    运行时:调用实际new的对象所属的类中的重写方法。

    成员变量:
    不具备多态性,只看引用变量所声明的类。

    展开全文
  • 一:java作为一门面对对象的语言,首先具有的便是三大特性:封装、继承、多态;个人认为多态之所以会放在封装、继承...为了更好地去理解多态性,我先从多态性的一些现实意义中先去描述,再从代码中去描述。首先,多...

    1、知识点概述    

           java作为一门面对对象的语言,首先具有的便是三大特性:封装继承多态;个人认为多态之所以会放在封装、继承之后成为第三大特性,有一定的程度上是因为其部分建立在前两大特性的基础上的,继承是指某一类继承了其父类的一些属性和方法。而多态讲的是在存在父类与子类的基础上,即有继承性上的另一种性质,而封装性则在类这一定义上便有了体现,因此说多态是建立在前两个基础上的。常说的多态指的是使用父类对象的地方都可以使用子类的对象,即意味着父类型的变量可以引用子类型的对象

    2、背景知识

            有了多态,自然会有人会说为什么会有多态。多态存在的好处体现在下面五个方面:

            1、可替换性。

                    例如对圆Circle类工作时,对于其他的任何圆形几何体像圆柱等也可以工作。

            2、可扩容性。

                    即在父类上添加新的子类不会影响父类的多态性,从而使其是一种动态可变的方式。

            3、接口性。

                    多态其实和接口很像,为他的子类提供了一个共同接口,从而使两个子类可以同时调用。

            4、灵活性。

                    多态性的存在使得代码整体上更加灵活,更加富有多变。

            5、简化性。

                    利用多态性可以减少代码得数量和简化修改过程,减少了程序员的工作量。

    3、知识点详述

      (1).动态绑定

            在讲述多态性之前,首先要介绍java中的动态绑定机制动态绑定中有着两个重要的术语:声明类型实际类型。在创建变量时,一定要对此变量进行一个类型的说明,即为某种类型的变量。这个类型称作声明类型。但是对类型赋值时我们可以将别的类型的值赋给他,这个值的类型叫做实际类型。而变量的调用以及其方法与属性都是由实际类型决定,这就叫做动态绑定

      (2).向上转型和向下转型

            知晓动态绑定机制后,接下来就是转型了。转型分为向上转型向下转型。向上转型指的是把一个子类的实例转化为一个父类的变量,因为子类的实例总是父类的实例。向下转型指的是当需要把一个父类的实例转化为其子类变量。所以必须使用转换标记符(子类名)来进行向下转型,向编译器表达你的要求。但是向下转型并不是都可以转换成功的,会存在转换的变量并不是原来实例的子类,所以会出现异常。因此在进行向下转型时,可以先通过操作符instanceof来判断转换的变量是否为原来实例的子类,从而使程序成功运行。

      (3).多态性

            1.为了更好地去理解多态性,我先从多态性的一些现实意义中先去描述,再从代码中去描述。首先,多态性的现实意义可以描述为现实的一个事物中会出现多种形态,如学生,是属于人的一种,而同学张三,他既是又是学生,因此说其有着多种形态。

           2. 而在java中我们可以这么去理解,我们建立了一个person类person类的子类student类,当我们去new一个student对象zhangsan时,那么zhangsan既是person类的实例,也是student类的实例,因此我们在定义时便可以将张三定义为person类或者是student类。

           3. 用比较学术性的语言描述便是多态体现为父类引用变量可以指向子类对象(或子类的对象赋给父类)。

           4.多态的定义和格式:

                    定义格式:父类类型 变量名=new 子类类型();

           5.多态的其他理解:

                   多态是同一个行为具有多个不同表现形式或形态的能力。

                   多态就是同一个接口,使用不同的实例而执行不同操作。

            二:下面为java中多态性的代码展示。

            父类Person类

    package duotai;
    
    public class Person {
    	int age;
    	String name;
    	
    	public void eat(){
    		System.out.println("吃饭");
    	}
    	
    	public void walk(){
    		System.out.println("走路");
    	}
    }

            子类Student类

    package duotai;
    
    public class Student extends Person {
    	String grade;
    	
    	public void eat(){
    		System.out.println("学生吃肉");
    	}
    	
    	public void walk(){
    		System.out.println("学生骑车");
    	}
    }

           PersonTest

    package duotai;
    
    public class PersonTest {
    	public static void main(String[] args) {
    		Person zhangsan=new Student();
    		zhangsan.eat();
    		zhangsan.walk();
    	}
    }

    运行结果:

     从代码中可以发现,张三是Person类,但其指向一个Students类,因此我们在调用eat和walk方法时调用的是重写之后的Student中的eat和walk方法。而非person中的eat和walk方法。但是如果我们调用一个Person类中不存在的方法,但在Student类中存在的方法,会发现在运行时会报错。

    上述所描述的情况其实是java中动态绑定机制下的一个结果,张三作为一个实例,在调用其方法时,首先会从其最底层的子类先去寻找相对应的方法,也便是重写的方法,如果不存在则会一层一层往上去寻找,知道找到为止,然后实现并停止查找。如果没有找到那么自然就会报错。

    与方法相比较,多态性是不会对属性起作用的,即属性为父类的属性,属性的值也为父类的属性,而不会去由子类里的属性,这是一个与方法的区别,需要特别关注!!!

    在多态性中存在一个对象转换的概念:即我们上面对多态定义的格式称之为隐式转换,但当我们需要将一个已经存在的对象赋值给一个新的变量时,便要使用显示转换,即在对象前加一个其是属于哪种类的对象,来告诉编译器。语法为用圆括号把目标对象的类型括起来,然后放到要转换的对象面前,例如这样子:student lisi=(student)zhangsan,(而这种student lisi=zhangsan则是错误的)。显示转换和隐式转换用在什么地方呢?当我们要把子类的实例转换为父类的变量的时,可以用隐式转换,也称之为向上转换。但把父类的实例转换为子类的变量时便要用显示转换,也为向下转换。

    但有时会存在着要转换为子类的变量并不是子类的实例的情况,因此便要去判断一下是否为子类的实例来防止程序出错,因此便可以使用instanceof关键字来判断,若是则返回True,不是则返回False。

    4、扩展使用场景

    多态性在代码书写中有着巨大的作用。例如当我们需要通过调用一个类的一个方法来实现不同的功能时,便可以使用多态性。在父类上创建一个方法,然后在不同的子类里进行重写,从而能够使不同的子类的声明类型都定义为父类的类型,从而使得能够在一个循环内将不同的子类方法都进行调用。这是其中的一个使用场景。

    5、小结

    多态性看似是一个十分简单的性质,对于其使用貌似也并不是特别需要,但是当你在项目的进行过程中,会逐渐发现多态性的应用场景之妙,应用多态性的代码的美丽。因此,要想真正的熟悉和理解多态性,最关键的是要从项目中找取经验。

    展开全文
  • 对象多态性的理解

    千次阅读 2017-03-30 22:24:51
    那么多态性呢?多态性是Java中最强悍的地方,那么有一个简单但是又需要好好推敲的疑问:什么是多态?什么是对象的多态?1,什么是多态?,按我的理解,什么是多态,字面意思咯,多种状态。,面向对象的多态特性有两...

    面向对象的三大特性:封装—保护类中的属性不被外部直接访问到;继承—扩展类的属性和功能;那么多态性呢?

    多态性是Java中最强悍的地方,那么有一个简单但是又需要好好推敲的疑问:什么是多态?什么是对象的多态?

    1,什么是多态?

    ,按我的理解,什么是多态,字面意思咯,多种状态。

    ,面向对象的多态特性有两种提现方式:1,方法的重载与覆写(有的人说这不算多态,然而,我感觉算,因为他们也满足了多种状态的要求);2,对象的多态性;

    重载—根据方法参数个数和参数类型的不同完成的功能也不同;覆写—–子类根据需求覆写父类中的方法;

    这里写图片描述

    1-0:对象的多态性

    1-1相上转型:

    使用父类对象接收子类实例(自动完成)。子类对象为父类对象实例化。

    发生了向上转型,那么在子类中那些独有的属性和方法,就不能被这个转型了的对象所看到了。

    class A{                    // 定义类A
        public void fun1(){     // 定义fun1()方法
            System.out.println("A --> public void fun1(){}") ;
        }
        public void fun2(){
            this.fun1() ;       // 调用fun1()方法
        }
    };
    class B extends A{
        public void fun1(){     // 此方法被子类覆写了
            System.out.println("B --> public void fun1(){}") ;
        }
        public void fun3(){    //子类重新定义的自己独有的方法
            System.out.println("B --> public void fun3(){}") ;
        }
    };
    public class PolDemo01{
        public static void main(String asrgs[]){
            B b = new B() ;     // 实例化子类对象
            A a = b ;           // 向上转型关系
            a.fun1() ;          // 此方法被子类覆写过
            a.fun3() ;
        }
    };

    这里写图片描述
    这里a.fun3();这句代码就会报错,因为a已经是从b向上转型过来的了,它看不到b独有的方法了,能看到的都是b中从a继承而来和覆写而来的方法和属性。

    向上转型中的注意点

    但是,注意,发生了向上转型,是父类对象,然后去调用那些父类中的方法,会发现,被调用的依然是子类中覆写过的方法,如果没有覆写过这些方法,则才会调用父类中的方法,因为发生向上转型了,一定程度上说,他还是子类实例,在我的理解里,是剥除了子类独有特性的子类。(可以形象的这么理解,这个子类对象是个私生子,是婢女所生的非正室所生的孩子,没有给予他开疆拓土成为一方诸侯的能力,仅仅是拥有其父辈积攒的余荫以及和父辈紧密相关的权力,只有正室所生的孩子才拥有父辈带来的光辉以及在父辈基础上继续开疆拓土的权力)调用子类独有的方法和属性就会报错了,因为他的这些方法属性,已经被剥除了,他看不到了,所有报错了。

    public class PolDemo01{
        public static void main(String asrgs[]){
            B b = new B() ;     // 实例化子类对象
            A a = b ;           // 向上转型关系
            a.fun1() ;          // 此方法被子类覆写过
            a.fun2() ;
        }
    };

    这里写图片描述

    1-2向下转型:

    使用子类对象接收父类对象,就是将父类对象变为子类对象(需要强制转型)。

    class A{                    // 定义类A
        public void fun1(){     // 定义fun1()方法
            System.out.println("A --> public void fun1(){}") ;
        }
        public void fun2(){
            this.fun1() ;       // 调用fun1()方法
        }
    };
    class B extends A{
        public void fun1(){     // 此方法被子类覆写了
            System.out.println("B --> public void fun1(){}") ;
        }
        public void fun3(){
            System.out.println("B --> public void fun3(){}") ;
        }
    };
    public class PolDemo02{
        public static void main(String asrgs[]){
            A a = new B() ;         // 向上转型关系
            B b = (B)a ;        // 发生了向下转型关系
            b.fun1() ;
            b.fun2() ;
            b.fun3() ;
        }
    };

    这里写图片描述

    向下转型中,有一个注意点:

    在进行向下转型时,必须先进行向上转型,否则会出现类型转换异常(ClassCastException)。因为,仅仅通过父类,是无法判断某个类是否是其子类的,但是从子类中就可以直接通过extend关键字,直接明白其父类是谁,如果两个没有关系的对象之间进行转换就会发生此异常,就是说,要发生对象的向下转型关系,则肯定必须先产生一个向上转型关系,这样的目的就是为了建立两个对象之间的关系。

    class A{                    // 定义类A
        public void fun1(){     // 定义fun1()方法
            System.out.println("A --> public void fun1(){}") ;
        }
        public void fun2(){
            this.fun1() ;       // 调用fun1()方法
        }
    };
    class B extends A{
        public void fun1(){     // 此方法被子类覆写了
            System.out.println("B --> public void fun1(){}") ;
        }
        public void fun3(){
            System.out.println("B --> public void fun3(){}") ;
        }
    };
    public class PolDemo03{
        public static void main(String asrgs[]){
            A a = new A() ;         // 实例化了一个父类对象
            B b = (B)a ;        // 发生了向下转型关系
            b.fun1() ;
            b.fun2() ;
            b.fun3() ;
        }
    };

    这里写图片描述

    比如 A 类,B extends A 类,首先第一中情况:B b=new A();这肯定会报异常的;然后第二种情况:A a=new B();这就是向上转型,就是为了让A,B两个类的对象产生关系;之后在进行向下转型,B b=(B)a;这就不会有问题了;

    2,对象多态性的优势?

    说道优势,怎么最明显,必然是比较一下,一个东西,一门技术到底好不好,怎么知道,对比一下,俗话说,没比较就没伤害,对比一下,使用前和使用后到底有什么差别就知道优势在哪里了。

    2-1问题:

    设计一个方法,此方法可以接收A类的任意子类对象,并在主类中调用该方法。

    首先不使用多态,这个问题,肯定需要使用重载来完成:

    class A{                    // 定义类A
        public void fun1(){     // 定义fun1()方法
            System.out.println("A --> public void fun1(){}") ;
        }
        public void fun2(){
            this.fun1() ;       // 调用fun1()方法
        }
    };
    class B extends A{
        public void fun1(){     // 此方法被子类覆写了
            System.out.println("B --> public void fun1(){}") ;
        }
        public void fun3(){
            System.out.println("B --> public void fun3(){}") ;
        }
    };
    class C extends A{
        public void fun1(){     // 此方法被子类覆写了
            System.out.println("C --> public void fun1(){}") ;
        }
        public void fun5(){
            System.out.println("C --> public void fun5(){}") ;
        }
    };
    public class PolDemo04{
        public static void main(String asrgs[]){
            fun(new B()) ;  // 传递B的实例
            fun(new C()) ;  // 传递B的实例
        }
        public static void fun(B b){
            b.fun1() ;      // 调用覆写父类中的fun1()方法
        }
        public static void fun(C c){
            c.fun1() ;      // 调用覆写父类中的fun1()方法
        }
    };

    如果现在扩展功能,A类,有1000个子类,那就麻烦了,要增加很多个重载的功能方法,很不好。

    使用对象的多态

    class A{                    // 定义类A
        public void fun1(){     // 定义fun1()方法
            System.out.println("A --> public void fun1(){}") ;
        }
        public void fun2(){
            this.fun1() ;       // 调用fun1()方法
        }
    };
    class B extends A{
        public void fun1(){     // 此方法被子类覆写了
            System.out.println("B --> public void fun1(){}") ;
        }
        public void fun3(){
            System.out.println("B --> public void fun3(){}") ;
        }
    };
    class C extends A{
        public void fun1(){     // 此方法被子类覆写了
            System.out.println("C --> public void fun1(){}") ;
        }
        public void fun5(){
            System.out.println("C --> public void fun5(){}") ;
        }
    };
    public class PolDemo05{
        public static void main(String asrgs[]){
            fun(new B()) ;  // 传递B的实例
            fun(new C()) ;  // 传递B的实例
        }
        public static void fun(A a){
            a.fun1() ;      // 调用覆写父类中的fun1()方法
        }
    };

    这样的代码,无论A类有多少个子类都没问题。这个功能方法不需要进行修改。

    总结:
    这里写图片描述
    多态性总结。

    3,instanceof关键字

    3-1,什么时候使用instanceof关键字,这个关键字有什么作用?

    其实对于这个问题,很简单,在Java中,可以通过instanceof关键字来判断,一个对象是哪一个类的实例。

    格式: 对象 instanceof 类名称 —>返回内容是一个Boolean结果。

    对于之前的问题:一个方法可以接受一个类的任意子类对象,并可以调用该方法的问题已经通过多态的向上转型得到了完美的解决;那么现在有一个新的问题:A的子类A extends B,继承了A的方法,同时自定义了一个新的方法fun3(),A extends C,自定义了一个新的方法fun5(),现在的需求是:——当传入的类的类的对象是B的实例的时候,让这个对象调用fun3,如果传入的对象是C的实例的时候就让它调用fun5,

    对于这个需求,仅仅通过参数的多态就不够了,还需要在方法内部通过使用instanceof关键字对传入的对象进行判断,然后分别执行对应的方法。

        class A{                    // 定义类A
            public void fun1(){     // 定义fun1()方法
                System.out.println("A --> public void fun1(){}") ;
            }
            public void fun2(){
                this.fun1() ;       // 调用fun1()方法
            }
        };
        class B extends A{
            public void fun1(){     // 此方法被子类覆写了
                System.out.println("B --> public void fun1(){}") ;
            }
            public void fun3(){
                System.out.println("B --> public void fun3(){}") ;
            }
        };
        public class InstanceofDemo01{
            public static void main(String asrgs[]){
                A a1 = new B() ;        // 通过向上转型实例化对象   
                System.out.println("A a1 = new B():" + (a1 instanceof A)) ;     //true
                System.out.println("A a1 = new B():" + (a1 instanceof B)) ;     //true
                A a2 = new A() ;        // 通过向上转型实例化对象
                System.out.println("A a2 = new A():" + (a2 instanceof A)) ;   //true
                System.out.println("A a2 = new A():" + (a2 instanceof B)) ;    //FALSE
            }
        };

    在开发中,对于向下转型,一定要进行转型验证,以避免classCastException。

    class A{                    // 定义类A
        public void fun1(){     // 定义fun1()方法
            System.out.println("A --> public void fun1(){}") ;
        }
        public void fun2(){
            this.fun1() ;       // 调用fun1()方法
        }
    };
    class B extends A{
        public void fun1(){     // 此方法被子类覆写了
            System.out.println("B --> public void fun1(){}") ;
        }
        public void fun3(){
            System.out.println("B --> public void fun3(){}") ;
        }
    };
    class C extends A{
        public void fun1(){     // 此方法被子类覆写了
            System.out.println("C --> public void fun1(){}") ;
        }
        public void fun5(){
            System.out.println("C --> public void fun5(){}") ;
        }
    };
    public class InstanceofDemo02{
        public static void main(String asrgs[]){
            fun(new B()) ;
            fun(new C()) ;
        }
        public static void fun(A a){
            a.fun1() ;
            if(a instanceof B){
                B b = (B) a ;
                b.fun3() ;
            }
            if(a instanceof C){
                C c = (C) a ;
                c.fun5() ;
            }
        }
    };

    如果现在要新增子类,则肯定要修改fun方法,这样一来就失去了程序的灵活性,
    所以,开发中,程序设计的重点要放在父类的设计上,只有父类设计的足够合理,
    开发过程才会非常方便,就想基石必须夯实,高楼才能更高。

    开发规则:
    一个类永远不要去继承一个已经实现好的类,而是最好去继承一个抽象类或者去实现一个接口。

    展开全文
  • C++多态性的理解

    2021-06-02 15:58:24
    (和Java中的abstract抽象类实现多态性类似) 特别说明:父类指针的概念——以父类为数据类型声明一个指针,该指针可以指向任何一个对象,但是父类指针调用函数时是先调用父类自己的实函数,当发现有空的虚函数时会...
  • C ++中的多态性

    2021-07-05 03:39:26
    虚拟功能函数名称重载运算符重载除了上述三种类型的多态性外,还存在其他种类的多态性:运行编译时间ad-hoc多态性参数多态性我知道运行时多态性可以通过虚函数来实现静态多态性可以通过模板函数实现但对于另外两个ad...
  • 编译原理——常见名词解释,包括编译原理课程每一章节重要名词和常见名词的介绍和解释。 例如:编译程序是一种程序,它把高级语言编写的源程序翻译成与之在逻辑上等价的机器语言或汇编语言的目标程序。 一个高级语言...
  • 多媒体技术名词解释: 媒体:媒体可理解为承载信息的实际载体或者是表述信息的逻辑载体。 多媒体:多媒体就是在数值、文字、图形等由计算机处理的信息中,使静止图像、语音 、影像等时间序列信息相互关联,同步处理...
  • 最全的地理名词解释 方便代理人观看学习,包括 自然地理、人文地理、地理信息科学GIS
  • 第一章操作系统:配置在计算机硬件上的第一层软件,对硬件系统的首次扩充道程序设计:在计算机内存中同时存放几道相互独立的程序,它们在管理程序的控制下相互穿插地运行。批处理系统:供一次加载的磁带或磁盘,...
  • 计算机常用名词解释

    2021-06-23 01:31:53
    低级语言——机器语言和汇编语言 高级语言程序的执行方式——解释和编译 操作系统(OS)——是用于统一管理计算机硬件、软件资源,控制计算机工作流程和方便用户使用计算机的一系列程序总和。 文件——带有名字的一...
  • 简述什么是封装性、继承性和多态性

    万次阅读 多人点赞 2018-08-16 23:24:59
    封装就是把普通的对象进行封装,对象的属性设为私有的,对外提供get和...多态是建立在继承的基础上的,一个父类对象可以产生个不同的子类对象,根据这些子类对象的不同可以具备不同的方法,也就是说表现出了不同的...
  • 操作系统名词解释.pdf

    2022-06-22 17:42:24
    2 管:当执行操作系统程序时,处理机所处的状态 3 目:当执行普通用户程序时,处理机所处的状态。 4 道程序设计:在这种设计技术下,内存中能同时存放道程序,在管理程序的控制下交替的执行。这 些作业共享...
  • 三、名词解释 1. 作业周转时间:批处理用户从向系统提交作业开始,到作业完成为止的时间间隔成为作 业周转时间。(P121) 2. 文件:文件是由文件名所标识的一组信息的集合。(P359) 3. 进程切换(P100) (网络:进行进程...
  • 三、名词解释 1. 作业周转时间:批处理用户从向系统提交作业开始,到作业完成为止的时间间隔成为作 业周转时间。(P121) 2. 文件:文件是由文件名所标识的一组信息的集合。(P359) 3. 进程切换(P100) (网络:进行进程...
  • 2管:当执行操作系统程序时,处理机所处的状态 3目:当执行普通用户程序时,处理机所处的状态。 4道程序设计:在这种设计技术下,内存中能同时存放道程序,在管理程序的控制下 交替的执行。这些作业共享CPU...
  • PCB常用语常见名词解释,PCB英文翻译,常见名词解释,PCB初学者
  • 名词解释题1. 中断2. 进程控制块(PCB)3. 虚时钟4. 段式管理5. 文件控制块(FCB)6. 对换(SWAPPING)7. 系统调用8. 绝对路径名9. 特别文件10. 虚设备技术11. 管道 12. 中断接收 13. 恢复现场 14. 页式管理 15. 作业步16...
  • 检查技术名词解释.doc

    2021-10-12 18:01:54
    检查技术名词解释.doc
  • 变电站综合自动化系统名词解释.doc
  • 医学名词医学名词医学名词医学名词
  • 【遗传学名词解释

    千次阅读 2021-11-17 16:03:08
    对微效基因的效应累加起来可以形成明显的表型效应,称为加效应,这些基因称为加基因(additive gene) 2.allele (等位基因)同源染色体同一基因座位上的一对基因 3.Allelic heterogeneity(等位基因异质)...
  • 2016华侨大学计算机科学与技术操作系统名词解释名词解释一、 第一章 操作系统引论1. 操作系统:操作系统是一组能有效地组织和管理计算机硬件和软件资源,合理的对各类作业进行调度,以及方便用户使用的程序的集合。...
  • LabVIEW(七):多态VI

    千次阅读 2018-09-25 08:45:00
    一般一个VI调用个实例VI,简而言之:一个多态VI就是个实例VI的封装和组合。 2、适用场合:实现一种功能,这种功能要应用到几种不同的数据类型,为了使用方便,最好不要建立一组不同的VI,这样在使用前,还要...
  • 油田开发名词解释

    2015-05-27 08:35:45
    油田开发工程名词解释,方便日常工作中的利用
  • 软件工程名词解释

    千次阅读 2020-08-06 11:26:23
    94、模块 答案:模块在程序中是数据说明、可执行语句等程序对象的集合,或者是单独命名和 编址的元素 95、多态性 答案:指相同的操作或函数、过程可作用于多种类型的对象上并获得不同结果。不同的对象,收 到同一...
  • 操作系统名词解释

    千次阅读 2020-08-09 18:15:31
    3、管和目 :管下可执行所有机器指令。目只能执行非特权指令。 4、操作控制命令:操作系统提供的让联机用 户(操作员一级)表示作业执行步骤的手段。 5、进程的定义:把一个程序在一个数据集合上 的一次执行...
  • 名词解释(软件工程)

    千次阅读 2020-12-31 01:58:48
    三、名词解释1、软件:在计算机系统中,与硬件相互依存的逻辑部件,它由程序、数据及相关文档组成。2、软件工程:是指导计算机软件开发和维护的工程学科。采用工程的概念、原理、技术和方法来开发与维护软件,把经过...
  • 名词解释题1.中断 2.进程控制块 (PCB) 3.虚时钟 4.段式管理5.文件控制块 (FCB)对换 (SWAPPING) 7. 系统调用 8. 绝对路径名 9. 特别文件 10. 虚设备技术管道 12. 中断接收 13. 恢复现场 14. 页式管理 15. 作业步字符...
  • 微内核将内核中最基本的功能保留在内核,而将那些不需要在核心执行的功能移到用户去执行,从而降低了内核的设计复杂,而那些移出内核的操作系统代码根据分层的原则被划分成若干服务程序,它们的执行相互独立...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,649
精华内容 3,859
关键字:

多态性名词解释