Sie sind auf Seite 1von 4

Object-oriented programming (OOP) is part of this movement toward using the computer as an expressive medium.

All programming languages provide abstractions. OOP allows you to describe the problem in terms of the problem, rather t han in terms of the computer where the solution will run . Everything is an object. A program is a bunch of objects telling each other what to do by sending messages. Each object has its own memory made up of other objects. Every object has a type(class) All objects of a particular type(class) can receive the same messages This means that an object can have internal data (which gives it state), methods (to produce behavior), and each object can be uniquely distinguished fr om every other object to put this in a concrete sense, each object has a unique ad dress in memory. You can create variables of a type (called objects or instances in objec t-oriented parlance) and manipulate those variables (called sending messages or requests; you send a message and the object figures out what to do with it). type = class

A type has a method associated with each possible request, and when you make a particular request to an object, that method is called. While you re trying to develop or understand a program design, one of the best ways to think about objects is as service providers. Thinking of an object as a service provider has an additional benefit: It helps to improve the cohesivene ss of the object. In a good object-oriented design, each object does one thing well, but d oesn t try to do too much. Java uses three explicit keywords to set the boundaries in a class: publ ic, private, and protected. These access specifiers determine who can use the de finitions that follow. public means the following element is available to everyo ne. The private keyword, on the other hand, means that no one can access that el ement except you, the creator of the type, inside methods of that type. private is a brick wall between you and the client programmer. Someone who tries to acce ss a private member will get a compile-time error. The protected keyword acts li ke private, with the exception that an inheriting class has access to protected members, but not private members. Code reuse is one of the greatest advantages that object-oriented progra mming languages provide. Because you are composing a new class from existing classes, this concep t is called composition (if the composition happens dynamically, it s usually call ed aggregation). Composition is often referred to as a has-a relationship. Because inheritance is so important in object-oriented programming, it i s often highly emphasized, and the new programmer can get the idea that inherita nce should be used everywhere. This can result in awkward and overly complicated designs. Instead, you should first look to composition when creating new classe s, since it is simpler and more flexible. If you take this approach, your design s will be cleaner. Once you ve had some experience, it will be reasonably obvious

when you need inheritance. ~~~Inheritance~~~ It seems a pity, however, to go to all the trouble to create a class and then be forced to create a brand new one that might have similar functionality. It s nicer if we can take the existing class, clone it, and then make additions a nd modifications to the clone. This is effectively what you get with inheritance , with the exception that if the original class (called the base class or superc lass or parent class) is changed, the modified clone (called the derived class or inherited class or subclass or child class) also reflects those changes. Using inheritance, you can build a type hierarchy that expresses the pro blem you re trying to solve in terms of its types. If you simply inherit a class and don t do anything else, the methods from the base-class interface come right along into the derived class. That means ob jects of the derived class have not only the same type, they also have the same behavior, which isn t particularly interesting. Although inheritance may sometimes imply (especially in Java, where the keyword for inheritance is -----extends-----) The second and more important way to differentiate your new class is to change the behavior of an existing base-class method. This is referred to as ove rriding that method.To override a method, you simply create a new definition for the method in the derived class. We often refer to the relationship between the base class and derived cl asses in this case as an is-a relationship, because you can say, A circle is a sh ape. A test for inheritance is to determine whether you can state the is-a relati onship about the classes and have it make sense. ~~~Polymorphism~~~ For example, you can derive a new subtype of shape called pentagon witho ut modifying the methods that deal only with generic shapes. This ability to eas ily extend a design by deriving new subtypes is one of the essential ways to enc apsulate change. To perform late binding, Java uses a special bit of code in lieu of the absolute call. This code calculates the address of the method body, using inform ation stored in the object (this process is covered in great detail in the Polym orphism chapter). Because of polymorphism the compiler and runtime system handle the detai ls; all you need to know right now is that it does happen, and more importantly, how to design with it. When you send a message to an object, the object will do the right thing, even when upcasting is involved. ~~~Containers~~~ But this new object, generally called a container (also called a collect ion, but the Java library uses that term in a different sense so this book will use container ), will expand itself whenever necessary to accommodate everything yo u place inside it. So you don t need to know how many objects you re going to hold i n a container. Just create a container object and let it take care of the detail s. There are two reasons that you need a choice of containers. First, conta iners provide different types of interfaces and external behavior. A stack has a different interface and behavior than a queue, which is different from a set or a list. One of these might provide a more flexible solution to your problem tha n the other. Second, different containers have different efficiencies for certai n operations. ~~~Object creation & lifetime~~~

Java uses dynamic memory allocation, exclusively.7 Every time you want t o create an object, you use the new operator to build a dynamic instance of that object.

Ordinarily, tasks are just a way to allocate the time of a single proces sor. But if the operating system supports multiple processors, each task can be assigned to a different processor, and they can truly run in parallel.So a task locks a resource, completes its task, and then releases the lock so that someone else can use the resource. Common Gateway Interface (CGI) ~~~Plug-ins~~~ One of the most significant steps forward in client-side programming is the development of the plug-in. This is a way for a programmer to add new functi onality to the browser by downloading a piece of code that plugs itself into the appropriate spot in the browser. It tells the browser, From now on you can perfo rm this new activity. (You need to download the plug-in only once.) Some fast and powerful behavior is added to browsers via plug-ins, but writing a plug-in is n ot a trivial task, and isn t something you d want to do as part of the process of bu ilding a particular site. The value of the plug-in for client-side programming i s that it allows an expert programmer to develop extensions and add those extens ions to a browser without the permission of the browser manufacturer. Thus, plug -ins provide a back door that allows the creation of new client-side programming l anguages (although not all languages are implemented as plug-ins). ~~~Scripting languages~~~ Plug-ins resulted in the development of browser scripting languages. Wit h a scripting language, you embed the source code for your client-side program d irectly into the HTML page, and the plug-in that interprets that language is aut omatically activated while the HTML page is being displayed. Scripting languages tend to be reasonably easy to understand and, because they are simply text that is part of an HTML page, they load very quickly as part of the single server hi t required to procure that page. The trade-off is that your code is exposed for everyone to see (and steal). Generally, however, you aren t doing amazingly sophis ticated things with scripting languages, so this is not too much of a hardship. One scripting language that you can expect a Web browser to support with out a plug-in is JavaScript.This points out that the scripting languages used in side Web browsers are really intended to solve specific types of problems, prima rily the creation of richer and more interactive graphical user interfaces (GUIs ). However, a scripting language might solve 80 percent of the problems encounte red in client-side programming. Your problems might very well fit completely wit hin that 80 percent, and since scripting languages can allow easier and faster d evelopment, you should probably consider a scripting language before looking at a more involved solution such as Java programming. The .NET platform is roughly the same as the Java Virtual Machine (JVM; the software platform on which Java programs execute) and Java libraries, and C# bears unmistakable similarities to Java. BigInteger supports arbitrary-precision integers. This means that you ca n accurately represent integral values of any size without losing any informatio n during operations. BigDecimal is for arbitrary-precision fixed-point numbers; you can use t hese for accurate monetary calculations, for example.