Object-oriented analysis and design is a crucial subject in computer science.

பொருள் சார்ந்த பகுப்பாய்வு மற்றும் வடிவமைப்பு கணினி அறிவியலில் ஒரு முக்கியமான பாடமாகும்.


The UML provides a standard way to write a system's blueprints.

UML ஒரு அமைப்பின் வரைபடங்களை எழுதுவதற்கான ஒரு நிலையான வழியை வழங்குகிறது.


A model is a simplification of reality; it helps us understand the system.

ஒரு மாதிரி என்பது யதார்த்தத்தின் எளிமைப்படுத்தல்; இது அமைப்பை புரிந்து கொள்ள உதவுகிறது.


Object-oriented development uses objects or classes as the main building blocks.

பொருள் சார்ந்த வளர்ச்சி, முக்கிய கட்டுமானத் தொகுதிகளாக பொருள்கள் அல்லது வகுப்புகளைப் பயன்படுத்துகிறது.


The Unified Modeling Language (UML) is a standard language for writing software blueprints.

ஒருங்கிணைந்த மாடலிங் மொழி (UML) மென்பொருள் வரைபடங்களை எழுதுவதற்கான ஒரு நிலையான மொழியாகும்.


Classes, relationships, and diagrams are fundamental to UML.

வகுப்புகள், உறவுகள் மற்றும் வரைபடங்கள் UML க்கு அடிப்படையானவை.


An interface describes the externally visible behavior of an element.

ஒரு இடைமுகம் ஒரு தனிமத்தின் வெளிப்புறமாக தெரியும் நடத்தையை விவரிக்கிறது.


Use cases are used to structure the behavioral things in a model.

ஒரு மாதிரியில் நடத்தை விஷயங்களை கட்டமைக்க பயன்பாட்டு வழக்குகள் பயன்படுத்தப்படுகின்றன.


Components are physical and replaceable parts of a system.

உறுப்புகள் ஒரு அமைப்பின் உடல் மற்றும் மாற்றக்கூடிய பாகங்கள் ஆகும்.


Nodes represent computational resources at runtime.

முனைகள் இயக்க நேரத்தில் கணக்கீட்டு வளங்களை பிரதிநிதித்துவப்படுத்துகின்றன.


Interactions involve messages exchanged among objects.

பொருள்களுக்கு இடையே பரிமாறிக்கொள்ளப்படும் செய்திகளை தொடர்புகள் உள்ளடக்கியுள்ளன.


State machines specify sequences of states an object goes through.

ஒரு பொருள் செல்லும் நிலைகளின் வரிசையை மாநில இயந்திரங்கள் குறிப்பிடுகின்றன.


Packages are used for organizing elements into groups.

உறுப்புகளை குழுக்களாக ஒழுங்கமைக்க தொகுப்புகள் பயன்படுத்தப்படுகின்றன.


A note is a symbol for rendering constraints and comments.

ஒரு குறிப்பு என்பது கட்டுப்பாடுகளையும் கருத்துகளையும் வழங்குவதற்கான ஒரு சின்னமாகும்.


Dependency is a semantic relationship between two things.

சார்ந்திருப்பது என்பது இரண்டு விஷயங்களுக்கு இடையேயான ஒரு சொற்பொருள் உறவாகும்.


Association describes a set of links among objects.

சங்கம் பொருள்களுக்கு இடையேயான இணைப்புகளின் தொகுப்பை விவரிக்கிறது.


Generalization represents a structural relationship between a whole and its parts.

பொதுமைப்படுத்துதல் என்பது ஒரு முழுமைக்கும் அதன் பகுதிகளுக்கும் இடையிலான ஒரு கட்டமைப்பு உறவை பிரதிபலிக்கிறது.


Realization is a semantic relationship between classifiers.

உணர்தல் என்பது வகைப்படுத்திகளுக்கு இடையேயான ஒரு சொற்பொருள் உறவாகும்.


Diagrams are graphical presentations of elements and relationships.

வரைபடங்கள் உறுப்புகள் மற்றும் உறவுகளின் வரைகலை விளக்கக்காட்சிகளாகும்.


The software development life cycle includes inception, elaboration, construction, and transition phases.

மென்பொருள் மேம்பாட்டு வாழ்க்கை சுழற்சியில் தொடக்கம், விரிவாக்கம், கட்டுமானம் மற்றும் மாற்றம் ஆகியவை அடங்கும்.


The software development process ends here, for even during this phase, the system is continuously improved.

மென்பொருள் உருவாக்கும் செயல்முறை இங்கே முடிவடைகிறது, ஏனெனில் இந்த கட்டத்தின் போதும் கூட, கணினி தொடர்ந்து மேம்படுத்தப்படுகிறது.


An iteration is a distinct set of activities, with a baselined plan and evaluation criteria that result in a release.

ஒரு மறுசெயல் என்பது ஒரு குறிப்பிட்ட செயல் தொகுப்பாகும், இது ஒரு அடிப்படைத் திட்டத்தையும் வெளியீட்டில் விளைவிக்கும் மதிப்பீட்டு அளவுகோல்களையும் கொண்டுள்ளது.


This means that the software development life cycle can be characterized as involving a continuous stream of executable releases.

இதன் பொருள் என்னவென்றால், மென்பொருள் உருவாக்கும் வாழ்க்கைச் சுழற்சியானது, செயல்படுத்தக்கூடிய வெளியீடுகளின் தொடர்ச்சியான ஓட்டத்தை உள்ளடக்கியதாக வகைப்படுத்தப்படலாம்.


It is this emphasis on architecture as an important artifact that drives the UML to focus on modeling the different views.

முக்கியமான ஒரு கருவியாக கட்டமைப்பிற்கு முக்கியத்துவம் கொடுப்பது, வெவ்வேறு பார்வைகளை மாதிரியாகக் கொண்டு வர UML-ஐ இயக்குகிறது.


A class is a description of a set of objects that share the same attributes, operations, relationships, and semantics.

ஒரு வகுப்பு என்பது ஒரே பண்புக்கூறுகள், செயல்பாடுகள், உறவுகள் மற்றும் சொற்பொருள் கொண்ட பொருள்களின் தொகுப்பை விவரிப்பதாகும்.


Every class must have a name that distinguishes it from other classes.

ஒவ்வொரு வகுப்பும் மற்ற வகுப்புகளிலிருந்து வேறுபடுத்தக்கூடிய ஒரு பெயரைக் கொண்டிருக்க வேண்டும்.


An attribute is a named property of a class that describes a range of values.

ஒரு பண்புக்கூறு என்பது ஒரு வகுப்பின் பெயரிடப்பட்ட சொத்தாகும், இது மதிப்புகளின் வரம்பை விவரிக்கிறது.


An operation is the implementation of a service that can be requested from any object of the class.

ஒரு செயல்பாடு என்பது ஒரு சேவையை செயல்படுத்துவதாகும், இது வகுப்பின் எந்தப் பொருளிலும் இருந்து கோரப்படலாம்.


A Responsibility is a contract or an obligation of a class.

ஒரு பொறுப்பு என்பது ஒரு வகுப்பின் ஒப்பந்தம் அல்லது கடமையாகும்.


You'll use classes most commonly to model abstractions that are drawn from the problem you are trying to solve.

நீங்கள் பொதுவாக வகுப்புகளைப் பயன்படுத்தி, நீங்கள் தீர்க்க முயற்சிக்கும் சிக்கலில் இருந்து பெறப்பட்ட கருத்துருக்களை மாதிரியாகக் காண்பீர்கள்.


Identify those things that users or implementers use to describe the problem or solution.

பயனர்கள் அல்லது செயல்படுத்துபவர்கள் சிக்கல் அல்லது தீர்வை விவரிக்கப் பயன்படுத்துவதை அடையாளம் காணவும்.


Provide the attributes and operations that are needed to carry out these responsibilities for each class.

ஒவ்வொரு வகுப்பிற்கும் இந்த பொறுப்புகளை நிறைவேற்ற தேவையான பண்புக்கூறுகள் மற்றும் செயல்பாடுகளை வழங்கவும்.


Model the thing you are abstracting as a class.

நீங்கள் சுருக்கமாகக் கூறும் விஷயத்தை ஒரு வகுப்பாக மாதிரியாகக் கொள்ளுங்கள்.


Model the thing you are abstracting as a type or an enumeration.

நீங்கள் சுருக்கமாகக் கூறும் விஷயத்தை ஒரு வகையாகவோ அல்லது எண்ணாகவோ மாதிரியாகக் கொள்ளுங்கள்.


In the UML, the ways that things can connect to one another are modeled as relationships.

UML இல், விஷயங்கள் ஒன்றோடொன்று இணைக்கக்கூடிய வழிகள் உறவுகளாக மாதிரியாகக் காட்டப்படுகின்றன.


சார்ந்திருப்பது உறவுகளைப் பயன்படுத்துகிறது.


Generalizations connect generalized classes to more-specialized ones.

பொதுமைப்படுத்தல்கள் பொதுமைப்படுத்தப்பட்ட வகுப்புகளை மிகவும் சிறப்பு வாய்ந்தவற்றுடன் இணைக்கின்றன.


Associations are structural relationships among instances.

சங்கங்கள் நிகழ்வுகளுக்கு இடையேயான கட்டமைப்பு உறவுகளாகும்.


A dependency is a using relationship that states that a change in specification of one thing may affect another thing.

ஒரு சார்புநிலை என்பது ஒரு உறவைப் பயன்படுத்துவதாகும், இது ஒரு விஷயத்தின் விவரக்குறிப்பில் ஏற்படும் மாற்றம் மற்றொரு விஷயத்தைப் பாதிக்கலாம் என்று கூறுகிறது.


A generalization is a relationship between a general thing and a more specific kind of that thing.

ஒரு பொதுமைப்படுத்தல் என்பது ஒரு பொதுவான விஷயம் மற்றும் அந்த விஷயத்தின் மிகவும் குறிப்பிட்ட வகைக்கும் இடையிலான உறவாகும்.


Object Oriented Analysis and design, Dept. of CSE, RGMCET

பொருள் சார்ந்த பகுப்பாய்வு மற்றும் வடிவமைப்பு, கணினி அறிவியல் மற்றும் பொறியியல் துறை, RGMCET


Package logically related sets of these operations and signals as interfaces.

இந்த செயல்பாடுகள் மற்றும் சிக்னல்களின் தர்க்கரீதியாக தொடர்புடைய தொகுப்புகளை இடைமுகங்களாக தொகுக்கவும்.


For each such collaboration in your system, identify the interfaces it relies on (imports) and those it provides to others (exports).

உங்கள் கணினியில் உள்ள ஒவ்வொரு ஒத்துழைப்பிற்கும், அது சார்ந்திருக்கும் இடைமுகங்களை (இறக்குமதி) மற்றும் மற்றவர்களுக்கு வழங்கும் இடைமுகங்களை (ஏற்றுமதி) அடையாளம் காணவும்.


You model the importing of interfaces by dependency relationships, and you model the exporting of interfaces by realization relationships.

நீங்கள் இடைமுகங்களைச் சார்ந்திருத்தல் உறவுகள் மூலம் இறக்குமதி செய்வதை மாதிரியாகக் கொள்ளலாம், மேலும் உருவகப்படுத்துதல் உறவுகள் மூலம் இடைமுகங்களை ஏற்றுமதி செய்வதை மாதிரியாகக் கொள்ளலாம்.


For each such interface in your system, document its dynamics by using pre- and postconditions for each operation, and use cases and state machines for the interface as a whole.

உங்கள் கணினியில் உள்ள ஒவ்வொரு இடைமுகத்திற்கும், ஒவ்வொரு செயல்பாட்டிற்கும் முன் மற்றும் பிந்தைய நிபந்தனைகளைப் பயன்படுத்துவதன் மூலம் அதன் இயக்கவியலை ஆவணப்படுத்தவும், மேலும் முழு இடைமுகத்திற்கும் பயன்பாட்டு நிகழ்வுகள் மற்றும் மாநில இயந்திரங்களைப் பயன்படுத்தவும்.


This component realizes three interfaces: IUnknown, ILedger, and IReports.

இந்த கூறு மூன்று இடைமுகங்களை செயல்படுத்துகிறது: IUnknown, ILedger மற்றும் IReports.


These three interfaces are realized by ledger.dll and are exported to other components for them to build on.

இந்த மூன்று இடைமுகங்களும் ledger.dll மூலம் செயல்படுத்தப்படுகின்றன, மேலும் மற்ற கூறுகள் அவற்றின் மீது கட்டமைக்க ஏற்றுமதி செய்யப்படுகின்றன.


Therefore, in a running system, you must supply components that realize these two interfaces.

எனவே, இயங்கும் கணினியில், இந்த இரண்டு இடைமுகங்களை செயல்படுத்தும் கூறுகளை நீங்கள் வழங்க வேண்டும்.


By identifying interfaces such as ITransaction, you've effectively decoupled the components on either side of the interface, permitting you to employ any component that conforms to that interface.

ITransaction போன்ற இடைமுகங்களை அடையாளம் காண்பதன் மூலம், இடைமுகத்தின் இருபுறமும் உள்ள கூறுகளை நீங்கள் திறம்பட துண்டித்துள்ளீர்கள், மேலும் அந்த இடைமுகத்திற்கு இணங்கக்கூடிய எந்தவொரு கூறையும் பயன்படுத்த உங்களை அனுமதிக்கிறது.


Most object-oriented programming languages are statically typed.

பெரும்பாலான பொருள் சார்ந்த நிரலாக்க மொழிகள் நிலையாக தட்டச்சு செய்யப்படுகின்றன.


Modeling the static nature of an object can be visualized in a class diagram.

ஒரு பொருளின் நிலையான தன்மையை ஒரு வகுப்பு வரைபடத்தில் காட்சிப்படுத்தலாம்.


However, when you are modeling things like business objects, which naturally change their roles throughout a workflow...

இருப்பினும், வணிகப் பொருள்கள் போன்றவற்றை நீங்கள் மாதிரியாகக் கொண்டிருக்கும்போது, அவை இயற்கையாகவே ஒரு பணிப்பாய்வின் மூலம் தங்கள் பாத்திரங்களை மாற்றுகின்றன...


Specify the different possible types of that object by rendering each type as a class stereotyped as type.

ஒவ்வொரு வகையையும் வகையாக வகைப்படுத்தப்பட்ட ஒரு வகுப்பாக வழங்குவதன் மூலம் அந்த பொருளின் வெவ்வேறு சாத்தியமான வகைகளை குறிப்பிடவும்.


Model all the roles the of the object may take on at any point in time.

எந்த நேரத்திலும் பொருள் வகிக்கக்கூடிய அனைத்து பாத்திரங்களையும் மாதிரியாகக் கொள்ளுங்கள்.


A package is a general-purpose mechanism for organizing elements into groups.

ஒரு தொகுப்பு என்பது கூறுகளை குழுக்களாக ஒழுங்கமைப்பதற்கான ஒரு பொதுவான நோக்கத்திற்கான வழிமுறையாகும்.


Every package must have a name that distinguishes it from other packages.

ஒவ்வொரு தொகுப்பும் மற்ற தொகுப்புகளிலிருந்து வேறுபடுத்தக்கூடிய ஒரு பெயரைக் கொண்டிருக்க வேண்டும்.


We may draw packages adorned with tagged values or with additional compartments to expose their details.

குறிப்பிடப்பட்ட மதிப்புகள் அல்லது கூடுதல் பெட்டிகளுடன் அலங்கரிக்கப்பட்ட தொகுப்புகளை அவற்றின் விவரங்களை வெளிப்படுத்தலாம்.


A package may own other elements, including classes, interfaces, components, nodes, collaborations, use cases, diagrams, and even other packages.

ஒரு தொகுப்பு வகுப்புகள், இடைமுகங்கள், கூறுகள், முனைகள், ஒத்துழைப்புகள், பயன்பாட்டு நிகழ்வுகள், வரைபடங்கள் மற்றும் பிற தொகுப்புகள் உட்பட பிற கூறுகளை சொந்தமாக வைத்திருக்கலாம்.


Packages may own other packages. This means that it's possible to decompose your models hierarchically.

தொகுப்புகள் மற்ற தொகுப்புகளை சொந்தமாக வைத்திருக்கலாம். இதன் பொருள் உங்கள் மாதிரிகளை படிநிலை முறையில் சிதைக்க முடியும்.


You can control the visibility of the elements owned by a package just as you can control the visibility of the attributes and operations owned by a class.

ஒரு வகுப்பால் சொந்தமான பண்புக்கூறுகள் மற்றும் செயல்பாடுகளின் தெரிவுநிலையை நீங்கள் கட்டுப்படுத்துவது போலவே, ஒரு தொகுப்பால் சொந்தமான கூறுகளின் தெரிவுநிலையையும் கட்டுப்படுத்தலாம்.


Figure shows four subsystems, each of which has been extended to include its version number and status.

படத்தில் நான்கு துணை அமைப்புகள் காட்டப்பட்டுள்ளன, ஒவ்வொன்றும் அதன் பதிப்பு எண் மற்றும் நிலையைக் கொண்டுள்ளது.


In the case of the Billing subsystem, one other tagged value is shown the person who has currently checked out the subsystem.

பில்லிங் துணை அமைப்பின் விஷயத்தில், தற்போது துணை அமைப்பை சரிபார்த்த நபரின் மற்றொரு குறிச்சொல் மதிப்பு காட்டப்பட்டுள்ளது.


When you create a model using the UML, you work within the rules the UML lays down.

நீங்கள் UML ஐப் பயன்படுத்தி ஒரு மாதிரியை உருவாக்கும்போது, UML வகுத்துள்ள விதிகளுக்குள் வேலை செய்கிறீர்கள்.


However, if you find yourself needing to express new semantics about which the UML is silent or that you need to modify the UML's rules, then you need to write a constraint.

இருப்பினும், UML அமைதியாக இருக்கும் அல்லது UML இன் விதிகளை மாற்றியமைக்க வேண்டிய புதிய சொற்பொருளை வெளிப்படுத்த வேண்டியிருந்தால், நீங்கள் ஒரு தடையை எழுத வேண்டும்.


To model new semantics, first, make sure there's not already a way to express what you want by using basic UML.

புதிய சொற்பொருளை மாதிரியாக உருவாக்க, முதலில், அடிப்படை UML ஐப் பயன்படுத்தி நீங்கள் விரும்புவதை வெளிப்படுத்த ஏற்கனவே வழி இல்லையா என்பதை உறுதிப்படுத்தவும்.


If you're convinced there's no other way to express these semantics, write your new semantics as text in a constraint and place it adjacent to the element to which it refers.

இந்த சொற்பொருளை வெளிப்படுத்த வேறு வழியில்லை என்று நீங்கள் நம்பினால், உங்கள் புதிய சொற்பொருளை ஒரு தடையாக உரையாக எழுதி, அது குறிப்பிடும் உறுப்புக்கு அருகில் வைக்கவும்.


This diagram shows that each Person may be a member of zero or more Departments and that each Department must have at least one Person as a member.

இந்த வரைபடம் ஒவ்வொரு நபரும் பூஜ்ஜியம் அல்லது அதற்கு மேற்பட்ட துறைகளின் உறுப்பினராக இருக்கலாம் என்பதையும், ஒவ்வொரு துறையும் குறைந்தபட்சம் ஒரு நபரையாவது உறுப்பினராக வைத்திருக்க வேண்டும் என்பதையும் காட்டுகிறது.


When you view a software system from any perspective using the UML, you use diagrams to organize the elements of interest.

நீங்கள் UML ஐப் பயன்படுத்தி எந்தப் பார்வையிலிருந்தும் ஒரு மென்பொருள் அமைப்பைப் பார்க்கும்போது, விருப்பமான கூறுகளை ஒழுங்கமைக்க வரைபடங்களைப் பயன்படுத்துகிறீர்கள்.


The UML defines nine kinds of diagrams, which you can mix and match to assemble each view.

UML ஒன்பது வகையான வரைபடங்களை வரையறுக்கிறது, அவற்றை நீங்கள் கலந்து ஒவ்வொரு காட்சியையும் உருவாக்கலாம்.


You'll use the UML's diagrams in two basic ways: To specify models from which you'll construct an executable system (forward engineering).

நீங்கள் UML இன் வரைபடங்களை இரண்டு அடிப்படை வழிகளில் பயன்படுத்துவீர்கள்: நீங்கள் செயல்படுத்தக்கூடிய ஒரு அமைப்பை உருவாக்குவதற்கான மாதிரிகளைத் தீர்மானிக்க (முன்னோக்கு பொறியியல்).


A system is a collection of subsystems organized to accomplish a purpose and described by a set of models, possibly from different viewpoints.

ஒரு அமைப்பு என்பது ஒரு நோக்கத்தை நிறைவேற்ற ஒழுங்கமைக்கப்பட்ட மற்றும் பல்வேறு கண்ணோட்டங்களில் இருந்து விவரிக்கப்படும் துணை அமைப்புகளின் தொகுப்பாகும்.


A diagram is the graphical presentation of a set of elements, most often rendered as a connected graph of vertices (things) and arcs (relationships).

ஒரு வரைபடம் என்பது கூறுகளின் தொகுப்பின் வரைகலை விளக்கமாகும், இது பெரும்பாலும் முனைகள் (பொருள்கள்) மற்றும் வளைவுகள் (உறவுகள்) ஆகியவற்றின் இணைக்கப்பட்ட வரைபடமாக வழங்கப்படுகிறது.


The UML's four structural diagrams exist to visualize, specify, construct, and document the static aspects of a system.

UML இன் நான்கு கட்டமைப்பு வரைபடங்கள் ஒரு அமைப்பின் நிலையான அம்சங்களைக் காட்சிப்படுத்தவும், குறிப்பிடவும், உருவாக்கவும் மற்றும் ஆவணப்படுத்தவும் உள்ளன.


We use class diagrams to illustrate the static design view of a system.

ஒரு அமைப்பின் நிலையான வடிவமைப்புப் பார்வையை விளக்க வகுப்பறை வரைபடங்களைப் பயன்படுத்துகிறோம்.


We use deployment diagrams to illustrate the static deployment view of an architecture.

ஒரு கட்டமைப்பின் நிலையான வரிசைப்படுத்தல் பார்வையை விளக்க வரிசைப்படுத்தல் வரைபடங்களைப் பயன்படுத்துகிறோம்.


The UML's five behavioral diagrams are used to visualize, specify, construct, and document the dynamic aspects of a system.

UML இன் ஐந்து நடத்தை வரைபடங்கள் ஒரு அமைப்பின் இயக்கவியல் அம்சங்களைக் காட்சிப்படுத்தவும், குறிப்பிடவும், உருவாக்கவும் மற்றும் ஆவணப்படுத்தவும் பயன்படுகின்றன.


We apply use case diagrams to illustrate the static use case view of a system.

ஒரு அமைப்பின் நிலையான பயன்பாட்டு வழக்குக் காட்சியை விளக்க பயன்பாட்டு வழக்கு வரைபடங்களைப் பயன்படுத்துகிறோம்.


We use sequence diagrams to illustrate the dynamic view of a system.

ஒரு அமைப்பின் இயக்கவியல் காட்சியைக் காட்ட வரிசை வரைபடங்களைப் பயன்படுத்துகிறோம்.


When you model a system from different views, you are in effect constructing your system simultaneously from multiple dimensions.

நீங்கள் வெவ்வேறு காட்சிகளிலிருந்து ஒரு அமைப்பை மாதிரியாக உருவாக்கும்போது, நீங்கள் உண்மையில் உங்கள் அமைப்பை ஒரே நேரத்தில் பல பரிமாணங்களிலிருந்து உருவாக்குகிறீர்கள்.


Classes are indeed the most important building block of any object-oriented system.

வகுப்புகள் உண்மையில் எந்தவொரு பொருள் சார்ந்த அமைப்பின் மிக முக்கியமான கட்டுமானத் தொகுதியாகும்.


வகுப்பிற்கான ஒரு மாநில இயந்திரத்தை வரையறுக்கவும்.


A relationship is a connection among things.

ஒரு உறவு என்பது விஷயங்களுக்கு இடையேயான ஒரு இணைப்பு ஆகும்.


Graphically, a relationship is rendered as a path, with different kinds of lines used to distinguish the different relationships.

வரைபட ரீதியாக, ஒரு உறவு ஒரு பாதையாக வழங்கப்படுகிறது, மேலும் வெவ்வேறு வகையான கோடுகள் வெவ்வேறு உறவுகளை வேறுபடுத்தப் பயன்படுகின்றன.


A dependency is a using relationship, specifying that a change in the specification of one thing may affect another thing that uses it.

ஒரு சார்புநிலை என்பது ஒரு உறவைப் பயன்படுத்துவதாகும், இது ஒரு விஷயத்தின் விவரக்குறிப்பில் ஏற்படும் மாற்றம் அதைப் பயன்படுத்தும் மற்றொரு விஷயத்தைப் பாதிக்கலாம் என்று குறிப்பிடுகிறது.


There are 17 such stereotypes, all of which can be organized into six groups.

அத்தகைய 17 உருவகங்கள் உள்ளன, இவை அனைத்தும் ஆறு குழுக்களாக ஒழுங்கமைக்கப்படலாம்.


Specifies that the source instantiates the target template using the given actual parameters.

கொடுக்கப்பட்ட உண்மையான அளவுருக்களைப் பயன்படுத்தி, மூலம் இலக்கு டெம்ப்ளேட்டை உதாரணப்படுத்துகிறது.


A generalization is a relationship between a general thing and a more specific kind of that thing.

ஒரு பொதுமைப்படுத்தல் என்பது ஒரு பொதுவான விஷயம் மற்றும் அந்த விஷயத்தின் மிகவும் குறிப்பிட்ட வகைக்கும் இடையிலான உறவாகும்.


In a generalization relationship, instances of the child may be used anywhere instances of the parent apply.

ஒரு பொதுமைப்படுத்தல் உறவில், குழந்தையின் நிகழ்வுகளை பெற்றோர் பயன்படுத்தும் எந்த இடத்திலும் பயன்படுத்தலாம்.


An association is a structural relationship, specifying that objects of one thing are connected to objects of another.

ஒரு தொடர்பு என்பது ஒரு கட்டமைப்பு உறவாகும், இது ஒரு விஷயத்தின் பொருள்கள் மற்றொன்றின் பொருள்களுடன் இணைக்கப்பட்டுள்ளன என்று குறிப்பிடுகிறது.


We use associations when you want to show structural relationships.

கட்டமைப்பு உறவுகளைக் காட்ட விரும்பும் போது நாங்கள் தொடர்புகளைப் பயன்படுத்துகிறோம்.


There are four basic adornments that apply to an association: a name, the role at each end of the association, the multiplicity at each end of the association, and aggregation.

ஒரு தொடர்புக்குப் பயன்படுத்தப்படும் நான்கு அடிப்படை அலங்காரங்கள் உள்ளன: ஒரு பெயர், சங்கத்தின் ஒவ்வொரு முனையிலும் உள்ள பங்கு, சங்கத்தின் ஒவ்வொரு முனையிலும் உள்ள பெருக்கம் மற்றும் திரட்டுதல்.


Unless otherwise specified, navigation across an association is bidirectional.

வேறுவிதமாகக் குறிப்பிடப்படாவிட்டால், ஒரு சங்கத்தின் குறுக்கே வழிசெலுத்தல் இரு திசையிலும் இருக்கும்.


You can explicitly represent the direction of navigation by adorning an association with an arrowhead pointing to the direction of traversal.

ஒரு அம்புக்குறியுடன் ஒரு சங்கத்தை அலங்கரிப்பதன் மூலம் வழிசெலுத்தலின் திசையை நீங்கள் வெளிப்படையாகக் குறிப்பிடலாம், இது பயணத்தின் திசையைச் சுட்டிக்காட்டுகிறது.


Given an association between two classes, objects of one class can see and navigate to objects of the other, unless otherwise restricted.

இரண்டு வகுப்புகளுக்கு இடையேயான ஒரு தொடர்பைக் கொடுத்தால், ஒரு வகுப்பின் பொருள்கள் மற்றொன்றின் பொருள்களைப் பார்க்கலாம் மற்றும் செல்லலாம், வேறுவிதமாகக் கட்டுப்படுத்தப்படாவிட்டால்.


In the UML, you'd model this idiom using a qualifier, which is an association attribute whose values partition the set of objects related to an object across an association.

UML இல், நீங்கள் இந்த சொல்லை ஒரு தகுதிவாய்ந்ததைப் பயன்படுத்தி மாதிரியாகக் கூறுவீர்கள், இது ஒரு தொடர்பு பண்புக்கூறாகும், இதன் மதிப்புகள் ஒரு சங்கத்தின் குறுக்கே ஒரு பொருளுடன் தொடர்புடைய பொருள்களின் தொகுப்பை பிரிக்கின்றன.


An interface is a collection of operations that are used to specify a service of a class or a component.

ஒரு இடைமுகம் என்பது ஒரு வகுப்பு அல்லது ஒரு கூறுபாட்டின் சேவையைச் சிறப்பாகப் பயன்படுத்தப்படும் செயல்பாடுகளின் தொகுப்பாகும்.


Composition is a form of aggregation, with strong ownership and coincident lifetime as part of the whole.

கலவை என்பது திரட்டலின் ஒரு வடிவமாகும், இது வலுவான உரிமையையும் முழுமையின் ஒரு பகுதியாக இருக்கும் தற்செயலான வாழ்நாளையும் கொண்டுள்ளது.


In an association between two classes, the association itself might have properties.

இரண்டு வகுப்புகளுக்கு இடையேயான ஒரு தொடர்பில், அந்த தொடர்புக்கே பண்புகள் இருக்கலாம்.


Realization is sufficiently different from dependency, generalization, and association relationships that it is treated as a separate kind of relationship.

உணர்தல், சார்புநிலை, பொதுமைப்படுத்தல் மற்றும் தொடர்பு உறவுகளிலிருந்து போதுமான அளவு வேறுபட்டது, இது ஒரு தனி வகையான உறவாகக் கருதப்படுகிறது.


When you model the vocabulary of a complex system, you may encounter dozens, if not hundreds or thousands, of classes, interfaces, components, nodes, and use cases.

ஒரு சிக்கலான அமைப்பின் சொற்களஞ்சியத்தை நீங்கள் மாதிரியாகக் கூறும்போது, நீங்கள் டஜன் கணக்கான, நூற்றுக்கணக்கான அல்லது ஆயிரக்கணக்கான வகுப்புகள், இடைமுகங்கள், கூறுகள், முனைகள் மற்றும் பயன்பாட்டு நிகழ்வுகளைக் காணலாம்.


உங்கள் வரைபடம் மிகவும் எளிமையானது.


Expand the neighbors of certain interesting objects.

சில சுவாரஸ்யமான பொருட்களின் அண்டை வீட்டார்களை விரிவுபடுத்துங்கள்.


ஒவ்வொரு பொருளின் நிலையையும் ஆழமாக வெளிப்படுத்துங்கள்.


An interaction is a behavior that comprises a set of messages exchanged among a set of objects.

ஒரு தொடர்பு என்பது ஒரு நடத்தை ஆகும், இது ஒரு தொகுப்பு பொருட்களுக்கு இடையில் பரிமாறிக்கொள்ளப்படும் செய்திகளின் தொகுப்பைக் கொண்டுள்ளது.


A message is a specification of a communication between objects.

ஒரு செய்தி என்பது பொருட்களுக்கு இடையேயான தகவல்தொடர்பு பற்றிய விவரக்குறிப்பாகும்.


The UML provides a graphical representation of messages.

UML செய்திகளின் வரைகலை பிரதிநிதித்துவத்தை வழங்குகிறது.


This notation permits you to visualize a message.

இந்தக் குறியீடு ஒரு செய்தியை காட்சிப்படுத்த உங்களை அனுமதிக்கிறது.


A message is rendered as a directed line.

ஒரு செய்தி ஒரு திசையுள்ள கோடாக வழங்கப்படுகிறது.


Graphically, a message is rendered as a directed line.

வரைபட ரீதியாக, ஒரு செய்தி ஒரு திசையுள்ள கோடாக வழங்கப்படுகிறது.


An interaction is a behavior that comprises a set of messages.

ஒரு தொடர்பு என்பது ஒரு நடத்தை ஆகும், இது செய்திகளின் தொகுப்பைக் கொண்டுள்ளது.


We can use interactions to visualize, specify, construct, and document the semantics of a class.

ஒரு வகுப்பின் சொற்பொருளைக் காட்சிப்படுத்த, குறிப்பிட, உருவாக்க மற்றும் ஆவணப்படுத்த தொடர்புகளைப் பயன்படுத்தலாம்.


We may find an interaction wherever objects are linked to one another.

பொருட்கள் ஒன்றோடொன்று இணைக்கப்பட்டுள்ள இடங்களில் ஒரு தொடர்பைக் காணலாம்.


We'll find interactions in the collaboration of objects.

பொருட்களின் ஒத்துழைப்பில் தொடர்புகளைக் காண்போம்.


We will also find interactions in the context of an operation.

ஒரு செயல்பாட்டின் சூழலில் தொடர்புகளையும் காணலாம்.


We might create interactions that show how the attributes of that class collaborate with one another.

அந்த வகுப்பின் பண்புக்கூறுகள் எவ்வாறு ஒன்றோடொன்று ஒத்துழைக்கின்றன என்பதைக் காட்டும் தொடர்புகளை நாம் உருவாக்கலாம்.


The objects that participate in an interaction are either concrete things or prototypical things.

ஒரு தொடர்பில் பங்கேற்கும் பொருள்கள் ஒன்று உறுதியானவை அல்லது முன்மாதிரியானவை.


As a concrete thing, an object represents something in the real world.

ஒரு உறுதியான பொருளாக, ஒரு பொருள் நிஜ உலகில் உள்ள ஒன்றை பிரதிபலிக்கிறது.


A link is a semantic connection among objects.

ஒரு இணைப்பு என்பது பொருட்களுக்கு இடையேயான ஒரு சொற்பொருள் தொடர்பு ஆகும்.


Wherever a class has an association to another class, there may be a link between the instances of the two classes.

ஒரு வகுப்பிற்கு மற்றொரு வகுப்போடு தொடர்பு இருக்கும் இடத்தில், இரண்டு வகுப்புகளின் நிகழ்வுகளுக்கு இடையில் ஒரு இணைப்பு இருக்கலாம்.


A message is the specification of a communication among objects.


இது பணிப்பாய்வை விளக்கும் ஒரு வரைபடம்.


வாடிக்கையாளர் ஒரு பொருளைத் திருப்பித் தரக் கோருகிறார்.


The item is shipped back to the warehouse.

பொருள் கிடங்கிற்கு திருப்பி அனுப்பப்படுகிறது.


An activity diagram can be attached to any modeling element.

செயல்பாட்டு வரைபடம் எந்த ஒரு மாதிரி உறுப்புடனும் இணைக்கப்படலாம்.


Forward engineering creates code from a model.

முன்னோக்கு பொறியியல் ஒரு மாதிரியிலிருந்து குறியீட்டை உருவாக்குகிறது.


Reverse engineering creates a model from code.

பின்னோக்கு பொறியியல் குறியீட்டிலிருந்து ஒரு மாதிரியை உருவாக்குகிறது.


நிகழ்வுகள் எதிர்பாராத நேரங்களில் நிகழ்கின்றன.


நிகழ்வுகள் நிலை மாற்றங்களை தூண்டலாம்.


சிக்னல்கள் ஒத்திசைவற்ற நிகழ்வுகள்.


அழைப்புகள் பொதுவாக ஒத்திசைவான நிகழ்வுகள்.


A time event represents the passage of time.

நேர நிகழ்வு நேரத்தின் போக்கை குறிக்கிறது.


A change event represents a change in state.

மாற்ற நிகழ்வு நிலையில் ஒரு மாற்றத்தைக் குறிக்கிறது.


Signals and calls involve at least two objects.

சிக்னல்களும் அழைப்புகளும் குறைந்தது இரண்டு பொருட்களை உள்ளடக்கியவை.


விதிவிலக்குகள் ஒரு வகையான சிக்னல்கள்.


A state machine specifies sequences of states.

ஒரு நிலை இயந்திரம் நிலைகளின் வரிசையை குறிப்பிடுகிறது.


A state is a condition during the life of an object.

ஒரு நிலை என்பது ஒரு பொருளின் வாழ்க்கையில் ஒரு நிபந்தனை.


A transition indicates an object entering a new state.

ஒரு மாற்றம் ஒரு பொருள் புதிய நிலைக்குள் நுழைவதைக் குறிக்கிறது.


ஒரு நிகழ்வு ஒரு நிலை மாற்றத்தைத் தூண்டுகிறது.


A guard condition is a Boolean expression.

ஒரு காப்பு நிபந்தனை என்பது ஒரு பூலியன் வெளிப்பாடு ஆகும்.


Actions are executable atomic computations.

செயல்கள் செயல்படுத்தக்கூடிய அணுசக்தி கணக்கீடுகள்.


The system checks the PIN number to see if it is valid.

இந்த அமைப்பு பின் எண்ணை சரிபார்த்து அது சரியானதா என அறியும்.


If the PIN number is valid, the system acknowledges the entry.

பின் எண் சரியானதாக இருந்தால், அமைப்பு உள்ளீட்டை அங்கீகரிக்கும்.


The Customer can cancel a transaction at any time by pressing the Cancel button.

வாடிக்கையாளர் எந்த நேரத்திலும் ரத்து பொத்தானை அழுத்துவதன் மூலம் பரிவர்த்தனையை ரத்து செய்யலாம்.


No changes are made to the Customer's account.

வாடிக்கையாளரின் கணக்கில் எந்த மாற்றமும் செய்யப்படாது.


If the Customer enters an invalid PIN number, the use case restarts.

வாடிக்கையாளர் தவறான பின் எண்ணை உள்ளிடும்போது, பயன்பாட்டு நிகழ்வு மீண்டும் தொடங்கும்.


Use case describes a set of sequences, not just a single sequence.

பயன்பாட்டு நிகழ்வு ஒரு வரிசையை மட்டும் அல்லாமல், பல வரிசைகளை விவரிக்கிறது.


ஒவ்வொரு வரிசையும் ஒரு காட்சி என்று அழைக்கப்படுகிறது.


A scenario is a specific sequence of actions that illustrates behavior.

ஒரு காட்சி என்பது நடத்தையை விளக்கும் குறிப்பிட்ட செயல்களின் வரிசையாகும்.


A use case captures the intended behavior of the system.

ஒரு பயன்பாட்டு நிகழ்வு, நீங்கள் உருவாக்கும் அமைப்பின் நோக்கத்தை விளக்குகிறது.


You can explicitly specify the realization of a use case by a collaboration.

ஒரு கூட்டு முயற்சியின் மூலம் ஒரு பயன்பாட்டு நிகழ்வின் உண்மையை நீங்கள் வெளிப்படையாகக் குறிப்பிடலாம்.


We can organize use cases by grouping them in packages.

பயன்பாட்டு நிகழ்வுகளை தொகுப்புகளாக குழுப்படுத்துவதன் மூலம் ஒழுங்கமைக்கலாம்.


You can also organize use cases by specifying generalization, include, and extend relationships.

பொதுமைப்படுத்தல், உள்ளடக்குதல் மற்றும் நீட்டிப்பு உறவுகளைக் குறிப்பிடுவதன் மூலம் பயன்பாட்டு நிகழ்வுகளை ஒழுங்கமைக்கலாம்.


An include relationship between use cases means that the base use case explicitly incorporates the behavior of another use case.

பயன்பாட்டு நிகழ்வுகளுக்கு இடையேயான ஒரு உள்ளடக்கிய உறவு, அடிப்படை பயன்பாட்டு நிகழ்வு மற்றொரு பயன்பாட்டு நிகழ்வின் நடத்தையை வெளிப்படையாக உள்ளடக்குகிறது என்று பொருள்.


We use an extend relationship to model the part of a use case the user may see as optional system behavior.

பயனர்கள் விருப்பமான கணினி நடத்தை எனப் பார்க்கக்கூடிய பயன்பாட்டு நிகழ்வின் பகுதியை மாதிரியாகக் காட்ட நீட்டிப்பு உறவைப் பயன்படுத்துகிறோம்.


Use cases are classifiers, so they may have attributes and operations.

பயன்பாட்டு நிகழ்வுகள் வகைப்படுத்திகள், எனவே அவை பண்புக்கூறுகளையும் செயல்பாடுகளையும் கொண்டிருக்கலாம்.


You can think of these attributes as the objects inside the use case.

இந்த பண்புக்கூறுகளை பயன்பாட்டு நிகழ்வுக்குள் இருக்கும் பொருள்களாக நீங்கள் கருதலாம்.


We can use state machines as yet another way to describe the behavior represented by a use case.

ஒரு பயன்பாட்டு நிகழ்வால் குறிப்பிடப்படும் நடத்தையை விவரிக்க, மாநில இயந்திரங்களைப் பயன்படுத்தலாம்.


Identify the actors that interact with the element.

அந்தக் கூறுகளுடன் தொடர்பு கொள்ளும் நடிகர்களை அடையாளம் காணவும்.


Use case diagrams are central to modeling the behavior of a system.

ஒரு அமைப்பின் நடத்தையை மாதிரியாகக் காட்டுவதற்கு பயன்பாட்டு நிகழ்வு வரைபடங்கள் முக்கியம்.


A use case diagram is a diagram that shows a set of use cases and actors and their relationships.

ஒரு பயன்பாட்டு நிகழ்வு வரைபடம் என்பது பயன்பாட்டு நிகழ்வுகள், நடிகர்கள் மற்றும் அவற்றின் உறவுகளைக் காட்டும் ஒரு வரைபடமாகும்.


ஒரு கூறு என்பது ஒரு உடல் ரீதியான பொருள்.


The UML provides a graphical representation of a component.

UML ஒரு கூறுக்கு ஒரு வரைகலை பிரதிநிதித்துவத்தை வழங்குகிறது.


Using stereotypes, you can tailor this notation to represent specific kinds of components.

ஸ்டீரியோடைப்களைப் பயன்படுத்தி, குறிப்பிட்ட வகையான கூறுகளைப் பிரதிநிதித்துவப்படுத்த இந்த குறியீட்டை நீங்கள் வடிவமைக்கலாம்.


A component is a physical and replaceable part of a system.

ஒரு கூறு என்பது ஒரு அமைப்பின் உடல் மற்றும் மாற்றக்கூடிய பகுதியாகும்.


ஒவ்வொரு கூறுக்கும் ஒரு பெயர் இருக்க வேண்டும்.


A path name is the component name prefixed by the name of the package.

ஒரு பாதை பெயர் என்பது தொகுப்பின் பெயரால் முன்னொட்டாகக் கூறப்படும் கூறு பெயர் ஆகும்.


கூறுகள் வகுப்புகளைப் போன்றவை.


Classes represent logical abstractions; components represent physical things.

வகுப்புகள் தர்க்கரீதியான கருத்தாக்கங்களைப் பிரதிபலிக்கின்றன; கூறுகள் உடல் ரீதியான விஷயங்களைப் பிரதிபலிக்கின்றன.


Components may live on nodes, classes may not.

கூறுகள் முனைகளில் வாழலாம், வகுப்புகள் முடியாது.


An interface is a collection of operations.

ஒரு இடைமுகம் என்பது செயல்பாடுகளின் தொகுப்பாகும்.


All the most common component-based operating system facilities use interfaces.

மிகவும் பொதுவான கூறு அடிப்படையிலான இயக்க முறைமை வசதிகள் இடைமுகங்களைப் பயன்படுத்துகின்றன.


This mechanism permits you to deploy a system whose services are somewhat location-independent.

இந்த வழிமுறை, உங்கள் சேவைகள் ஓரளவு இருப்பிட-சாராத ஒரு அமைப்பை வரிசைப்படுத்த உங்களை அனுமதிக்கிறது.


An interface that a component realizes is called an export interface.

ஒரு கூறு உணரும் இடைமுகம் ஏற்றுமதி இடைமுகம் என்று அழைக்கப்படுகிறது.


A component may provide many export interfaces.

ஒரு கூறு பல ஏற்றுமதி இடைமுகங்களை வழங்கக்கூடும்.


A component may conform to many import interfaces.

ஒரு கூறு பல இறக்குமதி இடைமுகங்களுக்கு இணங்கலாம்.


These are the components necessary to form an executable system.

இவை ஒரு செயல்படுத்தக்கூடிய அமைப்பை உருவாக்க தேவையான கூறுகள் ஆகும்.


You can organize components by grouping them in packages.

தொகுப்புகளில் அவற்றை குழுவாக்குவதன் மூலம் கூறுகளை ஒழுங்கமைக்கலாம்.


Model any executables and libraries as components.

எந்த செயல்படுத்தக்கூடிய மற்றும் நூலகங்களையும் கூறுகளாக வடிவமைக்கவும்.


Identify the programmatic seams in your system and model each seam as an interface.

உங்கள் கணினியில் நிரல் இடைவெளிகளைக் கண்டறிந்து, ஒவ்வொரு இடைவெளியையும் ஒரு இடைமுகமாக வடிவமைக்கவும்.


A node is a physical element that exists at run time.

ஒரு முனை என்பது இயக்க நேரத்தில் இருக்கும் ஒரு உடல் உறுப்பு ஆகும்.


Commanding state, the enclosing object will be in the Waiting or the Command state.

கட்டளையிடும் நிலையில், அதைச் சூழ்ந்திருக்கும் பொருள் காத்திருப்பு அல்லது கட்டளை நிலையில் இருக்கும்.


Object Oriented Analysis and design, Dept. of CSE, RGMCET Fig: Concurrent Substates

பொருள் சார்ந்த பகுப்பாய்வு மற்றும் வடிவமைப்பு, கணினி அறிவியல் மற்றும் பொறியியல் துறை, RGMCET படம்: ஒரே நேரத்தில் துணை நிலைகள்


ஒரு பொருளின் வாழ்நாளை மாதிரிப்படுத்துதல்


When you model the lifetime of an object, you essentially specify three things: the events to which the object can respond, the response to those events, and the impact of the past on current behavior.

நீங்கள் ஒரு பொருளின் வாழ்நாளை மாதிரிப்படுத்தும் போது, நீங்கள் அடிப்படையில் மூன்று விஷயங்களைக் குறிப்பிடுகிறீர்கள்: பொருள் பதிலளிக்கக்கூடிய நிகழ்வுகள், அந்த நிகழ்வுகளுக்கான பதில் மற்றும் கடந்த காலத்தின் தாக்கம் தற்போதைய நடத்தை மீது.


Modeling the lifetime of an object also involves deciding on the order in which the object can meaningfully respond to events, starting at the time of the object's creation and continuing until its destruction.

ஒரு பொருளின் வாழ்நாளை மாதிரிப்படுத்துவதில், பொருள் நிகழ்வுகளுக்கு அர்த்தமுள்ள வகையில் எவ்வாறு பதிலளிக்க முடியும் என்பதைத் தீர்மானிப்பதும் அடங்கும், பொருளின் உருவாக்கம் முதல் அதன் அழிவு வரை.


ஒரு பொருளின் வாழ்நாளை மாதிரிப்படுத்த


Set the context for the state machine, whether it is a class, a use case, or the system as a whole.

நிலை இயந்திரத்திற்கான சூழலை அமைக்கவும், அது ஒரு வகுப்பாக இருந்தாலும், பயன்பாட்டு நிகழ்வாக இருந்தாலும் அல்லது முழு அமைப்பாக இருந்தாலும்.


If the context is a class or a use case, collect the neighboring classes, including any parents of the class and any classes reachable by associations or dependences.

சூழல் ஒரு வகுப்பாகவோ அல்லது பயன்பாட்டு நிகழ்வாகவோ இருந்தால், அண்டை வகுப்புகளைச் சேகரிக்கவும், வகுப்பின் எந்த பெற்றோர்களையும், சங்கங்கள் அல்லது சார்புகளை அணுகக்கூடிய எந்த வகுப்புகளையும் சேர்த்துக்கொள்ளவும்.


These neighbors are candidate targets for actions and are candidates for including in guard conditions.

இந்த அண்டை வீட்டார் செயல்களுக்கான வேட்பாளர்களாகவும், காப்பு நிபந்தனைகளில் சேர்ப்பதற்கான வேட்பாளர்களாகவும் உள்ளனர்.


If the context is the system as a whole, narrow your focus to one behavior of the system.

சூழல் முழு அமைப்பாக இருந்தால், உங்கள் கவனத்தை அமைப்பின் ஒரு நடத்தைக்குக் குறைக்கவும்.


Theoretically, every object in the system may be a participant in a model of the system's lifetime, and except for the most trivial systems, a complete model would be intractable.

கோட்பாட்டளவில், கணினியில் உள்ள ஒவ்வொரு பொருளும் கணினியின் வாழ்நாள் மாதிரியில் ஒரு பங்கேற்பாளராக இருக்கலாம், மேலும் மிகச் சிறிய அமைப்புகளைத் தவிர, ஒரு முழுமையான மாதிரி கையாளுவதற்கு கடினமாக இருக்கும்.


Establish the initial and final states for the object.

பொருளுக்கான ஆரம்ப மற்றும் இறுதி நிலைகளை நிறுவுங்கள்.


Decide on the events to which this object may respond.

இந்த பொருள் பதிலளிக்கக்கூடிய நிகழ்வுகளைத் தீர்மானிக்கவும்.


செயல்முறைகள் மற்றும் திரெட்கள்


In the UML, you model each independent flow of control as an active object that represents a process or thread that can initiate control activity.

UML இல், நீங்கள் ஒவ்வொரு சுயாதீன கட்டுப்பாட்டு ஓட்டத்தையும் ஒரு செயலில் உள்ள பொருளாக மாதிரி செய்கிறீர்கள், இது ஒரு செயல்முறை அல்லது திரெட்டை பிரதிபலிக்கிறது, இது கட்டுப்பாட்டு செயல்பாட்டைத் தொடங்க முடியும்.


An active object is a process or thread that can initiate control activity.

ஒரு செயலில் உள்ள பொருள் என்பது ஒரு செயல்முறை அல்லது திரெட் ஆகும், இது கட்டுப்பாட்டு செயல்பாட்டைத் தொடங்க முடியும்.


Active classes are kinds of classes, so have all the usual compartments for class name, attributes, and operations.

செயலில் உள்ள வகுப்புகள் வகையான வகுப்புகளாகும், எனவே வகுப்பு பெயர், பண்புக்கூறுகள் மற்றும் செயல்பாடுகளுக்கான வழக்கமான பெட்டகங்கள் அனைத்தையும் கொண்டுள்ளன.


Active classes often receive signals, which you typically enumerate in an extra compartment.

செயலில் உள்ள வகுப்புகள் பெரும்பாலும் சமிக்ஞைகளைப் பெறுகின்றன, அவற்றை நீங்கள் பொதுவாக ஒரு கூடுதல் பெட்டகத்தில் எண்ணுகிறீர்கள்.


An active object is an object that owns a process or thread and can initiate control activity.

ஒரு செயலில் உள்ள பொருள் என்பது ஒரு செயல்முறை அல்லது திரெட்டை வைத்திருக்கும் ஒரு பொருளாகும், மேலும் கட்டுப்பாட்டு செயல்பாட்டைத் தொடங்க முடியும்.


When objects collaborate with one another, they interact by passing messages from one to the other.

பொருள்கள் ஒன்றோடொன்று ஒத்துழைக்கும்போது, அவை ஒருவருக்கொருவர் செய்திகளை அனுப்புவதன் மூலம் தொடர்பு கொள்கின்றன.


We show two instances of the component school.db.

நாம் school.db கூறுபாட்டின் இரண்டு நிகழ்வுகளைக் காட்டுகிறோம்.


Both instances are anonymous, and both have a different value for their location tagged value.

இரண்டு நிகழ்வுகளும் அநாமதேயமானவை, மேலும் இரண்டும் அவற்றின் இருப்பிடக் குறிச்சொல்லுக்கு வெவ்வேறு மதிப்பைக் கொண்டுள்ளன.


There's also a note, which explicitly specifies which instance replicates the other.

மற்றொன்றை எந்த நிகழ்வு பிரதிபலிக்கிறது என்பதைத் தெளிவாகக் குறிப்பிடும் ஒரு குறிப்பும் உள்ளது.


To forward engineer a component diagram, for each component, identify the classes or collaborations that the component implements.

ஒரு கூறு வரைபடத்தை முன்னோக்கி வடிவமைக்க, ஒவ்வொரு கூறுக்கும், கூறு செயல்படுத்தும் வகுப்புகள் அல்லது ஒத்துழைப்புகளை அடையாளம் காணவும்.


ஒவ்வொரு கூறுக்கும் இலக்கைத் தேர்ந்தெடுக்கவும்.


Your choice is basically between source code or a binary library or executable.

உங்கள் தேர்வு அடிப்படையில் மூலக் குறியீடு அல்லது ஒரு பைனரி நூலகம் அல்லது செயல்படுத்தக்கூடியது.


Use tools to forward engineer your models.

உங்கள் மாதிரிகளை முன்னோக்கி வடிவமைக்க கருவிகளைப் பயன்படுத்தவும்.


Reverse engineering a component diagram is not a perfect process because there is always a loss of information.

ஒரு கூறு வரைபடத்தை தலைகீழாக வடிவமைப்பது ஒரு சரியான செயல்முறை அல்ல, ஏனெனில் எப்போதும் தகவல்களை இழக்க நேரிடும்.


Choose the target you want to reverse engineer.

நீங்கள் தலைகீழாக வடிவமைக்க விரும்பும் இலக்கைத் தேர்ந்தெடுக்கவும்.


Source code can be reverse engineered to components and then classes.

மூலக் குறியீட்டை கூறுகளாகவும் பின்னர் வகுப்புகளாகவும் தலைகீழாக வடிவமைக்க முடியும்.


Binary libraries can be reverse engineered to uncover their interfaces.

பைனரி நூலகங்களை அவற்றின் இடைமுகங்களைக் கண்டறிய தலைகீழாக வடிவமைக்க முடியும்.


Executables can be reverse engineered the least.

செயல்படுத்தக்கூடியவை குறைவாகவே தலைகீழாக வடிவமைக்கப்படலாம்.


Using a tool, point to the code you'd like to reverse engineer.

ஒரு கருவியைப் பயன்படுத்தி, நீங்கள் தலைகீழாக வடிவமைக்க விரும்பும் குறியீட்டைக் சுட்டிக்காட்டவும்.


Use your tool to generate a new model or to modify an existing one that was previously forward engineered.

ஒரு புதிய மாதிரியை உருவாக்க அல்லது முன்பு முன்னோக்கி வடிவமைக்கப்பட்ட ஒன்றை மாற்றியமைக்க உங்கள் கருவியைப் பயன்படுத்தவும்.


For example, below figure provides a component diagram that represents the reverse engineering of the ActiveX component vbrun.dll.

உதாரணமாக, கீழே உள்ள படம் ActiveX கூறு vbrun.dll இன் தலைகீழ் வடிவமைப்பைக் குறிக்கும் ஒரு கூறு வரைபடத்தை வழங்குகிறது.


As the figure shows, the component realizes 11 interfaces.

படத்தில் காட்டப்பட்டுள்ளபடி, கூறு 11 இடைமுகங்களை உணர்த்துகிறது.


Given this diagram, you can begin to understand the semantics of the component by next exploring the details of its interfaces.

இந்த வரைபடத்தைக் கொண்டு, அதன் இடைமுகங்களின் விவரங்களை ஆராய்வதன் மூலம், கூறுபாட்டின் சொற்பொருளைப் புரிந்து கொள்ளத் தொடங்கலாம்.


Deployment diagrams are one of the two kinds of diagrams used in modeling the physical aspects of an object-oriented system.

ஒரு பொருள் சார்ந்த அமைப்பின் இயற்பியல் அம்சங்களை மாதிரியாக்குவதில் பயன்படுத்தப்படும் இரண்டு வகையான வரைபடங்களில் வரிசைப்படுத்தல் வரைபடங்கள் ஒன்றாகும்.


A deployment diagram shows the configuration of run time processing nodes and the components that live on them.

வரிசைப்படுத்தல் வரைபடம், இயக்க நேர செயலாக்க முனைகளின் உள்ளமைவையும், அவற்றில் வாழும் கூறுகளையும் காட்டுகிறது.


You use deployment diagrams to model the static deployment view of a system.

ஒரு அமைப்பின் நிலையான வரிசைப்படுத்தல் காட்சியை மாதிரியாக்க நீங்கள் வரிசைப்படுத்தல் வரைபடங்களைப் பயன்படுத்துகிறீர்கள்.