1 / 34

Introduction To Classes

Introduction To Classes. Session 4. Review. A Java program consists of a set of classes. The Java program must have a main() method from where it begins its execution. Variables defined in a class are called the instance variables. There are two types of casting: widening and narrowing.

ronli
Download Presentation

Introduction To Classes

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Introduction To Classes Session 4

  2. Review • A Java program consists of a set of classes. • The Java program must have a main() method from where it begins its execution. • Variables defined in a class are called the instance variables. • There are two types of casting: widening and narrowing. • Variables are basic unit of storage. • Each variable has a scope and lifetime. • Arrays are used to store several items of same data type in consecutive memory locations.

  3. Review Contd… • Java provides different types of operators. They include: • Arithmetic • Bitwise • Relational • Logical • Conditional • Assignment • Java supports the following programming constructs: • if-else • switch • for • while • do-while • The three jump statements-break,continue and return helps to transfer control to another part of the program.

  4. Objectives • Explain the Java Program Structure • Design a Simple Class • Create objects • Explain the concept of methods in a class • Implement constructors • List the features of Inheritance • Differentiate between Overloading and Overriding of methods • Identify the access specifiers and method modifiers

  5. Java Program Structure • Environment Information • Class Declaration • Tokens: • Identifiers • Keywords / Reserve words • Separators • Literals • Operators

  6. Class • A class defines a new data type. • Every time an instance of a class is created, an object is created. • The object contains its own copy of each instance variable defined by the class. • A dot operator ( . ) is used to access these variables. • The dot operator links the name of the object with the name of an instance variable.

  7. The simplest form for a class definition in Java is class ClassName { constructor1 constructor2 . . . method1 method2 . . . field1 field2 . . . }

  8. class Employee { // constructor public Employee(String n, double s, int year, int month, int day) { name = n; salary = s; GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day); hireDay = calendar.getTime(); } // a method public String getName() { return name; } // more methods . . . // instance fields private String name; private double salary; private Date hireDay; }

  9. Declaring Objects • When a new class is created, a new data type is created. • Objects are declared to represent the class. • Obtaining objects of a class is a two-step process. They are: • First, a variable of the class type has to be declared. The variable does not define an object. It is a variable that can refer to an object. • Second, an actual physical copy of the object must be acquired and assigned to that variable. It is done by using the new operator. • The new operator dynamically allocates memory for an object and returns a reference to it. • All class objects must be dynamically allocated.

  10. Fields • annotations : Annotations and annotation types are discussed in later. • access modifiers • static • final • transient. • volatile

  11. Static Fields • Sometimes you want only one instance of a field shared by all objects of a class. • You create such fields by declaring them static, so they are called static fields or class variables. • When you declare a static field in a class only one copy of the field exists, no matter how many instances of the class are created.

  12. public class Item { //static field uniqueId private static int uniqueId = 1; private int itemId; private String itemName; public Item(String itemName) { this.itemName = itemName; itemId = uniqueId; uniqueId++; } }

  13. final Fields • We have seen final fields used to define named constants because constants don't change value. In general, a final field is used to define an immutable property of a class or object a property that doesn't change for the lifetime of the class or object.

  14. Access Control • All members of a class are always available to code in the class itself. To control access from other classes, class members have four possible access modifiers: • private Members declared private are accessible only in the class itself. • package Members declared with no access modifier are accessible in classes in the same package, as well as in the class itself. • protected Members declared protected are accessible in subclasses of the class, in classes in the same package, and in the class itself. • public Members declared public are accessible anywhere the class is accessible.

  15. Class Constructors • Special methods are used to initialize member variables of the class. • It has the same name as the Class name and does not have a return type. • Called automatically and immediately after an object is created. • Two types of constructors: • Parameterized constructors • Implicit or default constructors

  16. you combine the constructor with the new operator • new Date() • A constructor has the same name as the class. • A class can have more than one constructor. • A constructor can take zero, one, or more parameters. • A constructor has no return value. • A constructor is always called with the new operator.

  17. Inheritance • The attributes set for a class are inherited by the sub classes defined within the class. • A class that is inherited from another class is called subclass. • The class from which another class is derived is called superclass. • Subclass is a specialized superclass and can access all the instance variables and methods defined by the superclass. • To inherit a class, one has to use the keyword extends in the subclass.

  18. Employee, Manager class Manager extends Employee { added methods and fields }

  19. Derived Class constructors • Has the same name as the subclass. • Statement that calls the constructor of the superclass should be the first statement in the constructor of a subclass. • The keyword super issued to call the superclass constructor. • The keyword super can also be used to refer to methods or instance variable of the superclass.

  20. Methods in Classes • A method is defined as the actual implementation of an operation on an object. • Syntax access_specifier modifier datatype method_name (parameter_list) { //body of the method } • A method is always invoked relative to some objects of its class. • Within a method there is no need to specify the object a second time.

  21. Sample Usage of Method class Temp { static int num = 10; public static void show() { System.out.println(num); } public static void main(String [] arg) { Temp tobj = new Temp(); tobj.show(); Temp t1Obj = new Temp(); t1Obj.num = 20; t1Obj.show(); } } Output

  22. Methods in Classes Contd... • Methods that have a return type other than void, return a value to the calling routine using the return statement. • Many methods need parameters. • Parameters allow a method to be generalized.

  23. Methods Overloading • Characteristics of overloaded methods are: • Defined in the same class • Have the same name • Have different parameter lists • Overloaded methods are a form of compile time polymorphism. • Overloading lets you define a similar operation in different ways for different data

  24. Methods Overriding • Characteristics of overridden methods are: • Defined in the superclass as well as in the subclass. • Are redefined in the subclass. • Overridden methods are a form of runtime polymorphism. • Overriding lets you define a similar operation in different ways for different object types

  25. Access Specifiers for Methods public protected private

  26. Method Modifiers • static • final • abstract • native • synchronized • volatile

  27. Private Methods • When implementing a class, we make all data fields private because public data are dangerous. But what about the methods? • Sometimes, you may wish to break up the code for a computation into separate helper methods. Typically, these helper methods should not become part of the public interface—they may be too close to the current implementation or require a special protocol or calling order. Such methods are best implemented as private. • To implement a private method in Java, simply change the public keyword to private. • the designers of the class can be assured that it is never used outside the other class operations and can simply drop it. If a method is public, you cannot simply drop it because other code might rely on it.

  28. Static methods • are methods that do not operate on objects. For example, the pow method of the Math class is a static method. The expression • Math.pow(x, a) computes the power x^a. • You can think of static methods as methods that don’t have a this parameter.

  29. Native methods • The Java native method is a great way to gain and merge the power of C or C++ programming into Java. To use Java as a scientific and high performance language, when efficient native Java compilers are not fully implemented, use native method can boost the performance to at least the speed of C compiled code. • Example showing how Java native method works. JMPI.java : public class JMPI { public native int Init(String[] args); public native int Finalize(); static { System.loadLibrary("JMPI"); } }

  30. this • The keyword this is useful when you need to refer to instance of the class from its method. The keyword helps us to avoid name conflicts.

  31. class Rectangle{int length,breadth;void show(int length,int breadth){this.length=length;this.breadth=breadth;  }int calculate(){return(length*breadth);  }}public class UseOfThisOperator{public static void main(String[] args){    Rectangle rectangle=new Rectangle();    rectangle.show(5,6);int area = rectangle.calculate();    System.out.println("The area of a Rectangle is  :  " + area);  }}class Rectangle{int length,breadth;void show(int length,int breadth){this.length=length;this.breadth=breadth;  }int calculate(){return(length*breadth);  }}public class UseOfThisOperator{public static void main(String[] args){    Rectangle rectangle=new Rectangle();    rectangle.show(5,6);int area = rectangle.calculate();    System.out.println("The area of a Rectangle is  :  " + area);  }}

  32. Nested Classes • Defining one class within another is called ‘Nesting’. • Scope of a nested class is within the enclosing class. • There are two types of nested class. They are: • Static • Non-static • Inner Class is the non-static nested class.

  33. Summary • Import statements are used to access the Java packages required for the execution of the program. • A token is the smallest unit in a program. There are five categories of tokens: • Identifiers • Keywords • Separators • Literals • Operators • Class declaration only creates a template and not an actual object. • Objects are instances of a class and have physical reality. • Method is the actual implementation of an operation on an object.

  34. Summary Contd… • Constructors are used for automatic initialization of objects at the time of creation. • The super keyword is used for calling the superclass constructors. • To inherit a class from the superclass, the extends keyword is used. • Overloaded methods are a form of static polymorphism and Overridden methods are a form of dynamic polymorphism. • Java access specifiers: public, protected, private help in the implementation of encapsulation. • The following modifiers are provided by Java: static, final, abstract, native, synchronized, and volatile. • Nested class can be static or non-static.

More Related