1. factory机制

顾名思义，factory机制（工厂机制），最大的优点是根据字符串（类名），创建该类的实例，比如下面的一个类：class my_driver extends uvm_driver;当使用factory机制时就可以根据字符串“my_driver”创建属于类my_driver的一个实例。还有另一种解释是factory机制本质上是对new函数的重载，从某种意义上也确实是这么回事。实现factory机制需要将类（严谨一点的话与这个类相关的uvm_object_registry或者uvm_component_registry）注册到factory中，通常会调用UVM自带的宏注册。

宏注册主要是`uvm_object_utiles(T)，  `uvm_object_param_utils(T)，`uvm_component_utiles(T)，  `uvm_component_param_utils(T)四个宏，在使用UVM的过程中原则上对所有的class均需要进行factory注册。

在上面我们有讲到，严格意义上向factory中注册的是与类T相关的uvm_object_registery#（）或者uvm_component_registery#（）的代理类。这两个类均继承与uvm_object_wrapper，这个类是一个virtual class。这里面有3个virtual 方法，create_object，create_component，get_type_name。在两个继承类中需要进行重载，同时这两个继承类会新建方法create，set_type_overvide, set_inst_override,get。这些方法均为static，我们在使用override的时候除了调用component自身的override方法之外，还可以使用::type_id::*的方法实现，当然这种使用方法很少见，一般不会这么费事的使用，毕竟UVM已经给我们封装好了。下面我们讲解一下其中的一个宏注册，`uvm_object_utiles(T)。

class T extends uvm_object;
`uvm_object_utils(T)
endclass
下面我们将宏所表示的代码全部展开
class T extends uvm_object;

   typedef uvm_object_registry#(T,"T") type_id; 
   static function type_id get_type(); 
     return type_id::get(); 
   endfunction 
   virtual function uvm_object_wrapper get_object_type(); 
     return type_id::get(); 
   endfunction
   
   function uvm_object create (string name=""); 
     T tmp; 
     `ifdef UVM_OBJECT_DO_NOT_NEED_CONSTRUCTOR 
     tmp = new(); 
     if (name!="") 
       tmp.set_name(name); 
     `else 
     if (name=="") tmp = new(); 
     else tmp = new(name); 
     `endif 
     return tmp; 
   endfunction
   
   const static string type_name = "T"; 
   virtual function string get_type_name (); 
     return type_name; 
   endfunction 
   
   function void __m_uvm_field_automation (uvm_object tmp_data__, 
                                     int what__, 
                                     string str__); 
   begin 
     T local_data__; /* Used for copy and compare */ 
     typedef T ___local_type____; 
     string string_aa_key; /* Used for associative array lookups */ 
     uvm_object __current_scopes[$]; 
     if(what__ inside {UVM_SETINT,UVM_SETSTR,UVM_SETOBJ}) begin 
        if(__m_uvm_status_container.m_do_cycle_check(this)) begin 
            return; 
        end 
        else 
            __current_scopes=__m_uvm_status_container.m_uvm_cycle_scopes; 
     end 
     super.__m_uvm_field_automation(tmp_data__, what__, str__); 
     /* Type is verified by uvm_object::compare() */ 
     if(tmp_data__ != null) 
       /* Allow objects in same hierarchy to be copied/compared */ 
       if(!$cast(local_data__, tmp_data__)) return;
	   
	end 
   endfunction 
   
endclass

 现在是不是一目了然了，在使用的过程中T::tyepe_id::create::就是来自这里。其中tyep_id是类T的一个成员变量，create是uvm_object_regisrty#（T，”T”）的static方法。

那么是怎么实现向factory注册呢，在uvm_object_registry中有一个静态变量me，利用静态方法get向factory中注册，通过调用factory的register方法实现注册。最终会在factory的m_type_names和m_type两个联合数据中注册记录。注意不要尝试对同一个类进行多次注册，如果出现的话factory会提示已经注册了（以warning的报告出现），当然了一般也没有人会这么干。

1. override机制

其实我们会发现UVM之所以实现factory机制，本质是为了实现平台代码最大的复用性，最主要的用法都集中在override机制方面，下面将会讲解一下override机制。

Override机制是factory机制优势最大的体现

Set_type_override_by_type(initial_type,override_type bit replease=1):

主要作用，在队列m_type_override[$]中放入override信息。比如base_type->ov1_type，base_type->ov2_type。首次调用的话ov1-type override了base_type。如果第二次再调用ov2_type  override base，如果参数replease=1(默认参数)，那么最终base_type由ov2_type 覆盖。如果参数replease=1，则覆盖失败。

set-type_override_by_name(initial_type_name,override_type_name bit replease=1):

主要作用：在队列m_type_override[$]中放入override信息。比如base_type->ov1_type，base_type->ov2_type。首次调用的话ov1-type override了base_type。如果第二次再调用ov2_type  override base，如果参数replease=1(默认参数)，那么最终base_type由ov2_type 覆盖。如果参数replease=1，则覆盖失败。注意这个函数传入的参数是类名字符串，不是类型。这个方法会根据传入的类名字符串去m_type_name[$]联合数组中寻找与这个类关联的代理类，然后获得代理类，接着执行与Set_type_override_by_type相同的操作。在这个override操作中海油一个要注意的是如果传入的initial_type_name在m_type_name[$]没有找到代理类，那么会在联合数组m_lookup_strs[string]中做出标记

Set_inst_override_by_type(initial_type,override_type full_inst_path):

这个是路径替换，特定UVM路径下类的替换，联合数组uvm_factory_queue_class m_inst_override_queues[uvm_object_wrapper],这种类型inst的特换没有replease的概念，但是又路径的概念，所以出现了uvm_factory_queue_class（就是一个queue，存放的是override信息，不同元素的区别在于不同的路径，同一个路径不会多次override（会先判断））

set_inst_override_by_name(initial_type_name,override_type_name full_inst_path):

也是路径特换，有3个重要的变量   uvm_factory_queue_class m_inst_override_queues[uvm_object_wrapper]    ，m_wildcard_inst_overrides[$],uvm_factory_queue_class m_inst_override_name_queues[string]

如果传入的参数string完整，则在m_inst_override_queues插入记录

如果传入的参数string不完整，但是又通配符，则在m_wildcard_inst_overrides[$]插入记录，同时通配符还匹配完成字符串，同时在m_inst_override_queues插入记录

如果传入的参数及不完整，有没有通配符，则在m_inst_override_name_queues插入记录

所有与override相关的队列或者联合数组均会在使用factory机制创建时被使用（遍历使用）

find_override_by_type(request_type,full_inst_path)

主要作用：在create_object_by_type和create_component_by_type中被调用，寻找真正要创建的对象的类型。如果是之前type_override的话，直接遍历m_type_override[$]（比如base_type->ov1_type,传进来的是base_type的代理类类型，发现m_type_override[$]中存在ov1_type覆盖base_type的情况，那么再次调用Find_override_by_type(request_type,full_inst_path)，只是传输的是ov1_type的代理类类型，发现m_type_override[$]不存在ov1_type的覆盖，返回ov1_type的代理类型如果base_type->ov1_type->ov2_type。那么最终返回的是ov2_type。以此类推）

如果是之前inst_override的话，直接遍历m_inst_override_queus联合数组，找到init_type类型的元素，下面对这个元素的queue中的path进行匹配base_type->ov1_type（带path），匹配上的话，载次调用Find_override_by_type(request_type,full_inst_path)，只是传输的是ov1_type的代理类类型，发现m_inst_override_queus没有匹配的，最终返回ov1_type。如果base_type->ov1_type->ov2_type。那么最终返回的是ov2_type。以此类推。注意一定要path匹配。

find_override_by_name(request_type-name,full_inst_path)

这个方法和上面的方法相似，内部还会调用Find_override_by_type。主要是根据参数request_type-name获取类型。如果是type_override。遍历m_type_override[$]寻找。如果是inst_override,根据参数request_type-name，会在与inst overroide相关的联合数组或者队列中查看是否可以寻找到，寻找到的话（匹配上的话，调用Find_override_by_type）。如果之中找到name匹配的地方，返回null

1. factory机制对象的创建

下面是怎么使用factory创建对象的：

Create_object_by_type(request_type,parent_inst_path,name)

调用find_override_by_type->create_object

Create_object_by_type(request_type_name,parent_inst_path,name)

调用find_override_by_name->create_object。如果find_override_by_name返回null，没有override或者没有找到override的匹配信息。这个实在在m_type_name中看看是否注册是，没有的话番薯直接返回null（没有注册的话当然不能使用factory机制创建）

Create_object_by_type(request_type,parent_inst_path,name，parent)

调用find_override_by_type->create_object

Create_object_by_type(request_type_name,parent_inst_path,name，parent)

调用find_override_by_name->create_object。如果find_override_by_name返回null，没有override或者没有找到override的匹配信息。这个实在在m_type_name中看看是否注册是，没有的话番薯直接返回null（没有注册的话当然不能使用factory机制创建）

@Override是JDK自带的注解，表示方法的重写

具体报错行为，可能会表现为@Override飘红，或者编译时发出警告Error:java: 无效的标记: -parameters

1  此时应检查pom文件的标签有没有提示爆红

2  并检查编译版本是否太低导致的，只需要在pom文件中指定编译的版本是1.8即可。

3 检查IDEA的moudles

重载、重写、覆写，分别指的是overload、override、new。

一、override重写，是在子类中重写父类中的方法，两个函数的函数特征（函数名、参数类型与个数）相同。用于扩展或修改继承的方法、属性、索引器或事件的抽象或虚拟实现。提供从基类继承的成员的新实现，而通过override声明重写的方法称为基方法。
注意事项：
1.重写基方法必须具有与override方法相同的签名。
2.override声明不能更改virtual方法的可访问性，且override方法与virtual方法必须具有相同级别访问修饰符。
3.不能用new、static、virtual修饰符修改override方法。
4.重写属性声明必须指定与继承的属性完全相同的访问修饰符、类型和名称。
5.重写的属性必须是virtual、abstract或override。
6.不能重写非虚方法或静态方法。
7.父类中有abstract，那么子类同名方法必定有override，若父类中有 virtual方法，子类同名方法不一定是override，可能是overload。
8.override必定有父子类关系。

二、overload重载，在同一个类中方法名相同、参数或返回值不同的多个方法即为方法重载。
注意事项：
1.出现在同一个类中。
2.参数列表不同或返回类型和参数列表都不同，只有返回类型不同不能重载。(参数列表包括参数个数和参数类型)

三、overwrite覆写，用new实现。在子类中用 new 关键字修饰定义的与父类中同名的方法，也称为覆盖，覆盖不会改变父类方法的功能。

示例：

class Parent
{
    public void F()
    {
        Console.WriteLine("Parent.F()");
    }
    public virtual void G() //抽象方法
    {
        Console.WriteLine("Parent.G()");
    }
    public int Add(int x, int y)
    {
        return x + y;
    }
    public float Add(float x, float y) //重载(overload)Add函数
    {
        return x + y;
    }
}
class ChildOne:Parent //子类一继承父类
{
    new public void F() //覆写(overwrite)父类函数
    {
        Console.WriteLine("ChildOne.F()"); 
    }
    public override void G() //重写(override)父类虚函数,主要实现多态
    {
        Console.WriteLine("ChildOne.G()");
    }
}
class ChildTwo:Parent //子类二继承父类
{
    new public void F()
    {
        Console.WriteLine("ChildTwo.F()");
    }
    public override void G()
    {
        Console.WriteLine("ChildTwo.G()");
    }
}
class Program
{
    static void Main(string[] args)
    {
        Parent childOne = new ChildOne();
        Parent childTwo = new ChildTwo();
        //调用Parent.F()
        childOne.F();
        childTwo.F();
        //实现多态
        childOne.G();
        childTwo.G();
        Parent load = new Parent();
        //重载(overload)
        Console.WriteLine(load.Add(1, 2));
        Console.WriteLine(load.Add(3.4f, 4.5f));
        Console.Read();
    }
}