精华内容
下载资源
问答
  • 多态性的分类
    2015-05-16 10:21:43
    1、多态的类型
    四种:重载多态强制多态参数多态包含多态
    	前面两种为专用多态。普通函数和类成员函数的重载,属于重载多态。再如整形变量和浮点变量相加,整形会转换为浮点进行运算,这就是强制多态。
    	后面两种为参数多态。如模板类型参数化就是参数多态。包含多态一般通过虚函数实现。
     
    2、多态实现
    	编译时多态:编译时确定具体调用哪个函数。即 静态绑定、(重载,强制,参数多态都是静态绑定)
    	运行时多态:运行过程中动态确定。 动态绑定(包含多态)
    更多相关内容
  • (一)多态性  多态是指同样的消息被不同的对象接收时导致不同的行为。所谓消息是指对类成员函数的调用,不同的行为是指的不同的实现,也就是调用了不同的函数。 1)多态的分类  广义上说,多态性是指一段程序能够...
  • 单核苷酸多态性(single nucleotide polymorphism,SNPs),即在基因组水平上由单个核苷酸的变异而引起的DNA序列多态性变化,具体是指在DNA序列中的单个碱基的变异,其是人类基因组变异种最常见的一种。SNP研究最主要的...
  • 行业分类-设备装置-核酸试纸条法检测ERCC1第118位密码子位点多态性.zip
  • 用从 100 个 10mers 随机引物中筛选出的 13 个具有特异多态性引物对黑子南瓜种质资源遗传多态性进行了 RAPD(Random amplified polymorphic DNA)分析。结果表明,RAPD 对中国南瓜种、印度南瓜种、美洲南瓜种及黑子...
  • 行业分类-设备装置-所连家庭的无线传感器网络中处理不同类型生活方式和生活安全业务的多态性和优先级反转.zip
  • java基础~多态性

    千次阅读 2022-01-20 21:06:45
    多态性引入 多态性下关于方法的调用 多态使用注意事项 关键字instanceof和类型转换 instanceof关键字 类型转换 关键字static 使用static修饰属性 使用static修饰方法 static关键字使用注意点 代码块 静态...

    目录

    多态性引入

    多态性下关于方法的调用

    多态使用注意事项

    关键字instanceof和类型转换

    instanceof关键字

    类型转换

    关键字static

    使用static修饰属性

    使用static修饰方法

    static关键字使用注意点

    代码块

    静态代码块

    非静态代码块

    代码块与构造器执行的优先级

    对属性赋值的优先级

    抽象类(关键字abstract)

    abstract修饰类:抽象类

    修饰方法:抽象方法

    abstract使用上的注意点

    接口(inferface)

    接口的使用(代码实现)

    接口使用注意点

    接口的作用

    抽象类与接口

    内部类

    成员内部类

    静态内部类

    局部内部类


    多态性引入

    动态编译:对象的类型只有在程序执行的时候才能确定,通过多态可以让对象的可扩展性更强。

    正常情况下,一个对象的实际类型是确定的,new 啥就是啥数据类型;例:

      Student s1 = new Student();

    但是可以指向的引用类型就不确定了;例:

     Person s2 = new Student();
     Object s3 = new Student();

    这叫父类的引用指向子类的类型,也就是父类的引用指向子类的对象。

    编译时类型由声明 该变量时使用的类型决定 (声明为左边Person类类型),运行时类型由实际赋给该变量的对象决定(实际赋给该变量的对象类型是右边Student类类型) 。若编译时类型和运行不一致 ,就出现了对象的多态性 (Polymorphism)

    多态性:即同一方法可以根据发送对象的不同而采用多种不同行为方式

    多态性下关于方法的调用

    多态性下关于方法的调用又叫虚拟方法调用。

    拿Student类和Person类来说,Person类是父类,Student类是子类,子类继承父类的全部方法。

      Student s1 = new Student();
      Person s2 = new Student();
      Object s3 = new Student();

    对象s1的类型是Student,对象s2的类型是Student,但Person类de引用指向对象s2,对象s3的类型是Student,但Object类的引用指向对象s3。

    如果Student类中有run方法:

      public class Person {
          public void run(){
              System.out.println("people run");
          }
      }

    在测试类中执行

      s2.run();

    因为Student类是子类,它继承了Person类的全部方法,所以执行s2对象的run方法的时候会打印people run。

    然后子类Student类对父类中的run方法进行重写,并且在子类Student类中声明eat()方法:

      public class Student  extends Person {
          public void run(){
              System.out.println("student run");
          }
          public void eat(){
              System.out.println("student eat");
          }
      }

    那么在测试类中执行

     //s2的类型是Person类,子类重写了父类的方法,执行子类的方       法。打印student run
      s2.run();
      //s1的类型是子类,执行自己重写父类的方法,打印student run
      s1.run();
      //s1的类型是子类,子类执行自己的特有方法,打印student eat
      s1.eat();
      //s2的类型是Person类,没有eat方法,会报错。
      s2.eat();

    总结:

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

    对象能执行的方法主要看new对象的时等号左边的类型,和右边关系不大,子类对象类型能调用的方法有1.子类自己的方法2.继承到父类的方法。父类对象类型能调用的方法有1,父类自己的方法。如果父类对象类型想要调用子类的方法,就必须强制转换类型。例:

     ((Student)s2).eat();

    多态使用注意事项

    1. 多态性的使用前提:

    • 左边声明的类和右边实际赋值的类具有继承关系,也就是父类引用指向子类对象。

    • 子类和父类中必须有重写的方法

         2.对象的多态性的适用范围:

    • 只适用于方法,不适用于属性(编译和运行都看左边)

    关键字instanceof和类型转换

    向下转型的的使用:

    有了对象的多态性以后,内存中实际上是加载了子类特有的属性和方法的,但是由于变量声明为父类类型,导致编译时,只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。 如何才能调用子类特有的属性和方法?向下转型:使用强制类型转换符。

    instanceof关键字

    a instanceof A:判断对象a是否是类A的实例。如果是,返回true;如果不是,返回false。如果a与A不存在父子关系,则编译不通过

    使用情境:为了避免在向下转型时出现ClassCastException的异常,我们在向下转型之前,先进行instanceof的判断,一旦返回true,就进行向下转型。如果返回false,不进行向下转型。

    如果,类B是类A的父类。

    a instanceof A返回true,则 a instanceof B也返回true.

    类型转换

    数据类型转换

    byte(8位),short(16位),char(16位),int(32位),long(64位),float(32位),double(64位)

    强制转换:从高到底

    自动转换:从低到高

    类型之间的转换

    父类代表高,子类代表低

    强制转换:从父类到子类

    自动转换:从子类到父类

    父类Person类:

      public class Person {
         
      }

    子类Student类:

      public class Student  extends Person {
       
          public void go(){
              System.out.println("student go");
          }
      }

    测试类:

     Person student = new Student();
       student.go();//报错

    我们只有把student对象转换为Student类型,我们才可以使用student对象中Student类型的方法。

      
       Person student = new Student();
       //进行强制转换
       Student student1 = (Student)student;
       student1.go();
       //另一种写法
       ((Student)student).go();

    关键字static

    static:静态的

    static关键字的引入

    当我们编写一个类时,其实就是在描述其对象的属性和行为,而并没有产生实质上的对象,只有通过new关键字才会产生出对象,这时系统才会分配内存空间给对象,其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下,某些特定的数据在内存空间里只有一份,例如所有的中国人都有个国家名称,每一个中国人都共享这个国家名称,不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

    使用static修饰属性

    属性按照是否使用static修饰,可分为:静态属性( 类变量)和非静态属性(实例变量)

    • 实例变量:我们创建了类的多个对象,每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时,不会导致其他对象中同样的属性值的修改。

    • 静态变量:我们创建了类的多个对象,多个对象共享同一个静态变量。当通过某一个对象修改静态变量时,会导致其他对象调用此静态变量时,是修改过了的。

    static修饰属性的其他说明:

    • 静态变量随着类的加载而加载,实例变量随着对象的创建而加载。静态变量可以通过"类.静态变量"的方式进行调用

    • 静态变量的加载要早于对象的创建,因为类的加载早于对象的创建。

    • 由于类只会加载一次,则静态变量在内存中也只会存在一份:存在方法区的静态域中。

    • 类变量(静态变量)可以用类调用,也可以用对象调用

      实例变量不可以用类调用,但是可以用对象调用。​

    使用static修饰方法

    静态方法

    • 随着类的加载而加载,可以通过"类.静态方法"的方式进行调用

    • 静态方法可以用类调用,也可以用对象调用

      非静态的方法不可以用类调用,但是可以用对象调用。

    • 静态方法中,只能调用静态的方法或属性;非静态方法中,既可以调用非静态的方法或属性,也可以调用静态的方法或属性

    static关键字使用注意点

    • 关于静态属性和静态方法的使用,大家都从生命周期的角度去理解。

    • 在静态的方法内,不能使用this关键字、super关键字

    代码块

    一个类里会有属性(变量),方法,构造器,代码块,内部类;其中前三种最常用。

    代码块可分为静态代码块和非静态代码块(匿名代码块)。

      static{
            静态代码块
      }
        
      {
            非静态代码块
      }

    静态代码块

    • 随着类的加载而执行,而且只执行一次

    • 作用:初始化类的信息

    • 如果一个类中定义了多个静态代码块,则按照声明的先后顺序执行

    • 静态代码块的执行要优先于非静态代码块的执行

    • 静态代码块内只能调用静态的属性、静态的方法,不能调用非静态的结构

    非静态代码块

    • 内部可以有输出语句

    • 随着对象的创建而执行

    • 每创建一个对象,就执行一次非静态代码块

    • 作用:可以在创建对象时,对对象的属性等进行初始化

    • 如果一个类中定义了多个非静态代码块,则按照声明的先后顺序执行

    • 非静态代码块内可以调用静态的属性、静态的方法,或非静态的属性、非静态的方法

    代码块与构造器执行的优先级

     //总结:由父及子,静态先行
        class Root{
            static{
                System.out.println("Root的静态初始化块");
            }
            {
                System.out.println("Root的普通初始化块");
            }
            public Root(){
                //找父类Objcet
                super();
                System.out.println("Root的无参数的构造器");
            }
        }
        class Mid extends Root{
            static{
                System.out.println("Mid的静态初始化块");
            }
            {
                System.out.println("Mid的普通初始化块");
            }
            public Mid(){
                //通过super调用父类中无参数的构造器
                super();
                System.out.println("Mid的无参数的构造器");
            }
            public Mid(String msg){
                //通过this调用同一类中重载的构造器
                this();
                System.out.println("Mid的带参数构造器,其参数值:" + msg);
            }
        }
        class Leaf extends Mid{
            static{
                System.out.println("Leaf的静态初始化块");
            }
            {
                System.out.println("Leaf的普通初始化块");
            }   
            public Leaf(){
                //通过super调用父类中有一个字符串参数的构造器
                super("尚硅谷");
                System.out.println("Leaf的构造器");
            }
        }
        public class LeafTest{
            public static void main(String[] args){
                new Leaf(); //先找Lesf类的构造器
                System.out.println();
                new Leaf();//因为静态代码块随着类的加载而执行,而且只执行一次,所以第二次执行new Leaf()的时候不会再执行静态方法块
            }
        }
        •
        Root的静态初始化块
        Mid的静态初始化块
        Leaf的静态初始化块
        Root的普通初始化块
        Root的无参数的构造器
        Mid的普通初始化块
        Mid的无参数的构造器
        Mid的带参数构造器,其参数值:我是参数值
        Leaf的普通初始化块
        Leaf的构造器
        •
        Root的普通初始化块
        Root的无参数的构造器
        Mid的普通初始化块
        Mid的无参数的构造器
        Mid的带参数构造器,其参数值:我是参数值
        Leaf的普通初始化块

    对属性赋值的优先级

    对属性可以赋值的位置:

    ①默认初始化

    ②显式初始化/在代码块中赋值

    ③构造器中初始化

    ④有了对象以后,可以通过"对象.属性"或"对象.方法"的方式,进行赋值

    具体代码实现参考java基础~面向对象之封装~构造器

    抽象类(关键字abstract)

    abstract可以用来修饰的结构:类、方法

    abstract修饰类:抽象类

    • 此类不能实例化,就是不能拿抽象类new对象。

    • 抽象类中一定有构造器,用abstract修饰的类不能再实例化,但是它的子类如果没有拿abstract修饰的子类可以实例化,所有抽象类的构造器是便于子类实例化时调用(涉及:子类对象实例化的全过程)

    • 开发中,都会提供抽象类的子类,让子类对象实例化,完成相关的操作

    • 抽象类的所有方法,继承了父类的子类都必须向要实现(重写)父类的方法,除非它的子类也是抽象类(用abstract修饰的类),那就让它子类的子类去实现它的方法。

    • 如果一个类中有抽象方法,那么这个方法所在类一定得是抽象类。

    • 抽象类中可以写普通的方法。

    修饰方法:抽象方法

    • 抽象方法只有方法的声明,没有方法体

    • 包含抽象方法的类,一定是一个抽象类。反之,抽象类中可以没有抽象方法的。

    • 如果父类是抽象类,并且有抽象方法,子类去继承父类的时候,要么把子类也设置成抽象类,要么重写父类中所有的抽象方法。

    • 若子类重写了父类中的所有的抽象方法后,此子类方可实例化。

      若子类没有重写父类中的所有的抽象方法,则此子类也是一个抽象类,需要使用abstract修饰。

    abstract使用上的注意点

    1. abstract不能用来修饰:属性、构造器,代码块等结构

    2. abstract不能用来修饰私有方法、静态方法、final的方法、final的类

    接口(inferface)

    接口的引入:

    一方面,有时必须从几个类中派生出一个子类,继承它们所有的属性和方法。但是,Java不支持多重继承。有了接口,就可以得到多重继承的效果。

    另一方面,有时必须从几个类中抽取出一些共同的行为特征,而它们之间又没有子父类的关系,仅仅是具有相同的行为特征而已。例如:鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。

    又如运动员类可以有篮球运动员子类和跨栏运动员子类,学生类可以有大学生子类和中学生子类,但是跨栏运动员和大学生可能都有跨栏的行为。

    接口就是规范,定义的是一组规则,体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的关系,而接口实现则是"能不能"的关系。

    接口的本质是契约,标准,规范,就像我们的法律一样。制定好后大家都要遵守。

    接口的使用(代码实现)

    TimeService接口:

      public interface TimeService {
          void timer();
      }

    UserService接口:

      public interface UserService {
          //interface定义的关键字:接口都需要实现类
          //接口中的所有定义的方法其实都是抽象的 public abstract
          //接口中定义的属性都是常量,public static final
          //只是定义了四个方法增删改查,但是没有实现,接口都需要实现类,实现类的类名一般用Impl结尾
      ​
          void add(String name);
          void delete(String name);
          void update(String name);
          void query(String name);
      }

    两个接口的实现类:

      //抽象类:extends 只能单继承
      //实现类  可以实现接口 implements  接口   多继承
      //实现可接口的类,就需要重新接口中的方法
      //多继承:利用接口实现多继承
      public abstract class UserServiceImpl implements UserService,TimeService{
          @Override
          public void timer() {
              
          }
      ​
          @Override
          public void add(String name) {
      ​
          }
      ​
          @Override
          public void delete(String name) {
      ​
          }
      ​
          @Override
          public void update(String name) {
      ​
          }
      ​
          @Override
          public void query(String name) {
      ​
          }
      }

    接口使用注意点

    • 接口中只是定义了方法,但是没有实现,接口都需要实现类,实现类的类名一般用Impl结尾。

    • 表面上看,接口是一种特殊的抽象类,但是类是类,接口是接口,是并列的关系。

    • 接口中所有方法都必须是抽象的。(1.8之后允许接口定义非抽象方法)

    • 接口中方法定义默认为public abstract类型,成员变量默认为public static final 类型。(如果省略,系统会默认补全)。

    接口的作用

    1.约束

    2.定义一些方法,让不同的人实现

    3.方法都是public abstract

    4.常量都是 public static final

    5.接口中没有构造方法(它都不是类)

    6.可以实现多个接口

    7.必须重写接口中的方法

    抽象类与接口

    抽象类用关键字abstract去定义,只能用extends去继承,并且是单继承。

    接口用关键字inferface去定义,子类(实现类)通过implements实现多个类,重写接口里的方法。

    抽象类:

    • 一个类中有抽象方法,这个类就变成了抽象类。

    • 抽象类中class的前面必须有abstract修饰符。

    • 抽象类中可以有普通方法,也可以有抽象方法,而抽象方法的个数可以是0个,也可以是多个。

    • 子类继承父类,必须重写全部的抽象方法,除非这个类也变成了抽象类。抽象类的所有方法,继承了父类的子类都必须向要实现(重写)父类的方法,除非它的子类也是抽象类(用abstract修饰的类),那就让它子类的子类去实现它的方法。

    接口:

    • 表面上看,接口是一种特殊的抽象类,但是类是类,接口是接口,是并列的关系。

    • 接口中所有方法都必须是抽象的。(1.8之后允许接口定义非抽象方法)

    • 接口中方法定义默认为public abstract类型,成员变量默认为public static final 类型。(如果省略,系统会默认补全)。

    • 接口中只是定义了方法,但是没有实现,接口都需要实现类,实现类的类名一般用Impl结尾。

    两者关系:

    • 相同点:抽象类和接口都不能被实例化

    • 一个类只能继承一个抽象类,而一个类可以实现多个接口。

    • 抽象类可以有构造方法,接口中不能有构造方法。

    • 抽象类中可以有成员变量,接口中没有成员变量。(被final修饰变成了常量)

    • 抽象类中可以有普通方法,接口中所有方法都必须是抽象的。(1.8后允许接口定义非抽象方法)

    • 抽象类中抽象方法的访问类型可以是public,protected,但接口中抽象方法的访问类型只能是public,并且默认为public abstract(省略则自动默认补全)。

    • 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是public static final类型的;

    • 抽象类中可以有静态代码块和静态方法,接口中不能含有静态代码块以及静态方法

    内部类

    内部类就是在一个类的内部定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对于B类来说就是外部类了。

    当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完整的结构又只为外部事物提供服务,那么整个内部的完整结构最好使用内部类。

    现有一个Person类,里面有name,age属性,我们想在Person类中加一个brain(大脑)的类,因为把brain设置成属性太简单,所以我们就把它设置成内部类,Person是外部类,brain是内部类。

    在Java中,允许一个类的定义位于另一个类的内部,前者称为内部类,后者称为外部类。

    内部类分类

    1. 成员内部类

      内部类可以访问外部类的私有属性和私有方法!!!

    2. 静态内部类

    3. 局部内部类

    4. 匿名内部类

    成员内部类

     

    public class Outer {
        private int id;
    
        public void out(){
            System.out.println("这是外部类方法");
        }
    
        class Inner{
    
            public void in(){
                System.out.println("这是内部类的方法");
            }
            //获取外部类的私有属性
            public void getID(){
            	System.out.println(id);
            }
        }
    }
    //测试
    
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = new Outer().new Inner();
        //获取外部类的私有属性
        inner.getID();
    }

    静态内部类

    public class Outer {
        private int id;
    
        public void out() {
            System.out.println("这是外部类方法");
        }
    
         static class Inner {
            public void in() {
                System.out.println("这是内部类方法");
            }
    
        }
    
    }
    //测试
    public static void main(String[] args) {
    
        Outer outer = new Outer();
        outer.out();
    
        Outer.Inner inner = new Outer.Inner();
        inner.in();
    }

     

    局部内部类

    public class Outer {
        private int id;
        public void method() {
    
            class Inner {
                public void in() {
                    System.out.println("这是局部内部类");
                }
            }
            Inner inner = new Inner();
            inner.in();
    
        }
    }
    //测试
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }

    展开全文
  • 扩增片段长度多态性(AFLP)是一种有效的分子遗传标记方法,具有快速、经济、简便、模板需要量少、重复性高、结果可靠等优点。目前AFLP在动物方面的应用还不是很多,处于初级阶段。主要用于鉴定分类关系、种群遗传...
  • 行业分类-设备装置-一个NFκB1基因插入缺失多态性位点在制备检测丙型肝炎易感性产品中的应用
  • 采用RAPD和PCR-DGGE指纹技术对转基因鱼试验湖的浮游生物群落DNA多态性进行了研究,并探讨了DNA多态性与物种组成的关系。结果显示:(1)形态学分类共鉴定到44种/类浮游生物:其中藻类13种,原生动物11种,轮虫16种,...
  • 为了研究体量子系统中量子的可分,利用Bell不等式给出了体量子可分的所有分类.这些不等式能分类2×2×2×2×2量子系统中所有可能的k-可分量子,包括全可分、双可分、三可分、四可分.利用推广的Bell...
  • C++的多态性

    千次阅读 2019-05-09 21:14:01
    多态性是面向对象编程中的重要特征之一。其是用父类型别的指针(或引用)指向其子类的实例,然后通过父类的指针调用实际子类的成员函数。这种由于调用子类的不同可以让父类的指针有“多种形态”,这是一种泛型技术...

     概述

          多态性是面向对象编程中的重要特征之一。其是用父类型别的指针(或引用)指向其子类的实例,然后通过父类的指针调用实际子类的成员函数。这种由于调用子类的不同可以让父类的指针有“多种形态”,这是一种泛型技术。

          多态实现方式:

    • 函数重载
    • 运算符重载
    • 虚函数

    多态实现

    •     多态分类

         1. 编译时多态(静态联编)

             : 通过函数重载 和 运算符重载实现。

         2. 运行时多态(动态联编)

             : 通过类的继承关系 和 虚函数实现。

         联编:也称绑定,这里是指计算机程序自身彼此关联的过程,即将函数名对象关联的过程。

    •     编译时多态的实现

    函数重载

    概念

    两个函数在同一作用域,函数名相同,参数列表不同。

    表达方式

    在一个类中重载

    在不同类中重载

    基类的成员函数在派生类中重载

     

    被重载的同名函数在编译期间区分,编译器会通过:1. 根据实参类型;2. 使用类作用域限定符“::”区分;3. 根据调用函数的类对象区分

     

                  运算符重载:

    运算符重载实质上是函数重载。        

    语法: 函数类型 operator 运算符名称(参数列表){ // 重载处理 }

    说明:

    • 运算符重载中:运算符顺序和优先级不能更改,但参数和返回类型可以重载;
    • 运算符参数都是内部类型时不能重载;
    • 基本数据之间关系是确定的,若允许在其上重新定义,那么基本数据类型的内在关系将混乱;
    • C++规定::: .* ?: 4个运算符不能重载;
    •     运行时多态的实现

    实现条件:

    • 基类中必须存在虚函数,派生类必须对基类中的虚函数进行重写;

    重写:两个函数作用域不同(分别在基类和派生类),函数名相同,参数列表相同,用virtual修饰即基类一定有虚函数

    规则:

    1. 返回值类型相同;

    2. 派生类重写基类的虚函数的 关键字"virtual" 可加可以不加;

    3. 派生类虚函数必须与被重写的基类函数原型一致(返回值,函数名字,参数类型必须完全相同);

     例外:协变:基类虚函数返回基类对象的指针或者引用,派生类虚函数返回派生类对象的指针或者引用。// 仅适用于返回值,而不是参数。
                                                                    
          析构函数 :如果基类中的析构函数是虚函数,派生类虚构函数提供构成重写,且构成重写的虚函数的函数名字不同。

    4. 派生类虚函数的访问权限可以与基类虚函数的访问权限不同,基类中虚函数访问权限必须是公有的。

    • 必须通过基类指针或者引用来调用虚函数。

       虚函数的注意事项:

    • 构造函数不能虚函数。因为构造派生类对象方式不同于继承时,先调用派生类的构造函数,然后派生类的构造函数将使用基类的一个构造函数。而且虚函数调用是在部分信息下完成工作的机制,允许我们只知道接口而不知道对象的确切类型。 要创建一个对象,你需要知道对象的完整信息。 特别是,你需要知道你想要创建的确切类型。 因此,构造函数不应该被定义为虚函数。
    • 析构函数可以为虚函数,且通常声明为虚函数。将析构函数声明为虚函数保证当我们new一个子类,然后使用基类指针指向该子类对象,释放基类指针时可以释放掉子类的空间,防止内存泄漏。

     

    • 友元函数不能为虚函数。因为友元函数不是类的成员函数,因为虚函数仅适合用于有继承关系的对象;
    • 静态成员函数不能为虚函数,因为静态成员函数没有this指针,不受限与任一对象的;
    • 内联函数不能为虚函数,因为内联函数不能在运行中动态确定;
    • 如果派生类没有重写虚函数,则将使用该函数的基类版本。如果派生类在一条派生链中,则使用最新虚函数版本;
    • 派生类被重写的方法,不仅隐藏参数列表相同的同名基类方法,而且隐藏参数列表不相同的同名基类方法;

          纯虚函数与抽象类:

      纯虚函数

    语法:virtual 函数返回值 函数名(参数列表)= 0; 

    说明:

    • 声明为纯虚函数,基类中就不能在给出函数实现部分
    • C++中有一种情况:空的虚函数,空的虚函数指函数体为空,而纯虚函数压根没有函数体,有着本质区别;
    • 纯虚函数必须在派生类中重写,否则这个函数就没有存在意义。

      抽象类:

    概念:含有纯虚函数的类称为抽象类。

    作用: 抽象类是不能实例化对象的,它是为了组织一个继承的层次结构专门为派生类提供基本类型和接口函数的基类。

    所以说抽象类也被称为抽象基类,且必须被继承,否则没有存在意义。

    •     多态调用原理

         在这插入一个例子:

    #include <iostream>
    
    using namespace std;
    
    class Base{
    	virtual void Func1()
    	{}
    
    private:
    	int _val;
    };
    
    int main()
    {
    	Base b;
    	cout << sizeof(b) << endl;
    	return 0;
    }

        这调用监视窗口查看测试代码的结果:

       按我们所理解的,类中只有一个整型变量,应该占4字节,也就是说多了4个字节。

       我们再查看我们所构建的对象就能清楚明白:

       这是多存了一个指针_vfptr,这个指针所指向的是一个叫虚函数表(vtable)的东西。

       虚表的结构可以查看相关博客:https://blog.csdn.net/timecur/article/details/95981159

        派生类虚表构造过程:

    1. 先将基类虚表中虚函数拷贝一份到派生类虚表中;

    2. 如果派生类重写了基类中的虚函数,用派生类自己的虚函数替换(覆盖)相同偏移量位置同名的虚函数。

    3. 将派生类新增加的虚函数按照其在类中声明次序添加到派生类虚表的最后。

    重载

    两个函数在同一作用域,函数名相同,参数列表不同

    重写(覆盖)

    两个函数作用域不同(分别在基类和派生类),函数名相同,参数列表相同,用virtual修饰

    重定义(同名隐藏)

    1.如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual

    关键字,基类的函数将被隐藏(注意别与重载混淆)。

    2.如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual

    关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。

        总结多态的调用步骤:

    1. 从指针或引用的具体的对象中取虚表的地址;

    2. 传递this指针;

    3. 从虚表中取虚指针;

    4. 调用该虚函数。

    C++11 override 和 final

    override 和 final 来修饰虚函数。

    overrid修饰虚函数,表示要强制重写虚函数,因为虚函数的意义就是实现多态,如果没有重写,虚函数就没有意义。 ---可以防止写错虚函数的函数名。

    final修饰虚函数,表示最终虚函数,之后不能再被重写。

     

    展开全文
  • 经典编程C++之多态性

    2011-06-16 10:54:53
    对C++语言的多态性进行详细分析与讲解,并具体分析,内容由浅入深,适合初学者
  • 将设备运行状态划分为三种状态,比以往的两模型对于设备的故障分类具有更高的准确。在设备运行状态三划分的基础上,提出了新的三模型,将设备运行状态定义为故障、准故障、健康三种状态,其中准故障...
  • SNP(单核苷酸多态性)准确性的验证,你造吗? 【2016-12-12】 SNP(全称Single Nucleotide Polymorphisms)即单核苷酸多态性,主要是指在基因组水平上由单个核苷酸的变异引起的DNA序列多态性,包括...

    SNP(单核苷酸多态性)准确性的验证,你造吗?

    【2016-12-12】
     
     
     

    SNP(全称Single Nucleotide Polymorphisms)即单核苷酸多态性,主要是指在基因组水平上由单个核苷酸的变异引起的DNA序列多态性,包括单个碱基的转换、颠换等。SNP定位分类:可分为基因编码区、基因周边以及基因间SNP等三类;SNP位置区域包括UTR区、编码区的外显子或内含子区 、可变剪切位点等等。

    SNP是人类可遗传变异中最常见的一种,占所有已知多态性的90%以上,所以SNP的应用范围较微卫星标记更加广泛,在群体遗传学、生态环境学、制药业、法医学、癌症及遗传性疾病甚至进化方面的研究都有不同程度的应用。研究人员希望通过SNP的研究,更深刻地认识癌症、糖尿病、血管性疾病和某些精神性疾病等多基因疾病的发生机制,主要应用有:

    1、确定基因多态性和疾病的关系   

    2、解释个体间的表型差异对疾病的易感程度 

    3、对未来疾病做出诊断 

    4、研究不同基因型个体对药物反应的差异,指导药物开发及临床合理用药 

    5、个体间SNP千差万别,通过SNP检测等技术进行法医鉴定及个体识别

     

    SNP的研究前期通常基于下一代测序(NGS)技术对大量样本进行全基因组测序,通过与参考序列的比对发现并构建SNP数据库,之后对数据库中大量的SNP进行验证,并经过统计学分析找到少量与疾病或性状关联的SNPs。目前对SNP进行验证检测的方法主要有:

     

    1、 扩增测序

        原理:Sanger测序

        特点:方法稳定,可靠,通量低,成本高

     

     

    2、SNaPshot 检测

        原理:基于荧光标记单碱基延伸原理的分型技术,也称小测序。在体系中加入测序酶,四种荧光标记的ddNTP,紧挨多态位点5,端的延伸引物和PCR产物模板,PCR扩增过程中,引物延伸一个碱基即终止,经ABI测序仪电泳后,根据峰的颜色可知掺入的碱基种类,从而确定该样本的基因型,根据峰移动的位置确定该延伸产物对应的SNP位点。


        特点:

    a)采用多重单碱基检测技术,每次可以检测10~20个位点,通量高,速度快;

    b)同时检测基因组任何位置上的SNP位点,且数据完整性高;

    c)基于3730xl测序仪平台的检测技术,直接得到位点的碱基组成,检测结果直观、稳定、可靠;

    d)价格比较低廉。

     

    3、Mass Array

        原理:该技术基于Sequenom质谱仪平台,通过PCR扩增出含有SNP位点的一段DNA(SNP位点前后各50bp左右),用SAP酶去除掉PCR 体系中剩余的脱氧核糖核苷三磷酸(dNTP),加入一单碱基延伸引物,其3’末端碱基紧挨SNP位点,采用四种ddNTP替代dNTP,这样,探针在SNP位点处仅延伸一个碱基,连接上的ddNTP与SNP位点的等位基因对应,树脂交换,纯化延伸后产物,用基质辅助激光解析电离飞行时间质谱(MALDI-TOF MS)检测延伸产物与未延伸引物间的分子量差异,确定该点处碱基。

     

        特点:

    a) 一次可以检测20-40个位点;通量高,一次可以检测384个样本;

    b) 1管式操作,避免换管,降低被污染的概率;

    c)检测灵敏,可检测pmol级别的物质;

    d)适合大量样本检测,但是有一些SNP位点不适合设计延伸引物,无法检测,且缺失的数据难以补充。

     

     

    4、Taqman探针法

        原理:该技术基于实时荧光定量平台,每个SNP位点设计一对Taqman探针,分别标记不同的荧光。5’末端携有报告荧光基团,3’端标有荧光淬灭基团,Taq聚合酶具有外切活性,从而将探针5 ’端连接的荧光分子从探针上切割下来,破坏两荧光分子间的PRET,发出荧光。


        特点:
    a)操作简单、检测速度快、灵敏度高;
    b)一次一般检测1个位点,两个SNP位点之间太近或者SNP序列附近有特殊结构,不易设计探针;
    c)少量样本检测费用高,适合位点少,样本量大的情况。

     

     

    除了上述几种方法,还有焦磷酸测序、HRM(高分辨率溶解曲线分析技术)、Microarray芯片法、MALDI-Tof、dHPLC(变性高效液相色谱技术)、RFLP、SSCP、DGGE等。

     

    阅微基因在SNP检测方面有丰富的经验,开展多种不同的检测方法,可根据客户的样本和位点的数量选择最合适的实验方法。每个项目的检出率不低于95%。针对有特殊结果的位点,我们会采用高效的DNA聚合酶,确保每个位点都有实验结果,进一步确保了客户数据的完整性。另外,阅微基因可以针对口腔拭子,唾液等样本提取DNA进行SNP检测分析。在此基础上提供基因分型分析、关联分析、聚类分析、遗传图谱等服务,使客户的研究更顺利。

    转载于:https://www.cnblogs.com/wangprince2017/p/9815384.html

    展开全文
  • 近年来,恶意软件呈现出爆发式增长势头,新型恶意样本携带变异性和多态性,通过多态、加壳、混淆等方式规避传统恶意代码检测方法。基于大规模恶意样本,设计了一种安全、高效的恶意软件分类的方法,通过提取可执行...
  • java线程安全基础介绍 线程安全 正确 什么是线程安全 原子条件 i++ 读i ++ 值写回i 可见 JMM 由于cpu和内存加载速度的差距,在两者之间增加了多级缓存导致,内存并不能直接对cpu可见。 ...
  • 多态(Polymorphism),在面向对象语言中指的是同一个接口可以有多种不同的实现方式,OC中的多态则是不同对象对同一消息的不同响应方式,子类通过重写父类的方法来改变同一消息的实现,体现多态性。另外我们知道C++...
  • 采用随机扩增多态性DNA(RAPD)标记,筛选出69个随机引物对32份草地早熟禾品种遗传谱带进行分析,46个引物共扩增出了197条扩增片断,其中多态性带数为195条,每个引物扩增出1~9条多态性带,平均每条引物扩增出4.3条...
  • C++多态性与虚函数

    千次阅读 2012-04-12 21:49:47
    C++多态性与虚函数 本讲基本要求  * 掌握:多态性的概念;虚函数的定义及应用。  * 理解:对象与类函数的静态关联与动态关联。  重点、难点: :多态性的概念;虚函数的定义及应用。 一、多态性的概念 ...
  • 本文概述了随机扩增多态性DNA(RAPD)技术的技术基础,分析了PAPD简便快捷、费用低、灵敏度高、对模板纯度要求不高、能充分反映模板的多态性等技术优势;同时指出了该技术稳定性和可重复性差、不能对纯合体杂合体加以...
  • 什么是无序多分类?举一个例子,当我们要研究基因突变与疾病之间的关系时,因变量就是疾病的各种分类,如乳癌、胃癌、鳞癌等多种,此时因变量不是简单的患病和不患病,且他们之间是无序的,这就是无序多分类。 当...
  • 木霉是一类常见的生防真菌,具有重要的...本文综述了包括随机扩增多态性 DNA( RAPD)、通用引物 PCR( UP-PCR)、 扩增片段长度多态性( AFLP)、ITS序列分析等在内的多种分子生物学技术在木霉鉴定与多样性分析中的应 用;此
  • (4)提交博文,记录实验过程和结果,用自己的话回答上面提出的问题,概括你对虚函数、多态性和抽象类的理解。——不要忽视回答问题,写出来,你会更明白。 2、阅读下面的程序,并写出运行结果 (1) #include ...
  • 特别是,我们对所有包含守恒电流或自由场的多重进行分类和构造,这些多重在超共形场论(SCFT)中起着重要作用。 保形场理论中允许的某些电流不能嵌入超保形多重峰中,因此在SCFT中是不存在的。 我们使用超共形...
  • Bert讲解+基于Bert的情感多分类任务(超高精度)

    千次阅读 热门讨论 2021-12-21 11:14:58
    基于Bert实现的情感分类任务,包含对于Bert原文的讲解和介绍,其实任务2分类99+精度一直到5分类仍有97+精度
  • 分类器解决多分类问题

    千次阅读 2019-05-14 16:38:20
    两种思路: 以SVM为例 1.one-versus-rest 思想: 假设一共有1,2,3,4,5个类别的数据 ...在预测阶段,对于输入的待分类样本,分别从第一个分类器开始询问是否属于该类别,该分类器“承认”,就将该样本...
  • C#之简单工厂模式与多态性

    千次阅读 热门讨论 2014-01-27 16:06:36
    最近看简单工厂模式,视频中只是简单的讲了讲,于是自己又上网查了一下,有了一个初步的了解,它和多态性有着密切的关系,它是通过建立一个父类,通过派生出不同的子类来产生不同的功能,再根据主程序中所指定的实例...
  • 阐述了真菌分类的传统分类方法和几种分子生物学方法,传统分类学主要以形态学为...分子生物学方法主要有DNA中G+C含量测定、核酸杂交技术、限制性酶切片段长度多态性分析、随机扩增多态性DNA(RAPD)、rDNA序列同源性分析。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 57,271
精华内容 22,908
关键字:

多态性的分类