Çoklu arayüze sahip nesnelerin tasarımı ve erişim kontrollerinin sağlanması

Abstract

Nesneye yönelik diller nesnelerin ayrıntılarını, nesnelerin kullanıcılarından saklar. Nesne ile olan etkileşimlerin hepsi, nesnenin desteklediği işlemlerle olmalıdır. Bu yüzden nesneler bütün kullanıcılarının ihtiyacını karşılamak için yeterli bir işlem grubu sağlamalıdırlar. Değişik kullanıcıların istekleri oldukça farklıdır. Dolayısıyle bütün işlemleri tüm kullanıcılara sağlamak yerine, belirli kullanıcılara veya kullanıcı gruplarına desteklenen işlemlerin sınırlı sayıdaki bir grubunu sunmak istenilen bir Özellik olacaktır. Bu çalışmada C++ dilindeki nesnenin public arayüzü farklı grup nesnelere farklı hizmetler vermek için çoklu hale getirilmiştir.

Object oriented programming (OOP) is a method of programming that seeks to mimic the way we form models of the world. To cope with the complexities of life, we have evolved a wonderful capacity to generalize, classify, and generate abstractions. Almost every noun in our vocabulary represent a class of objects sharing some set of attributes or behavioral traits. From a world full of individual dogs, we distill an abstract class called "dog." This allows us to develop and process ideas about canines without being distracted by the details concerning any particular dog. The OOP extensions in C++ exploit this natural tendency we have to classify and abstract things. As the notions of object oriented programming become more widely understood, some people are claiming that there's not really anything new in this heavely promoted "techno-jargon." In some ways they're correct. We still see functions, data structures, and data typing. But the object oriented paradigm serves to pull these basic building blocks together into a cohesive unit -an object. This allows the designer of a software system to closely model real- world entities having both state and behaviour. The paradigm gives the trusty information model the vital added dimension of activity. Functions gives us the ability to organize behaviour in objects; data structures give us the organization of state representation. Objects allow us to organize our software system one level higher up than functions or data structures. It allows us to organize our system based on aggregates of functions and data that represent entities in our abstract model. Object oriented languages (OOL) are growing in popularity. They introduce features not available in conventional programming languages, such as function and operator overloading, inheritance, and dynamic (late) binding. More and more organizations are introducing object oriented methods and languages into their software development practices. Claimed advantages of object oriented -Vır programming include extensive reuse of software objects and easier maintanence through data encapsulation. Object oriented programming can be considered either revolutionary or evolutionary, depending on the degree to which access to conventional programming techniques is retained. Pure object oriented languages such as Smalltalk-80 represent the revolutionary approach and provide the advantage of conceptual simplicity, The programmer works in a compututational environment that contains only objects, so the break with the past is clean and crisp. Evolutionary approach is adding object oriented concepts on the top of conventional languages. Hybrid languages just add a new power tool to the programmer's kit, a tool that can be picked up when it fits the task at hand or set aside when conventional techniques are sufficient. Since they retain conventional languages as a substrate, efficiency can be outstanding. We are taught very early that computers do operations on operands, and this computational model is preserved through everything we learn subsequently. Once we know that larger operators can be built out of stored sequences of operators, our progress as programmers becomes a matter of increasing the number of different operators we now - text editors, command languages, machine languages, linkers, debuggers, high-level languages, subroutine libraries, application packages, and so forth. We think of the computer as two disjoint compartments, one containing operators and the other operands, and we express our intentions by selecting what operators are to be applied and to what operands in what order. We call this conventional model of computation the operator/operand model. Operators are active and make some predetermined change to whatever operand is supplied them. Operands are passive and change only when effected by some operator. The environment determines what operators are to be applied to what operands in what order. The term environment stands for whatever determines what happens next. It encompases the computer user, his input device, and the programs running on his behalf. It is responsible for three different things. The environment is responsible for controlling the progression of events in time. For example, a second operator is to be applied just after the first one has finished. -v««- The environment is responsible for controlling the movement of computational objects through computational space. For example, the operand will be found within, and the result delivered to, the environment's address space. The environment is responsible for ensuring that the operands meet the data type assumptions made by the operator. For example, since sqrt assumes a floating point argument, the environment is responsible for ensuring that x is a floating point number. The operator/operand model treats operators and operands as if they were independent. But in practice, operators place strong restrictions on the types of operands they handle correctly. For example, operators like text editors depend on their operands being text files. Under the message/object approach, by contrast, objects record their types (class) explicitly. This record is used at run time to determine the set of operations that can be performed on objects of this class. The message/object model decouples the environment from the data types it contains by moving responsibility for operator/operand interdependencies out of implicit storage in data structures called classes. Classes collect their operators in a table that associates each operator with a name that suggests its meaning without revealing its implementation. The instances of that class -the objects- are like conventional operands, but they record their type explicitly by identifying their class in some standart manner. Sequential object oriented languages are based on a model of passive objects. An object is activated when it receives a masssage from another object. While the receiver of the message is active, the sender is waiting for the result, so the sender is passive. After the returning the result, the receiver becomes passive again and the sender continues. At any point of time, only one object in the system is active. Object oriented languages break a program down into segments (objects) accessible only by sending messages through a rigid interface. The objects interpret each message and take an appropriate action. Theoretically, you can not acces an object's internal data, but the object, in effect, shares this data through its actions. -ix- In these languages, objects inherit features from other objects in a hierarcy. Inheritance classifies objects that share sets of properties. Objects may inherit features from more than one classification structure and more than once from the same class (multiple inheritance). In some cases, objects inherit only a reference to the inherited code instead of a copy of the entire segment. Inheritance lets programmers reuse code and redefine its application within the currrent environment. It is key to building maintainable, reusable systems, and it provides a form of configuration management. Inheritance is one of seven properties that, according to Bertrand Meyer, characterize pure object oriented languages. The seven properties are; 1. Modular structure; 2. Data abstraction (objects are described implemantations of abstract data types); 3. Automatic memory management (The language deallocates unused objects without programmer intervention); 4. Classes (every nonsimple type is a class); 5. Inheritance (a class may be defined as an extension or restriction of another); 6. Polymorphism and dynamic binding (program entities can refer to objects of more than one class, and opeartions can have different realisations in different classes); and 7. Multiple and repeated inheritance (a class can inherit from more than one class and be a parent to the same class more than once). Meyer regards languages that meet the first four criteria as object based; he regards as truly object oriented only languages that meet seven characteristics. The hardest requirement to meet is the last one, multiple inheritance. When a child class inherits from two other classes that share a common ancestor, references to that ancestors methods are ambiguous unless you delineate a specific path.