Your SlideShare is downloading. ×
Object and Classes in Java
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Object and Classes in Java

2,648

Published on

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
2,648
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
140
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. IADCS Diploma course Classes and Objects in Java U Nyein Oo COO/Director(IT) Myanma Computer Co., Ltd
  • 2. Classes and Object-Oriented Programming
    • Classes should be the implementation of a design or object model
    • Classes reflect the types of real-world objects and relationships between objects
    • Attributes become fields of classes, and messages become methods of classes
    • Design the interface between classes
  • 3. Using Constructors and Finalizers
    • Constructors: methods that prepare newly created objects for use
    • Finalizers: are methods that perform any actions, such as releasing memory buffers or closing network connections, that should be completed before the objects are discarded
  • 4. Constructors
    • Rules to define constructors are:
      • Give the constructor the same name as the class name
      • Do not specify a return type, not even void
      • You can specify as many arguments as you like
  • 5. Finalizers
    • Use finalizers only for necessary cleanup tasks (example: releasing memory buffers allocated by the object or closing network connections)
    • A finalizer cannot have private or package access because it overrides a protected method of Object
  • 6. Finalizers (Cont.)
    • The finalize method cannot take arguments or return a value
    • Include the clause throws Throwable to allow for a subclass to include a finalizer that does throw an exception
  • 7. Reference Objects and Garbage Collector
    • Create a reference object by instantiating the classes SoftReference, WeakReference, or PhantomReference and passing an object reference to an object used by your program as an argument of the constructor
    • When the garbage collector operates on objects, it changes the reachability level of the object
    • Use the reference classes to determine the status of an object
  • 8. Reachability Levels of Objects
  • 9. Cloning Objects
    • For the primitive types, you can copy with the assignment operator
    • To copy objects of reference type, including arrays, use the clone method
    • By default, the clone method performs a shallow copy
  • 10. Cloning Objects (Cont.)
    • A shallow copy makes no attempt to make duplicates of the referenced objects
    • A deep copy duplicates contained objects, creates new object references for the duplicates, and inserts the new object references into the copy of the containing object
  • 11. Shallow and Deep Copies
  • 12. Making Objects Cloneable
    • To be cloneable, an object must be an instance of a class that implements the interface Cloneable
    • The clone method throws an exception when called for an instance of a class that is not cloneable
    • The Cloneable interface is an example of a marker interface
    • The purpose of a marker interface is to attach a piece of type information to a class
  • 13. Overriding the Default Clone Method
    • If your classes contain fields that have reference types, override the clone method to perform a deep copy
    • Start the implementation of clone with the statement super.clone( )
    • Define the clone method to copy objects for all fields that are reference objects
  • 14. Defining Cloneable Classes
    • Override or inherit clone
    • Optionally define your class to implement Cloneable
    • Optionally throw the exception CloneNotSupportedException
    • Optionally catch the exception CloneNotSupportedException
    • List or omit the exception in the throws clause of the clone method
  • 15. Run-Time Type Information
    • Run-time type information (RTTI) is the type information about the objects in use within a program cannot be known until the program is running
    • Use RTTI to access members of classes that you cannot know about when you develop your class
    • RTTI is helpful in debugging the code
  • 16. Determining the Type of Objects
    • Use of the instanceof operator
      • To ask whether an object is an instance of a particular class or any of its subclasses
      • Returns a boolean value
        • True if the object on the left is an instance of the class or a subclass of the class on the right
      • Does not work for the primitive types
  • 17. Accessing Information about Classes at Runtime
    • The Java platform creates the Class object automatically and stores several facts about the class (accessible at runtime)
    • You can call a method to get the Class object for a class or an instance of a class
    • After you have a reference to a Class object, you can send messages to it to ask questions about the class that the object describes
  • 18. Casting Between Types
    • Casting forces an object or primitive type to behave as a different type of object or primitive type
    • If a cast is definitely unsafe, the compiler outputs an error message
    • If cast might be unsafe, the compiler assumes the code is correct and leaves the decision to the JVM (runtime checking)
  • 19. Using the Reflection API
    • Reflection API:
      • The classes in the package java.lang.reflect
      • Supports introspection, which essentially asks a class to describe itself
      • Gives an object the ability to reflect upon itself and discover its contents
    • Three classes represent the building blocks of classes:
      • Constructor
      • Method
      • Field
  • 20. Calling Methods with the Reflection API
    • Call the method by name or create an object with the new keyword
    • Use a Method object or a Constructor object when you must use the Reflection API to discover which methods are available, or to determine the type of an object
  • 21. Nested Classes and Interfaces
    • Nested class:
      • Defined inside the definition of another class
      • Are top-level classes
      • Nested top-level classes are declared with the keyword static
    • Rules for accessing a nested class resemble the rules for accessing members of the enclosing class
  • 22. Nested Classes and Interfaces (Cont.)
    • The names of nested classes consist of:
      • package name
      • enclosing class names
      • the simple name of the nested class (separated by dots)
  • 23. Inner Classes
    • Three kinds of inner classes are possible:
      • Member inner classes: defined inside another class, at the same level as fields and methods
        • They are members of the enclosing class
      • Local inner classes: defined inside blocks of code
        • They are local to the enclosing method or block
      • Anonymous inner classes: local inner classes that have no name.
  • 24. Inner Classes (Cont.)
    • Use inner classes to create adapter classes within an existing class
    • Adapter classes
      • Programming design pattern
      • Create a wrapper for the data of a class to present it within a different interface that the class does not implement
    • An inner class implements an interface when the interface defines only one method
  • 25. Defining Member Inner Classes
    • Inner classes
      • Instance members of their enclosing classes
      • Can be declared public, protected, or private
      • Cannot be instantiated without an instance of the outer class
    • To create the inner class object in an instance method of the enclosing class, the object reference is implied
  • 26. Name Conflicts in Inner Classes
  • 27. Local Inner Classes
    • Local inner classes
      • Classes declared inside methods
      • Private to the blocks in which they are defined
      • The names of the classes cannot be used anywhere except in the method in which they are defined
    • Objects of a local inner class and all the objects within their extended states live beyond the scopes in which they are created
  • 28. Anonymous Local Inner Classes
    • Anonymous inner classes
      • Local inner classes that have no name
      • Have neither names nor constructors
    • To initialize an object, an instance initializer is used
    • An instance initializer has the same syntax as a static initializer, but without the keyword static
  • 29. Class Files for Nested and Inner Classes
    • Each nested top-level class or inner class is stored in its own .class file
    • The filename generated for .class files consists of
      • The enclosing class name
      • A dollar sign character ($)
      • The enclosed class name (for every level of nesting)
    • An anonymous class is identified by a number
  • 30. Thanks You!

×