2. Objectives • Define modeling concepts: abstraction, encapsulation. • Define class, member, attribute, method, constructor and package • Invoke a method on a particular object. • In a Java program, identify the following: The package statement. The import statements. Classes, methods, and attributes. Constructors. • Use the Java API online documentation
3. Abstraction An essential element of object oriented language is abstraction. Humans manage the complexity through abstraction. For example People do not think of car as a set of tens of thousand of individual parts. They think of it as a well defined object with its own unique behavior. They can ignore the details of how the engine, transmission and braking systems work. Powerful way to manage the abstraction is through the use of hierarchical classifications.
4. From the outside, the car is a single object. Once inside you see that the car consist of several subsystems: steering, brakes, sound system, seat belts ,cellular system and so on. In turn each of these subsystem is made up of more specialized units. For example sound system consist of a radio, a CD player and a tape player. The point is you manage the complexity of car through the use of hierarchical abstraction.
5. Hierarchical abstraction of complex systems can also be applied to computer programs. The data from program can be transformed by abstraction into its component objects. Each object describe its own unique behavior.We can treat these objects as concrete entities that respond to message telling them to do something.
6.
7.
8.
9.
10.
11. Creating Objects This statement creates a new Rectangle object from the Rectangle class. Rectangle rect = new Rectangle(); This single statement performs three actions: Declaration : Rectangle rect is a variable declaration that declares to the compiler that the name rect will be used to refer to a Rectangle object. Instantiation : new is a Java operator that creates the new object Initialization : Rectangle() is a call to Rectangle's constructor, which initializes the object.
12. Using Objects Once you've created an object, you probably want to use it for something. You may need information from it, want to change its state, or have it perform some action. Objects give you two ways to do these things: 1.Manipulate or inspect its variables . area = rect.height * rect.width; 2.Call its methods. rect.move(15, 37);
13. Cleaning Up Unused Objects Java allows you to create as many objects as you want and you never have to worry about destroying them. The Java runtime environment deletes objects when it determines that they are no longer being used. This process is called garbage collection. An object is eligible for garbage collection when there are no more references to that object. The Java platform has a garbage collector that periodically frees the memory used by objects that are no longer needed. The garbage collector runs in a low-priority thread
14. Finalization Before an object gets garbage-collected, the garbage collector gives the object an opportunity to clean up after itself through a call to the object's finalize method. This process is known as finalization . During finalization, an object may wish to free system resources such as files and sockets or to drop references to other objects so that they in turn become eligible for garbage collection.
15.
16. Inheritanc e I nheritance is a mechanism that enables one class to inherit all of the behaviour and attributes of another class. For example, mountain bikes, road bikes, are all kinds of bicycles. Mountain bikes, road bikes are all subclasses of the bicycle class. Similarly, the bicycle class is the superclass of mountain bikes, road bikes. Each subclass inherits state from the superclass. Mountain bikes, road bikes share some states: cadence, speed, and the like. Also, each subclass inherits methods from the superclass. Example inheritance.java
17.
18. Encapsulation in Java In Java the basis of encapsulation is the class. Since the purpose of a class is to encapsulate complexity, there are mechanisms for hiding the complexity of the implementation inside the class. Each method or variable in a class may be marked private or public.
19. P olymorphism Polymorphism is something like one name, many forms . Polymorphism manifests itself in Java in the form of multiple methods having the same name. In some cases, multiple methods have the same name, but different formal argument lists( overloaded methods) Example overload.java In other cases, multiple methods have the same name, same return type, and same formal argument list (overridden methods) . Example override.java
20. Interface Interface is a device or a system that unrelated entities use to interact. Remote control is an interface between you and a television . T he English language is an interface between two people. Use an interface to define a behavior that can be implemented by any class. So interface is a collection of methods that indicate a class has some behaviour in addition to what it inherits from its superclass.
21.
22. Interface • Variables declared inside of interface declarations are implicitly public, final and static • They must also be initialized with a constant value • All methods are implicitly public and abstract. • Interface methods cannot be marked final, strictfp or native. • An interface can extend one or more other interfaces. • An interface cannot implement another interface or class. Example Callback.java, Client.java
23.
24. The following interface method declarations won't compile: final void bounce(); // final and abstract can never be used // together, and abstract is implied static void bounce(); // interfaces define instance methods private void bounce(); // interface methods are always public protected void bounce(); // (same as above)
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37. The Default Constructor • There is always at least one constructor in every class • If the writer does not supply any constructors, the default constructor will be present automatically The default constructor takes no arguments The default constructor has no body • Enables you to create object instances with new Xxx()without having to write a constructor
38.
39.
40.
41. Packages • Packages help manage large software systems • Packages can contain classes and sub-packages • Basic syntax of the package statement: <package_declaration> ::= package <top_pkg_name>[.<sub_pkg_name>].*; Example: package shipping.reports.Web; • Specify the package declaration at the beginning of the source file
42. Packages • Only one package declaration per source file • If no package is declared, then the class "belongs" to the default package • Package names must be hierarchical and separated by dot
43. The import Statement • Basic syntax of the import statement: <import_declaration> ::= import <pkg_name>[.<sub_pkg_name>]*.<class_name | *>; Examples: import shipping.domain.*; import java.util.List; import java.io.*; • Precedes all class declarations • Tells the compiler where to find classes to use
