Introduction To Classes

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.