精华内容
下载资源
问答
  • 在正式开始讲述反射之前,还是让我们先来看一下微软自己是怎么定义反射的,根据MSDN的解释:反射提供了封装程序集、模块和类型的对象(Type 类型)。可以使用反射动态创建类型的实例,将类型绑定到现有对象,或从...

     

    反射概述

    反射定义

    在正式开始讲述反射之前,还是让我们先来看一下微软自己是怎么定义反射的,根据MSDN的解释:反射提供了封装程序集、模块和类型的对象(Type 类型)。可以使用反射动态创建类型的实例,将类型绑定到现有对象,或从现有对象获取类型并调用其方法或访问其字段和属性。如果代码中使用了属性,可以利用反射对它们进行访问。说到底,反射就是一种在程序的执行期通过对程序集的类型元数据的使用动态获取其模块,类型,方法等信息的机制。

    为何需要反射

              任何一种技术的产生都有其特定的背景和使用需求,同样,反射也不例外,具体来说,我们将在下面的场景中使用到反射技术。

    ·         查看元数据,这给我们窥探程序集的内部机理提供了一种方便,很多工具也是基于此而开发的,例如ILDASMReflector

    ·         类型查看,它允许我们检查程序集中的类型并与之交互,这给我们在创建定制脚本方面提供了极大的帮助;

    ·         后期绑定,该技术通常用于解释型语言,例如脚本语言,因为其程序集中的某些类在编译期间是未知的;

    ·         运行时动态创建类型。

    反射应用

    查看元数据

                    在这里我想举一个查看自定义属性的例子(关于属性的更多内容,请参考我的另一篇文章),为此,我们得先准备一个自定义属性

    ExpandedBlockStart.gif代码
     1 using System;
     2 using System.Reflection;
     3 
     4 namespace ViewCustomProperty
     5 {
     6     class Program
     7     {
     8         static void Main(string[] args)
     9         {
    10             MemberInfo memberInfo = typeof(ClassWithCustomProperty);
    11             object[] customAttributes = memberInfo.GetCustomAttributes(typeof(BugFixAttribute), false);
    12             foreach (object obj in customAttributes)
    13             {
    14                 BugFixAttribute bugFixAttribute = obj as BugFixAttribute;
    15                 if (bugFixAttribute != null)
    16                 {
    17                     Console.WriteLine("BugID: {0}", bugFixAttribute.BugID);
    18                     Console.WriteLine("Programmer: {0}", bugFixAttribute.Programmer);
    19                     Console.WriteLine("Date: {0}", bugFixAttribute.Date);
    20                     Console.WriteLine("Comment: {0}\n", bugFixAttribute.Comment);
    21                 }
    22             }
    23             Console.ReadKey();
    24         }
    25     }
    26 
    27     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
    28     public class BugFixAttribute : System.Attribute
    29     {
    30         public BugFixAttribute(int bugID, string programmer, string date)
    31         {
    32             this.bugID = bugID;
    33             this.programmer = programmer;
    34             this.date = date;
    35         }
    36 
    37         public int BugID
    38         {
    39             get
    40             {
    41                 return bugID;
    42             }
    43         }
    44 
    45         public string Comment
    46         {
    47             get
    48             {
    49                 return comment;
    50             }
    51             set
    52             {
    53                 comment = value;
    54             }
    55         }
    56 
    57         public string Date
    58         {
    59             get
    60             {
    61                 return date;
    62             }
    63         }
    64 
    65         public string Programmer
    66         {
    67             get
    68             {
    69                 return programmer;
    70             }
    71         }
    72 
    73         private int bugID;
    74         private string comment;
    75         private string date;
    76         private string programmer;
    77     }
    78  
    79     [BugFixAttribute(66180"Chunting Pan""01/01/2010")]
    80     [BugFixAttribute(66181"Chunting Pan""12/31/2010", Comment = "Rollback the changes from previous version")]
    81     public class ClassWithCustomProperty
    82     {
    83         public void Display()
    84 
    85         {
    86             Console.WriteLine("This is a class with custom property");
    87         }
    88     }
    89 }

     

     运行的结果如下:

    BugID: 66180

    Programmer: Chunting Pan

    Date: 01/01/2010

    Comment:

     

    BugID: 66181

    Programmer: Chunting Pan

    Date: 12/31/2010

    Comment: Rollback the changes from previous version

    类型查看

    类型查看非常简单,在此不想浪费太多时间,让我们直接看一个例子,此例子返回正在运行的程序集的所有类型信息。

    ExpandedBlockStart.gif代码
     1 using System;
     2 using System.Reflection;
     3 
     4 namespace TypeDiscovery
     5 {
     6     class Program
     7     {
     8         static void Main(string[] args)
     9         {
    10             Assembly assembly = Assembly.GetExecutingAssembly();
    11             Type[] types = assembly.GetTypes();
    12             foreach (Type type in types)
    13             {
    14                 Console.WriteLine(type);
    15             }
    16             Console.ReadKey();
    17         }
    18     }
    19 }

     

    运行结果如下:

    TypeDiscovery.Program

    后期绑定

             程序集A的代码可以实例化并使用一个定义在程序集B中的类型,而该类型可能在A编译的时候并没有被引用,我们把这种类型的联系描述为后期绑定。如果我们深入研究后期绑定,你将会发现这是一种很酷的技术,但限于篇幅的原因,在此不再赘述,仅以下面的例子作为参考,有兴趣的同学可以去研究一下动态语言如PythonRuby以及插件技术(Plugin)

    ExpandedBlockStart.gif代码
     1 using System;
     2 using System.Reflection;
     3 
     4 namespace LateBinding
     5 {
     6     class Program
     7     {
     8         static void Main(string[] args)
     9         {
    10             Assembly assembly = Assembly.GetExecutingAssembly();
    11             Type type = assembly.GetType("LateBinding.Employee");
    12             Object obj = Activator.CreateInstance(type);
    13 
    14             Type[] paramTypes = new Type[1];
    15             paramTypes[0= Type.GetType("System.String");
    16             MethodInfo SayHelloMethodInfo = type.GetMethod("SayHello", paramTypes);
    17  
    18             Object[] parameters = new Object[1];
    19             parameters[0= "panchunting";
    20             Object returnVal = SayHelloMethodInfo.Invoke(obj, parameters);
    21             Console.WriteLine(returnVal);
    22             Console.ReadKey();
    23         }
    24     }
    25 
    26     public class Employee
    27     {
    28         public void SayHello(string employeeName)
    29         {
    30             Console.WriteLine("Hello, {0}", employeeName);
    31         }
    32     }
    33 }

     

    运行结果如下:

    Hello, panchunting

    运行时动态创建类型

                    在创建类型之前,我们得有相应的程序集,你可选择创建一个新程序集,也可以选择使用当前的程序集,下面我们分别加以说明。

    方式一:引用外部程序集

                    一般而言,程序集由DLLEXE文件组成,当然也可以包含资源文件,如JPG等,我们假定这里的程序集只包含单个DLL文件,为此我们先创建一个类库项目

    ExpandedBlockStart.gif代码
     1 using System;
     2 
     3 namespace ReflectionClassLibrary
     4 {
     5     public class Employee
     6     {
     7         public Employee(string employeeName)
     8         {
     9             this.employeeName = employeeName;
    10         }
    11  
    12         private string employeeName;
    13  
    14         public void SayHello()
    15         {
    16             Console.WriteLine("Hello, " + this.employeeName);
    17         }
    18     }
    19 }

     

     下面创建一个控制台应用程序用于反射此程序集(当然你得先添加对此程序集的引用)

    ExpandedBlockStart.gif代码
     1 using System;
     2 using System.Reflection;
     3 using ReflectionClassLibrary;
     4 
     5 namespace ReflectionEmployee
     6 {
     7     class Program
     8     {
     9         static void Main(string[] args)
    10         {
    11             Assembly assembly = Assembly.LoadFrom("ReflectionClassLibrary.dll");
    12             Type type = assembly.GetType("ReflectionClassLibrary.Employee");
    13             Employee employee = Activator.CreateInstance(type, "panchunting"as Employee;
    14             if (employee != null)
    15             {
    16                 employee.SayHello();
    17             }
    18             Console.ReadKey();
    19         }
    20     }
    21 }
    22 

     

     运行结果如下:

    Hello, panchunting

    方式二,反射的类与反射方法在同一个程序集中

    ExpandedBlockStart.gif代码
     1 using System;
     2 using System.Reflection;
     3 
     4 namespace ReflectionAllInOneAssembly
     5 {
     6     class Program
     7     {
     8         static void Main(string[] args)
     9         {
    10             Assembly assembly = Assembly.GetExecutingAssembly();
    11             Type type = assembly.GetType("ReflectionAllInOneAssembly.Employee");
    12             Employee employee = Activator.CreateInstance(type, "panchunting"as Employee;
    13             if (employee != null)
    14             {
    15                 employee.SayHello();
    16             }
    17             Console.ReadKey();
    18         }
    19     }
    20 
    21     public class Employee
    22     {
    23         public Employee(string employeeName)
    24         {
    25             this.employeeName = employeeName;
    26         }
    27  
    28         private string employeeName;
    29  
    30         public void SayHello()
    31         {
    32             Console.WriteLine("Hello, " + this.employeeName);
    33         }
    34     }
    35 }

     

     反射与抽象工厂

           先介绍点业务逻辑知识:Performance有两种类型:PlanReview,而它们又都有三种类型的Program,即:CompetencyJobResponsibilityTrainingDevelopment

    创建抽象工厂代码如下:

     

    ExpandedBlockStart.gif代码
     1 using System;
     2 using System.Text;
     3 using System.Reflection;
     4 
     5 namespace ReflectionAbstractFactory
     6 {
     7     public abstract class AbstractFactory
     8     {
     9         public abstract IProgramType CreateProgram(string ProgramTypeName);
    10     }
    11 
    12     public class ReviewProgram : AbstractFactory
    13     {
    14         public override IProgramType CreateProgram(string ProgramTypeName)
    15         {
    16             IProgramType ProgramType = null;
    17             Type type = Type.GetType("ReflectionAbstractFactory." + ProgramTypeName);
    18             if (type != null)
    19             {
    20                 ProgramType = Activator.CreateInstance(type) as IProgramType;
    21             }
    22             return ProgramType;
    23         }
    24     }
    25 
    26     public class PlanProgram : AbstractFactory
    27     {
    28         public override IProgramType CreateProgram(string ProgramTypeName)
    29         {
    30             IProgramType ProgramType = null;
    31             Type type = Type.GetType("ReflectionAbstractFactory." + ProgramTypeName);
    32             if (type != null)
    33             {
    34                 ProgramType = Activator.CreateInstance(type) as IProgramType;
    35             }
    36             return ProgramType;
    37         }
    38     }
    39 
    40     public interface IProgramType
    41     {
    42         void Display();
    43     }
    44 
    45     public class ReviewCompetency : IProgramType
    46     {
    47         public void Display()
    48         {
    49             Console.WriteLine("This is competency program of review");
    50         }
    51     }
    52 
    53     public class ReviewJobResponsibility : IProgramType
    54     {
    55         public void Display()
    56         {
    57             Console.WriteLine("This is job responsibility program of review");
    58         }
    59     }
    60 
    61     public class ReviewTrainingDevelopment : IProgramType
    62     {
    63         public void Display()
    64         {
    65             Console.WriteLine("This is training development program of review");
    66         }
    67     }
    68 
    69     public class PlanCompetency : IProgramType
    70     {
    71         public void Display()
    72         {
    73             Console.WriteLine("This is competency program of plan");
    74         }
    75     }
    76 
    77     public class PlanJobResponsibility : IProgramType
    78     {
    79         public void Display()
    80         {
    81             Console.WriteLine("This is job responsibility program of plan");
    82         }
    83     }
    84  
    85     public class PlanTrainingDevelopment : IProgramType
    86     {
    87         public void Display()
    88         {
    89             Console.WriteLine("This is training development program of plan");
    90         }
    91     }
    92 }

     

    控制台运行结果如下:

    Please input the class name, like ReviewCompetency:ReviewCompetency

    ------------------------------------------------------

    This is competency program of review

    ------------------------------------------------------

    Plese input any key to exit

    性能

    (MSDN)反射的性能损失主要来源于比较类型、遍历成员、调用成员三种情形,其中比较类型耗时最小,调用成员耗时最多,所以尽量减少采用成员动态调用等反射方式可以提高应用程序性能。除此之外,采取后期绑定、避免将反射方法放到循环内产生放大效应等办法均可提升反射性能。

    参考及引用

    http://msdn.microsoft.com/zh-cn/library/ms173183(VS.80).aspx

    http://msdn.microsoft.com/en-us/magazine/cc164170.aspx

    http://oreilly.com/catalog/progcsharp/chapter/ch18.html

    http://www.codeproject.com/KB/architecture/CSharpClassFactory.aspx

    http://p2p.wrox.com/content/blogs/lee-dumond/refactoring-c-aspnet-%E2%80%93-abstract-factory-reflection

    Practical .NET2 and C#2 (Harness the Platform, the Language, the Framework)

     

    转载于:https://www.cnblogs.com/panchunting/archive/2010/03/24/CSharpReflection.html

    展开全文
  • 1、反射的定义及功能介绍:审查元数据并收集关于它的类型信息的能力。元数据(编译以后的最基本数据单元)就是一大堆的表,当编译程序集或者模块时,编译器会创建一个类定义表,一个字段定义表,和一个方法定义表等...


        1、反射的定义及功能介绍:审查元数据并收集关于它的类型信息的能力。元数据(编译以后的最基本数据单元)就是一大堆的表,当编译程序集或者模块时,编译器会创建一个类定义表,一个字段定义表,和一个方法定义表等。可能这些说的比较抽象。我再从另一个角度来说:反射是.Net中获取运行时类型信息的方式,.Net的应用程序由几个部分:‘程序集(Assembly)’、‘模块(Module)’、‘类型(class)’组成,而反射提供一种编程的方式,让程序员可以在程序运行期获得这几个组成部分的相关信息,例如:Assembly类可以获得正在运行的装配件信息,也可以动态的加载装配件,以及在装配件中查找类型信息,并创建该类型的实例。
        Type类可以获得对象的类型信息,此信息包含对象的所有要素:方法、构造器、属性等等,通过Type类可以得到这些要素的信息,并且调用之。
        MethodInfo包含方法的信息,通过这个类可以得到方法的名称、参数、返回值等,并且可以调用之。
        诸如此类,还有FieldInfo、EventInfo等等,这些类都包含在System.Reflection命名空间下。

        System.reflection命名空间包含的几个类,允许你反射(解析)这些元数据表的代码

        System.Reflection.Assembly:表示一个程序集。

        System.Reflection.Module:在模块上执行反射。

        System.Type:表示各种类型。

        System.Reflection.MethodBase:提供有关方法和构造函数的信息。

        System.Reflection.MethodInfo:发现方法的属性并提供对方法元数据的访问。

        System.Reflection.MemberInfo:获取或访问有关成员属性。

        System.Reflection.FieldInfo:发现字段属性并提供对字段元数据的访问权。

        System.Reflection.PropertyInfo:发现或访问属性(Property)的属性(Attribute)。

        System.Reflection.EventInfo:发现事件的属性并提供对事件元数据的访问权。

        System.Reflection.ConstructorInfo:发现或访问类构造函数的属性。


        2、反射层次模型图如下所示:




        3、获取程序集元数据 

        Assembly类定义了一个程序集,它是一个可重用、无版本冲突并且可自我描述的公共语言运行库应用程序构造块。因为程序集中是使用元数据进行自我描述的,所以我们就能通过其元数据得到程序集内部的构成。结合Assembly和反射能够获取程序集的元数据,但是首先要将程序集装入内存中。可以使用Assembly类的多种静态Load方法加载程序集。

        如Assembly assem = Assembly.Load("University");//加载系统程序集

        4、获取类型的方法可以通过Type.GetType以及Assembly.GetType方法,如:
                 Type  t  =  Type.GetType(“University.College”);
        需要注意的是,必须指定它所在的装配件,University这个动态库已经引用到这个控制台程序中了。(全文都是基于我的University.dll及控制台程序展开讲解的)。

        5、动态创建对象以及调用方法:在学习如何动态地创建一个对象之前,我们先来学习一下静态方法和实例方法的区别。

        拿别人一个例子说事:比如说“人”这个类,每个人都有姓名、年龄、性别、身高等,这些属性就应该是非静态的,因为每个人都的这些属性都不相同;但人在生物学上属于哪个门哪个纲哪个目等,这个属性是属于整个人类,所以就应该是静态的——它不依赖与某个特定的人,不会有某个人是“脊椎动物门哺乳动物纲灵长目”而某个人却是“偶蹄目”的。

        静态就是类的,实例就是对象的。静态方法和实例方法的区别之处还有一个地方:静态方法不需要依赖类当中的属性,能在这个方法中封闭的完成一个功能。实例方法更多的会使用到类当中的属性。

    (1)   使用有参函数创建对象。

    (2)   通过一个示范例说明:

    namespace University
    {
        public class College
        {
            private string _code;
           
            private string _address;
            private string _telephone;
            private string _value;
            public string  code
            {
                get
                {
                    return _code;
                }
                set
                {
                    _code = value;
                }
            }
            
            public string address
            {
                get
                {
                    return _address;
                }
                set
                {
                    _address = value;
                }
            }
            public string telephone
            {
                get
                {
                    return _telephone;
                }
                set
                {
                    _telephone = value;
                }
            }
            public string value
            {
                get
                {
                    return _value;
                }
                set
                {
                    _value = value;
                }
            }
           
             public College(string  code,string address,string telephone, string value)
            {
                this.code = code;
                this.address = address;
                this.telephone = telephone;
                this.value = value;                   
            }
             public string getCode()
             {
                 return code;
             }
            public string getAddress()
            {
                return address;
            }
            public string getTelephone()
            {
                return telephone;
            }
            public string getValue()
            {
                return value;
            }
    public void Test(string name)
            {
                Console.WriteLine("向{0}汇报:静态方法成功调用!",name);
            }
        }
    }

        //使用有参数构造函数创建对象

       

     Assembly asm = Assembly.Load("University");
    string[] testString = { "01", "第三中学", "西安", "高级" };
    object[]parameters = testString;
    Object obj =asm.CreateInstance("University.MiddleSchool", true,BindingFlags.Default, null, parameters, null, null);

         BindingFlags在前面我们也用到过,它用于限定对类型成员的搜索。在这里指定Default,意思是不使用BingdingFlags的策略(你可以把它理解成null,但是BindingFlags是值类型,所以不可能为null,必须有一个默认值,而这个Default就是它的默认值)接下来的参数是Binder,它封装了CreateInstance绑定对象(Calculator)的规则,我们几乎永远都会传递null进去,实际上使用的是预定义的DefaultBinder接下来是一个Object[]数组类型,它包含我们传递进去的参数,有参数的构造函数将会使用这些参数;接下来的参数是一个CultureInfo类型,它包含了关于语言和文化的信息(简单点理解就是什么时候ToString)

        //使用InvokeMember调用实例方法

               
                Type t = Assembly.Load("University").GetType(string.Format("University.College"));
                string result = (string)t.InvokeMember("getAddress", BindingFlags.InvokeMethod, null, obj, null);
                string result1 = (string)t.InvokeMember("getCode", BindingFlags.InvokeMethod, null, obj, null);
                string result2 = (string)t.InvokeMember("getValue", BindingFlags.InvokeMethod, null, obj, null);
                string result3 = (string)t.InvokeMember("getTelephone", BindingFlags.InvokeMethod, null, obj, null);
                Console.WriteLine(String.Format("Theresult is {0},{1},{2},{3}", result, result1, result2, result3));



        结果为:The result is 第三中学,01,高级,西安

           在InvokeMember方法中,第一个参数说明了想要调用的方法名称;第二个参数说明是调用方法(因为InvokeMember的功能非常强大,不光是可以调用方法,还可以获取/设置 属性、字段等。此枚举的详情可参看MSDN);第三个参数是Binder,null说明使用默认的Binder;第四个参数说明是在这个对象上(obj是College类型的实例)进行调用;最后一个参数是数组类型,表示的是方法所接受的参数。

        //使用InvokeMember对静态方法的调用 

               

                Type t1 = Assembly.Load("University").GetType(string.Format("University.College"));
                Object[] parameters2 = {"John"};          
                t1.InvokeMember("Test", BindingFlags.InvokeMethod,null,obj, parameters2);

        结果为:向John汇报:静态方法成功调用!

        我们和上面对比一下:首先,第四个参数传递的是 obj,不再是一个Calculator实例类型,这很容易理解,因为我们调用的是一个静态方法,它不是基于某个具体的类型实例的,而是基于类型本身;其次,因为我们的静态方法需要提供一个参数,所以我们以数组的形式将这个参数进行了传递。

        


    展开全文
  • 其实这些都是类内置函数,如果我们在自己定义的类里重写了这几个函数, 会直接覆盖了类中这几个函数默认功能,换个角度,我们可以直接改写这些函数,让它在已有 功能基础上添加新功能 class Foo: x = 2...

    一、我们在前面的章节中学习了  __getattr__  __setattr__ 以及 __delattr__的用法,

    其实这些都是类的内置函数,如果我们在自己定义的类里重写了这几个函数,

    会直接覆盖了类中这几个函数的默认功能,换个角度,我们可以直接改写这些函数,让它在已有

    功能的基础上添加新功能

    class Foo:
        x = 2
        def __init__(self,y):
            self.y = y
    
        def __delattr__(self, item):
            print("正在执行__setattr__,这里可加新功能哦")
            self.__dict__.pop(item)
    
    f1 = Foo(7)
    print(f1.__dict__)
    del f1.y
    print(f1.__dict__)
    

     

    二、包装一个标准类型

    list  str  tuple  等等都是类

    我们可以创建新类继承他们,同时增加新功能

    class List(list):
    
        def show_midle(self):  #求列表中间值
            mid_index = int(len(self)/2)
            return self[mid_index]
    
    l2 = List('hellojinling')
    print(l2.show_midle())
    print(l2)
    

      

    class List(list):
    
        def append(self,p_object):  #修改append方法
            print("正在添加")
            if type(p_object) is str:  #判断一下,只添加字符串
                super().append(p_object)
    
        def show_midle(self):  #求列表中间值
            mid_index = int(len(self)/2)
            return self[mid_index]
    
    l2 = List('hellojinling')
    print(l2)
    l2.append("LOVE")
    print(l2)
    

      

     

     

    转载于:https://www.cnblogs.com/dabai123/p/11605584.html

    展开全文
  • 反射的定义及概述 JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法(类名,方法名,参数类型,返回值类型);对于任意一个对象,都能够调用它任意的一个方法和属性;这种动态获取...
    • 反射的定义及概述

      JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法(类名,方法名,参数类型,返回值类型);对于任意一个对象,都能够调用它任意一个方法属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

       总结来说就是,反射就是把java类中的各种成分映射成一个个   java对象例如:一个类有:成员变量、方法、构造方法,包等信息,利用反射技术可以对一个类进行解剖,把各个组成部分映射成一个个对象

    • 反射的相关函数介绍:

      • 获取类的三种方法
        • 第一种方式-->Class.forName("类名字符串")

          • Class c1=Class.forName("com.edu.Student");

        • 第二种方式-->先创建对象,再用对象调用getClass()方法,即实例对象.getClass().返回运行时类

          • Student s=new Student();

          • Class c2 = s.getClass();

        • 第三种方式-->类名.class。返回Class的对象。(每个类都有class属性)

          • Class c2 = s.getClass();    

            (!!!Class类用于表示.class文件(字节码),获取某个类时的前提条件就是获取该类的Class)
      • 获取属性
      • 获取方法
      • 获取构造函数
      • 获取其他信息
    • 具体代码实现:

      • ​​​​​​​引入工程截图
        • ​​​​​​​
      • 获取类的类名
        • ​​​​​​​实体类Student 
          • ​​​​​​​略
        • 获取代码实现
      • 获取类的构造方法
        • ​​​​​​​Student类的构造方法
          • ​​​​​​​
        • 获取的代码实现
          • ​​​​​​​
      • 获取类的方法
        • ​​​​​​​Student类的方法
          • ​​​​​​​
        • 获取的代码实现
          • ​​​​​​​
      • 获取类的属性
        • ​​​​​​​Student类的属性
          • ​​​​​​​
        • 获取属性的代码实现
          • ​​​​​​​
      • 获取类的其他信息
        • ​​​​​​​获取的代码实现
          • ​​​​​​​

    参考文献:

    1. https://blog.csdn.net/sinat_38259539/article/details/71799078
    2. https://blog.csdn.net/ylyang12/article/details/53469957
    3. https://blog.csdn.net/qq_24341197/article/details/77964172

     

     

     

     

     

     

    展开全文
  • 反射 (Reflection):反射就是让你可以通过名称来得到对象 ( 类,属性,方法 ) 技术。例如我们可以通过类名来生成一个类实例;...它能找出构成该类所有属性方法名称和数据类型。这种能...
  • 反射的定义 反射(Reflection)是Java 程序开发语言的特征之一,它允许运行中的 Java 程序获取自身的信息,并且可以操作类或对象的内部属性。 简而言之,通过反射,我们可以在运行时获得程序或程序集中每一个类型的...
  • 反射的定义:审查元数据并收集关于它的类型信息的能力。元数据(编译以后的最基本数据单元)就是一大堆的表,当编译程序集或者模块时,编译器会创建一个类定义表,一个字段定义表,和一个方法定义表等,。System
  • C#反射的入门学习首先要明白C#反射提供了封装程序集、模块和类型的对象等等。那么这样可以使用反射动态创建类型的实例,将类型绑定到现有对象,或从现有对象获取类型并调用其方法或访问其字段和属性。如果代码中使用...
  • Java中的反射及Bean容器实现

    千次阅读 2015-05-31 15:53:40
    与之相关是自省(Introspection),这个指是程序自己可以获取一个类型的描述信息,例如获取一个类所有接口定义、一个接口所有形参。当编程语言有了这些语言特性之后,可以在很大程度上解决代码耦合问题,所以...
  • java反射机制用法

    2018-10-08 17:07:50
    一、反射的定义   反射的核心是 JVM 在运行时才动态加载类或调用方法/访问属性,它不需要事先(写代码的时候或编译期)知道运行对象是谁。通过反射,我们可以在运行时获得程序或程序集中每一个类型的成员和成员的...
  • 换句话说,Java程序可以加载一个运行时才得知名称class,获悉其完整构造(但不包括methods定义),并生成其对象实体、或对其fields设值、或唤起其methods。然而C++是不支持反射机制,虽然C++有RTTI(运行时类型识别...
  • 反射简介简单应用

    2021-04-04 08:20:17
    有关程序及其类型的数据被称为元数据,保存在程序程序集 一个运行程序查看本身元数据或者其他程序元数据行为叫反射 一遍下来啥都没整明白?没事,咱只是惯例行事,先放定义反射reflection,这个词也有...
  • 反射实例概念

    2008-02-21 16:42:00
    反射appDomain 的程序集 反射单个程序集 利用反射获取类型信息 设置反射类型的成员 通过反射创建类型的实例 反射类型的接口 反射的性能 反射的概述 反射的定义:审查元数据并收集关于它的类型信息的能力。...
  • Java枚举类型 枚举类型概述 Java中枚举类型属于自定义引用类型,定义枚举类型使用enum关键字修饰类 枚举类型通常包含一组...枚举类型的定义 public enum SignalLamp { /*枚举常量定义*/ RED,//常量之间用逗号分隔
  • 反射的讲解

    2019-12-12 15:01:42
    反射的定义: Reflection (反射)是Java被视为动态语言的关键,反射机制允许程序在执行期借助于ReflectionAPI取得任何类的内部信息,并能直接操作任意对象的内部属性方法。 Class.forName(“java.lang.String”) ...
  • Java反射实例说明

    2016-05-27 14:14:31
    反射是Java中一种强大工具...(1)java.lang.Class 对象建模的类型,存放调用类型的表现形式。该类定义了返回构造函数,成员变量,成员属性等一系列方法。 (2)java.lang.reflect.Constructor 构造函数 (3)j
  • 反射是框架灵魂,对于任意一个类,能够动态获取信息以及动态调用对象方法功能,这被称为反射机制。 对象创建 静态 比如Person p = new Person(),在编译时就已经确定了具体类型,绑定了对象 动态 运行...
  • 反射

    2021-03-07 23:41:57
    反射(Reflection)是指程序在运行期间可以拿到一个对象所有信息,并能够直接操作对象内属性方法。反射是为了解决在运行期,对某个实例一无所知情况下,可以调用其方法。 Class类 除了基本类型外,Jave...
  • //反射 // java反射:在程序运行过程中,...// 解剖这个类型,获取类中成员,需要使用Class类型定义的方法 // 这种【动态】获取信息以及【动态】访问成员这种方式,称为:反射 //获取字节码对象三个方法 .
  • C#特性及反射相关

    2017-02-10 17:21:01
    所有 .NET 程序集都包含指定一组元数据,这些元数据描述在程序集中定义的类型类型成员。可以添加自定义特性,以指定所需任何附加信息。 可以将一个或多个特性应用到整个程序集、模块或较小程序元素(如...
  • 反射机制的定义: 是在运行状态中,对于任意的一个类,都能够知道这个类的所有属性和方法,对任意一个对象都能够通过反射机制调用一个类的任意方法,这种动态获取类信息动态调用类对象方法的功能称为java的反射...
  • 20150804-反射及注解

    2015-08-04 14:55:04
    反射 一基本概念 二通过反射可以返回主要信息 三范例1 四范例2 二注解 Annotation类这里介绍...3.Object类中定义了getClass方法,返回一个类型为Class对象。例: 法1:Class clazz = Student.class;//将stud
  • 以上方法返回值的类型是一个Class类,实际上此类是Java反射的源头, 实际上所谓反射从程序的运行结果来看也很好理解,即: 可以通过对象反射求出类的名称 正常方式:引入需要的包、类名称,通过new实例化,取得实例...
  • 反射机制的定义: 是在运行状态中,对于任意的一个类,都能够知道这个类的所有属性和方法,对任意一个对象都能够通过反射机制调用一个类的任意方法,这种动态获取类信息动态调用类对象方法的功能称为java的反射...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 276
精华内容 110
关键字:

反射的定义及类型