CN111427581B - Method, device, equipment and medium for realizing type multi-inheritance - Google Patents
Method, device, equipment and medium for realizing type multi-inheritance Download PDFInfo
- Publication number
- CN111427581B CN111427581B CN202010221672.0A CN202010221672A CN111427581B CN 111427581 B CN111427581 B CN 111427581B CN 202010221672 A CN202010221672 A CN 202010221672A CN 111427581 B CN111427581 B CN 111427581B
- Authority
- CN
- China
- Prior art keywords
- class
- merged
- interface
- super
- superclasses
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 82
- 238000004590 computer program Methods 0.000 claims description 13
- 238000000605 extraction Methods 0.000 claims description 6
- 230000004044 response Effects 0.000 claims description 4
- 230000006870 function Effects 0.000 description 16
- 238000010586 diagram Methods 0.000 description 14
- 230000003287 optical effect Effects 0.000 description 4
- 238000013461 design Methods 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 3
- 230000000694 effects Effects 0.000 description 2
- 239000000835 fiber Substances 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000008569 process Effects 0.000 description 2
- 238000013068 supply chain management Methods 0.000 description 2
- 230000001360 synchronised effect Effects 0.000 description 2
- 238000012546 transfer Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 230000014509 gene expression Effects 0.000 description 1
- 238000007726 management method Methods 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
- 238000000844 transformation Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a method for realizing type multi-inheritance, which comprises the following steps: extracting an interface from a method and an attribute which need to be inherited by each superclass in a plurality of superclasses to be inherited; recording the superclass and an interface corresponding to the superclass; combining a plurality of superclasses into a combined class through dynamic compilation, and configuring the combined class as an interface for extracting all combined superclasses; and responding to the realization of the interface method, combining the super classes and transferring the combined super classes to the corresponding methods respectively. The invention also discloses a device, equipment and a medium. The method, the device, the equipment and the medium for realizing type multi-inheritance provided by the invention can realize class inheritance of a plurality of super classes.
Description
Technical Field
The present invention relates to the field of computer technologies, and in particular, to a method, an apparatus, a device, and a medium for implementing type multi-inheritance.
Background
The mainstream programming languages used by modern software systems almost do not support one class to inherit multiple parent classes, only support interfaces to inherit multiple interfaces.
Disclosure of Invention
In view of this, an object of the embodiments of the present invention is to provide a method for implementing type multiple inheritance, so that each method of a class can be developed and deployed separately.
Based on the above object, an aspect of the present invention provides a method for implementing type multiple inheritance, including:
extracting an interface from a method and an attribute which need to be inherited by each of a plurality of superclasses to be inherited;
recording the superclass and an interface corresponding to the superclass;
combining a plurality of superclasses into a combined class through dynamic compiling, and configuring the combined class as an interface for realizing extraction of all the combined superclasses;
and responding to the realization of the interface method, combining the super classes and transferring the combined super classes to the corresponding methods respectively.
In some embodiments of the method for implementing type multi-inheritance of the present invention, recording the superclass and the interface corresponding to the superclass further comprises:
and recording the super class and the interface corresponding to the super class through the configuration file.
In some embodiments of the method for implementing type multiple inheritance according to the present invention, the step of merging a plurality of super classes into a merged class through dynamic compilation, and configuring the merged class as an interface for extracting all the merged super classes further includes:
and finding interfaces of the merged classes and the merged super classes through the configuration files.
In some embodiments of the method for implementing type multi-inheritance according to the present invention, the step of merging a plurality of super classes into a merged class through dynamic compilation, and configuring the merged class as an interface for implementing extraction of all the merged super classes further includes:
dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javaccompiler in Java.
In another aspect of the embodiments of the present invention, a device for implementing type multiple inheritance is further provided, where the device includes:
the interface extraction module is configured to extract an interface from the method and the attribute which need to be inherited by each of a plurality of super classes to be inherited;
the recording module is configured to record the super class and an interface corresponding to the super class;
the merging module is configured to merge the plurality of super classes into a merged class through dynamic compiling, and configure the merged class as an interface for realizing extraction of all the merged super classes;
and the method transferring module is configured to combine the methods respectively corresponding to the superclasss of class transferring combination in response to the realization of the interface method.
In some embodiments of the apparatus implementing type multiple inheritance of the present invention, the recording module is further configured to:
and recording the super class and the interface corresponding to the super class through the configuration file.
In some embodiments of the apparatus implementing type multiple inheritance of the present invention, the merging module is further configured to:
and finding interfaces of the merged class and the merged super class through the configuration file.
In some embodiments of the apparatus implementing type multiple inheritance of the present invention, the merging module is further configured to:
dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javaccompiler in Java.
In another aspect of the embodiments of the present invention, there is also provided a computer device, including:
at least one processor; and
a memory storing a computer program operable on a processor, the processor executing the program to perform the method of implementing multi-inheritance of a type as previously described.
In another aspect of the embodiments of the present invention, a computer-readable storage medium is further provided, where a computer program is stored, where the computer program is executed by a processor to perform the foregoing method for implementing type multiple inheritance.
The invention has at least the following beneficial technical effects: by defining a set of flow and method, the problem that the type in a software system written by a modern high-level programming language cannot simultaneously inherit the methods and attributes on a plurality of superclasses is solved.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the embodiments or the prior art descriptions will be briefly described below, it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art that other embodiments can be obtained according to the drawings without creative efforts.
FIG. 1 shows a schematic block diagram of an embodiment of a method of implementing type multi-inheritance in accordance with the present invention;
FIG. 2 is a structural diagram illustrating a class diagram after an abstraction interface according to an embodiment of the method of implementing type multi-inheritance of the present invention;
FIG. 3 is a structural diagram illustrating the dynamic compilation of an embodiment of a method for implementing type multi-inheritance according to the present invention to generate merged classes;
FIG. 4 shows a timing diagram of a method transfer according to an embodiment of the present invention implementing a type multiple inheritance method.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the following embodiments of the present invention are described in further detail with reference to the accompanying drawings.
It should be noted that all expressions using "first" and "second" in the embodiments of the present invention are used for distinguishing two entities with the same name but different names or different parameters, and it is understood that "first" and "second" are only used for convenience of description and should not be construed as limiting the embodiments of the present invention, and the descriptions thereof in the following embodiments are omitted.
In view of the foregoing, a first aspect of the embodiments of the present invention provides an embodiment of a method for implementing type multi-inheritance. Fig. 1 is a schematic diagram illustrating an embodiment of a method for implementing type multi-inheritance according to the invention. In the embodiment shown in fig. 1, the method comprises at least the following steps:
s100, extracting an interface from a method and an attribute which need to be inherited by each of a plurality of superclasses to be inherited;
s200, recording the superclass and an interface corresponding to the superclass;
s300, combining a plurality of superclasses into a combined class through dynamic compiling, and configuring the combined class as an interface for extracting all combined superclasses;
s400, responding to the realization of the interface method, combining the super classes and transferring the combined super classes to the corresponding methods.
In some embodiments of the present invention, the method and the attribute that need to be inherited in the super class to be inherited are extracted out of the interface, and the super class and the corresponding interface are recorded. In some embodiments, there are three super classes to be inherited, which are ClassA, classB, and ClassC, respectively, and fig. 2 is a schematic structural diagram illustrating a post-extraction-interface class diagram according to an embodiment of the method for implementing type multi-inheritance of the present invention, where the post-extraction-interface class diagram is shown in fig. 2.
After the software system is run, a class is generated by utilizing the dynamic compiling capability, simultaneously, interfaces extracted from all the merged classes are realized, and a corresponding method in the corresponding merged class modulation class is established in the realization of an interface method.
According to some embodiments of the method for implementing type multiple inheritance of the present invention, recording the superclass and the interface corresponding to the superclass further comprises:
and recording the superclass and the interface corresponding to the superclass through the configuration file.
In some embodiments of the invention, classes and corresponding interfaces are recorded via a configuration file or other means.
According to some embodiments of the method for implementing type multiple inheritance according to the present invention, the step of merging a plurality of super classes into a merged class through dynamic compilation, and configuring the merged class as an interface for extracting all the merged super classes further comprises:
and finding interfaces of the merged classes and the merged super classes through the configuration files.
In some embodiments of the present invention, during service runtime, dynamic compilation is used to find classes to be merged and class interfaces according to a configuration file or other manners, and the interfaces of the classes to be merged are combined to generate a new class, i.e., a merged class.
According to some embodiments of the method for implementing type multiple inheritance according to the present invention, the step of merging a plurality of super classes into a merged class through dynamic compilation, and configuring the merged class as an interface for extracting all the merged super classes further comprises:
dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javaccompiler in Java.
In some embodiments of the invention, a class is generated after the software system is run using dynamic (with respect to the software development phase) compilation capabilities (e.g., microsoft, CSharp, CSharpCodProvider in DotNet or Roslyn and JavaCompiler in Java).
In another embodiment of the present invention, taking the sales order management function of the supply chain management system as an example, a sales order service named SalesOrderService is developed, which provides functions of adding sales orders (Add), viewing sales orders (Retrieve), and the like. The sales order business is divided into warehousing and ex-warehousing, a warehousing service (named as sogoodsrechervice) has all functions of sales order service, and a warehousing method (goodsrechervice) is added at the same time, and an ex-warehousing service (named as sogoodscuseservice) has all functions of sales order service and an ex-warehousing method (goodscusue) is added at the same time.
When the supply chain management system is applied to military enterprises, customers generally require:
the sales order service provides a function of setting a privacy level;
the warehousing service provides a function of setting security and merging into a warehouse;
the ex-warehouse service provides the functions of setting confidentiality and ex-warehouse;
according to the requirements, related developers develop military sales order service on the basis of the sales order service, namely MilitarySOservice, and provide a function (SetSecureLevel) for setting the security level; the military warehousing service is developed on the basis of military sales order service and warehousing service, is named as MilitarySOGoodsReceiveService, and provides a security setting and warehousing function (SetSecureLevelAndGoodsRecive); the military export service is developed on the basis of military sales order service and export service, is named as MilitarySOGoodsIssueServer, and provides a function of setting privacy and exporting (SetSecureLevelAndGoodsIssue).
In service operation, dynamic compilation is utilized, classes to be merged and class interfaces are found according to configuration files or other modes, the interfaces of the classes to be merged are combined to generate a new class of Military SOGoodsReceiveServiceImpl and Military SOGoodsIssuerviceImpl, FIG. 3 is a structural schematic diagram of generating the merged classes by dynamic compilation according to an embodiment of the method for realizing type multi-inheritance of the present invention, and the class diagram is shown in FIG. 3.
When the service consumer needs to use the warehousing service, the generated instance of the militarysogoodsrechaceserviceimpl class is returned, and when the ex-warehousing service needs to be used, the generated instance of the MilitarySOGoodsIssueServiceImpl class is returned. Because the millitariysoodsireserviceimpl and the millitariysoodsisoseviceimpl are classes generated by dynamic compilation, they cannot be directly used by a service consumer, and thus a factory design pattern or the like is generally required to create an instance.
When a service consumer calls a method on a service, a corresponding method on an implementation class where an intra-class callback method is implemented is taken as an example of millitariysoodsrechaceserviceimpl, and fig. 4 shows a sequence diagram of method callbacks according to an embodiment of the method for implementing multi-inheritance of types of implementation of the present invention, and the call sequence diagram is shown in fig. 4.
For the above-mentioned class creation interface, the interface name is uniformly specified as the beginning of the class name with the added letter I (for example, the interface name created by salesrerservice is isaleserdrervice), and the class diagram after the interface is created is as follows:
in another aspect of the embodiments of the present invention, an embodiment of a device for implementing type multiple inheritance is provided. The device includes:
the interface extraction module is configured to extract an interface from the method and the attribute which need to be inherited by each of a plurality of super classes to be inherited;
the recording module is configured to record the superclass and the interface corresponding to the superclass;
the merging module is configured to merge a plurality of superclasses into a merged class through dynamic compilation, and configure the merged class as an interface for extracting all the merged superclasses;
and the method transferring module is configured to combine the methods respectively corresponding to the superclasss of class transferring combination in response to the realization of the interface method.
According to some embodiments of the apparatus implementing type multiple inheritance according to the invention, the recording module is further configured to:
and recording the superclass and the interface corresponding to the superclass through the configuration file.
According to some embodiments of the apparatus for implementing type multiple inheritance according to the invention, the merging module is further configured to:
and finding interfaces of the merged classes and the merged super classes through the configuration files.
According to some embodiments of the apparatus implementing type multiple inheritance of the present invention, the merging module is further configured to:
dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javaccompiler in Java.
In view of the above object, another aspect of the embodiments of the present invention further provides a computer device, including: at least one processor; and a memory storing a computer program operable on the processor, the processor executing the program to perform the method for implementing type inheritance as described above.
In another aspect of the embodiments of the present invention, a computer-readable storage medium is further provided, where a computer program is stored, where the computer program is executed by a processor to perform the foregoing method for implementing type multiple inheritance.
Likewise, it will be appreciated by those skilled in the art that all of the embodiments, features and advantages set forth above with respect to the method of implementing type multiple inheritance according to the present invention apply equally well to the apparatus, the computer device and the medium according to the present invention. For the sake of brevity of this disclosure, no further discussion is repeated herein.
It should be particularly noted that, the steps in the embodiments of the method, apparatus, device and medium for implementing type multiple inheritance as described above can be mutually intersected, replaced, added and deleted, so that these reasonable permutation and combination transformations also belong to the scope of the present invention for implementing type multiple inheritance, and should not limit the scope of the present invention to the embodiments.
Finally, it should be noted that, as those skilled in the art can understand that all or part of the processes in the methods of the above embodiments can be implemented by instructing relevant hardware through a computer program, and a program for implementing the method of type multiple inheritance may be stored in a computer readable storage medium, and when executed, the program may include the processes of the embodiments of the methods as described above. The storage medium of the program may be a magnetic disk, an optical disk, a read-only memory (ROM), or a Random Access Memory (RAM). The embodiments of the computer program may achieve the same or similar effects as any of the above-described method embodiments corresponding thereto.
Furthermore, the methods disclosed according to embodiments of the present invention may also be implemented as a computer program executed by a processor, which may be stored in a computer-readable storage medium. Which when executed by a processor performs the above-described functions as defined in the method disclosed by an embodiment of the invention.
Further, the above method steps and system elements may also be implemented using a controller and a computer readable storage medium for storing a computer program for causing the controller to implement the functions of the above steps or elements.
Further, it should be understood that the computer-readable storage medium herein (e.g., memory) can be either volatile memory or nonvolatile memory, or can include both volatile and nonvolatile memory. By way of example, and not limitation, nonvolatile memory can include Read Only Memory (ROM), programmable ROM (PROM), electrically Programmable ROM (EPROM), electrically Erasable Programmable ROM (EEPROM), or flash memory. Volatile memory can include Random Access Memory (RAM), which can act as external cache memory. By way of example and not limitation, RAM is available in a variety of forms such as synchronous RAM (DRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), synchlink DRAM (SLDRAM), and Direct Rambus RAM (DRRAM). The storage devices of the disclosed aspects are intended to comprise, without being limited to, these and other suitable types of memory.
Those of skill would further appreciate that the various illustrative logical blocks, modules, circuits, and algorithm steps described in connection with the disclosure herein may be implemented as electronic hardware, computer software, or combinations of both. To clearly illustrate this interchangeability of hardware and software, various illustrative components, blocks, modules, circuits, and steps have been described above generally in terms of their functionality. Whether such functionality is implemented as software or hardware depends upon the particular application and design constraints imposed on the overall system. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present disclosure.
The various illustrative logical blocks, modules, and circuits described in connection with the disclosure herein may be implemented or performed with the following components designed to perform the functions herein: a general purpose processor, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Field Programmable Gate Array (FPGA) or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination of these components. A general purpose processor may be a microprocessor, but in the alternative, the processor may be any conventional processor, controller, microcontroller, or state machine. A processor may also be implemented as a combination of computing devices, e.g., a combination of a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors in conjunction with a DSP, and/or any other such configuration.
The steps of a method or algorithm described in connection with the disclosure herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. A software module may reside in RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art. An exemplary storage medium is coupled to the processor such the processor can read information from, and write information to, the storage medium. In the alternative, the storage medium may be integral to the processor. The processor and the storage medium may reside in an ASIC. The ASIC may reside in a user terminal. In the alternative, the processor and the storage medium may reside as discrete components in a user terminal.
In one or more exemplary designs, the functions may be implemented in hardware, software, firmware, or any combination thereof. If implemented in software, the functions may be stored on or transmitted over as one or more instructions or code on a computer-readable medium. Computer-readable media includes both computer storage media and communication media including any medium that facilitates transfer of a computer program from one place to another. A storage media may be any available media that can be accessed by a general purpose or special purpose computer. By way of example, and not limitation, such computer-readable media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a general-purpose or special-purpose computer, or a general-purpose or special-purpose processor. Also, any connection is properly termed a computer-readable medium. For example, if the software is transmitted from a website, server, or other remote source using a coaxial cable, fiber optic cable, twisted pair, digital Subscriber Line (DSL), or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio, and microwave are included in the definition of medium. Disk and disc, as used herein, includes Compact Disc (CD), laser disc, optical disc, digital Versatile Disc (DVD), floppy disk, blu-ray disc where disks usually reproduce data magnetically, while discs reproduce data optically with lasers. Combinations of the above should also be included within the scope of computer-readable media.
The foregoing are exemplary embodiments of the present disclosure, but it should be noted that various changes and modifications could be made herein without departing from the scope of the present disclosure as defined by the appended claims. The functions, steps and/or actions of the method claims in accordance with the disclosed embodiments described herein need not be performed in any particular order. Furthermore, although elements of the disclosed embodiments of the invention may be described or claimed in the singular, the plural is contemplated unless limitation to the singular is explicitly stated.
It should be understood that, as used herein, the singular forms "a", "an" and "the" are intended to include the plural forms as well, unless the context clearly supports the exception. It should also be understood that "and/or" as used herein is meant to include any and all possible combinations of one or more of the associated listed items.
The numbers of the embodiments disclosed in the embodiments of the present invention are merely for description, and do not represent the merits of the embodiments.
It will be understood by those skilled in the art that all or part of the steps for implementing the above embodiments may be implemented by hardware, or may be implemented by a program instructing relevant hardware, and the program may be stored in a computer-readable storage medium, where the above-mentioned storage medium may be a read-only memory, a magnetic disk or an optical disk.
Those of ordinary skill in the art will understand that: the discussion of any embodiment above is meant to be exemplary only, and is not intended to intimate that the scope of the disclosure, including the claims, of embodiments of the invention is limited to these examples; within the idea of an embodiment of the invention, also technical features in the above embodiment or in different embodiments may be combined and there are many other variations of the different aspects of the embodiments of the invention as described above, which are not provided in detail for the sake of brevity. Therefore, any omissions, modifications, substitutions, improvements, and the like that may be made without departing from the spirit and principles of the embodiments of the present invention are intended to be included within the scope of the embodiments of the present invention.
Claims (6)
1. A method for implementing type multi-inheritance, the method comprising:
extracting an interface from a method and an attribute which need to be inherited by each of a plurality of superclasses to be inherited;
recording the super class and the interface corresponding to the super class;
combining a plurality of the superclasses into a combined class through dynamic compiling, and configuring the combined class as the interface extracted by all the combined superclasses;
in response to implementing an interface method, the merge class transposes the methods that each correspond to the merged superclass;
wherein the interface for merging the plurality of superclasses into a merged class by dynamic compilation and configuring the merged class as a super class abstraction that implements all merges further comprises: finding the interfaces of the merged class and the merged super class through a configuration file; the dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javactiler in Java.
2. The method for implementing type multi-inheritance according to claim 1, wherein said recording of said super class and said interface corresponding to said super class further comprises:
and recording the super class and the interface corresponding to the super class through a configuration file.
3. An apparatus for implementing type multiple inheritance, wherein the apparatus comprises:
the interface extraction module is configured to extract an interface from the method and the attribute which need to be inherited by each of a plurality of superclasses to be inherited;
a recording module configured to record the super class and the interface corresponding to the super class;
a merging module configured to merge the plurality of superclasses into a merged class by dynamic compilation, and configure the merged class as the interface extracted from all the merged superclasses;
a method tuning module configured to tune the methods to which the merged superclass corresponds, in response to implementing an interface method, the merged class;
wherein the merge module is further configured to find the interfaces of the merged class and the merged super class from a configuration file; the dynamic compilation is implemented by Microsoft, CSharp, cschappProvider or Roslyn in DotNet or JavaCompailer in Java.
4. The apparatus for implementing type multiple inheritance according to claim 3, wherein the recording module is further configured to:
and recording the super class and the interface corresponding to the super class through a configuration file.
5. A computer device, comprising:
at least one processor; and
memory storing a computer program operable on the processor, characterized in that the processor, when executing the program, performs the method according to any of claims 1-2.
6. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, is adapted to carry out the method of any one of claims 1-2.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010221672.0A CN111427581B (en) | 2020-03-26 | 2020-03-26 | Method, device, equipment and medium for realizing type multi-inheritance |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010221672.0A CN111427581B (en) | 2020-03-26 | 2020-03-26 | Method, device, equipment and medium for realizing type multi-inheritance |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111427581A CN111427581A (en) | 2020-07-17 |
| CN111427581B true CN111427581B (en) | 2023-02-21 |
Family
ID=71548793
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010221672.0A Active CN111427581B (en) | 2020-03-26 | 2020-03-26 | Method, device, equipment and medium for realizing type multi-inheritance |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111427581B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111930363B (en) * | 2020-08-07 | 2023-11-24 | 抖音视界有限公司 | Block interface code generation method and device |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106201514A (en) * | 2016-07-11 | 2016-12-07 | 电子科技大学 | The structure of a kind of WebGIS Development Framework based on OpenLayers and using method |
| CN108196916A (en) * | 2017-12-18 | 2018-06-22 | 广州视源电子科技股份有限公司 | Method and device for parameter verification of interface, storage medium and electronic equipment |
| CN109960503A (en) * | 2017-12-26 | 2019-07-02 | 北京金风科创风电设备有限公司 | Component development method and device based on Django framework |
| CN110515676A (en) * | 2019-07-11 | 2019-11-29 | 平安普惠企业管理有限公司 | Interface integration method, device, equipment and storage medium |
| CN110704035A (en) * | 2019-10-17 | 2020-01-17 | 北京首贝科技发展有限公司 | Plug-in type software architecture system and implementation method thereof |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JPH047640A (en) * | 1990-04-25 | 1992-01-13 | Hitachi Ltd | Class succession settling processing method |
| US10528366B2 (en) * | 2017-06-05 | 2020-01-07 | International Business Machines Corporation | Facilitating multi-inheritance within a single inheritance container-based environment |
| CN110232088B (en) * | 2019-06-13 | 2021-03-26 | 华中师范大学 | Method and device for classification merging and storage medium |
-
2020
- 2020-03-26 CN CN202010221672.0A patent/CN111427581B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106201514A (en) * | 2016-07-11 | 2016-12-07 | 电子科技大学 | The structure of a kind of WebGIS Development Framework based on OpenLayers and using method |
| CN108196916A (en) * | 2017-12-18 | 2018-06-22 | 广州视源电子科技股份有限公司 | Method and device for parameter verification of interface, storage medium and electronic equipment |
| CN109960503A (en) * | 2017-12-26 | 2019-07-02 | 北京金风科创风电设备有限公司 | Component development method and device based on Django framework |
| CN110515676A (en) * | 2019-07-11 | 2019-11-29 | 平安普惠企业管理有限公司 | Interface integration method, device, equipment and storage medium |
| CN110704035A (en) * | 2019-10-17 | 2020-01-17 | 北京首贝科技发展有限公司 | Plug-in type software architecture system and implementation method thereof |
Non-Patent Citations (1)
| Title |
|---|
| Java代理模式;ALS Ritter;《https://alsritter.icu/posts/cffaadf/》;20200324;第1-14页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111427581A (en) | 2020-07-17 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110032599B (en) | Data structure reading and updating method and device, and electronic equipment | |
| RU2725690C1 (en) | Service processing method and device | |
| JP2021534486A (en) | Upgradeable securities tokens | |
| CN110032568B (en) | Data structure reading and updating method and device, and electronic equipment | |
| US8141035B2 (en) | Method for accessing internal states of objects in object oriented programming | |
| CN111881102A (en) | Method, device and readable medium for collecting audit logs based on AOP (automatic optical plane protocol) section | |
| CN107025253A (en) | A kind of method, database operation method and device for creating database interface | |
| CN108153806B (en) | Data migration | |
| CN111427581B (en) | Method, device, equipment and medium for realizing type multi-inheritance | |
| CN111159301A (en) | Data creating method, device, equipment and storage medium based on intelligent contract | |
| CN116974581B (en) | Code generation method, device, electronic equipment and storage medium | |
| WO2002046909A1 (en) | Automatically deploy and upgrade an application based on markup language application definition | |
| CN111176666B (en) | BIOS + ME mirror image refreshing method, system, equipment and readable medium | |
| CN110059088A (en) | Data attribute identification method, device and equipment in a kind of piece of chain type account book | |
| CN112925523A (en) | Object comparison method, device, equipment and computer readable medium | |
| CN112379871A (en) | Data processing method and device | |
| CN110059087B (en) | Data attribute identification method, device and equipment in block chain type account book | |
| CN112114778A (en) | Cross-platform dynamic library algorithm management system supporting horizontal extension | |
| CN108021389B (en) | Method and device for introducing ARouter into Android | |
| CN115951870A (en) | Mirror image file compiling method, system, equipment and medium | |
| CN113779132B (en) | Data importing method, device, computer equipment and storage medium | |
| CN112817580B (en) | Data processing method and device, electronic equipment and storage medium | |
| CN102768721B (en) | The method of control White List and device | |
| CN111444215A (en) | Blocking method, device and equipment in block chain type account book | |
| CN111858558B (en) | Application program modification method and device, readable storage medium and computer equipment |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20230406 Address after: 250101 Inspur science and Technology Park, 1036 Inspur Road, hi tech Zone, Jinan City, Shandong Province Patentee after: Inspur Genersoft Co.,Ltd. Address before: 250100 Room 102, 1st floor, R & D building, 2877 Kehang Road, Suncun Town, high tech Zone, Jinan City, Shandong Province Patentee before: SHANDONG INSPUR GENESOFT INFORMATION TECHNOLOGY Co.,Ltd. |
|
| TR01 | Transfer of patent right |