Object-Oriented Programming (Java)

Transcription

1 Object-Oriented Programming (Java)

2 Topics Covered Today 2.1 Implementing Classes Defining Classes Inheritance Method equals and Method tostring 2

3 Define Classes class classname extends superclass{ type instance-variable1; type instance-variable2; // type instance-variablen; type methodname1(parameter-list){ // body of method // type methodnamen(parameter-list){ // body of method class name attribute method 3

4 Point Class class Point { private int x, y; public Point() { x=0; y=0; public Point(int x, int y) { this.x=x; this.y=y; public void move(int newx, int newy) { x = newx; y = newy; 4

5 Create Object Declare: Point p; // only variable declaration Instantiation: Use new to allocate memory for object instance, which will invoke the corresponding constructor method to initialize the values of attributes defined in a class 5

6 Creating objects of a class Point p = new Point(20,23); 0x0000 0xFF

7 Creating objects of a class Point pointone = new Point(); Point pointtwo = new Point() ; pointone = pointtwo; Before Assignment After Assignment pointone pointtwo pointone pointtwo P Q P Q 7

8 Automatic garbage collection The object P does not have a reference and cannot be used in future. The object becomes a candidate for automatic garbage collection. Java automatically collects garbage periodically and releases the memory used to be used in the future. 8

9 Accessing Object/Point Data Similar to C syntax for accessing data defined in a structure. Using object variable objectreference.variable p.x= 10; Using object method objectreference.methodname([paramlist]); p.move(30,20); 9

10 Class Diagram to JAVA Code -x : int -y : int Point public class Point { private int x; private int y; +Point() +Point(newX : int, newy : int) +getx() : int +gety() : int +setx(newx : int) +sety(newy : int) 10

11 Class Diagram to JAVA Code Point -x : int -y : int +Point() +Point(newX : int, newy : int) +getx() : int +gety() : int +setx(newx : int) +sety(newy : int) public class Point { public Point(int newx, int newy) { x = newx; y = newy; public Point(){ x = 0; y = 0; 11

12 Class Diagram to JAVA Code -x : int -y : int Point public class Point { public int getx() { return x; +Point() +Point(newX : int, newy : int) +getx() : int +gety() : int +setx(newx : int) +sety(newy : int) public int gety() { return y; 12

13 Class Diagram to JAVA Code Point -x : int -y : int +Point() +Point(newX : int, newy : int) +getx() : int +gety() : int +setx(newx : int) +sety(newy : int) public class Point { public void setx(int newx) { x = newx; public void sety(int newy) { y = newy; 13

14 Class Diagram to JAVA Code public class Point { public static void main(string[] args) { Point pointone = new Point(10, 100); System.out.println("x: " + pointone.getx()); System.out.println("y: " + pointone.gety()); pointone.setx(20); pointone.sety(200); sent message to pointone System.out.println("new x: " + pointone.getx()); System.out.println("new y: " + pointone.gety()); 14

15 Static Member Java supports definition of global methods and variables that can be accessed without creating objects of a class. Such members are called Static members. This feature is useful when we want to create a variable common to all instances of a class. One of the most common example is to have a variable that could keep a count of how many objects of a class have been created. Note: Java creates only one copy for a static variable which can be used even if the class is never instantiated. Static member of a class can be accessed by the class and objects of the class. 15

16 Static Variables Define using static: static int numberofinstances = 0; Access with the class name (ClassName.StatVarName): npoints = Point. numberofinstances; 16

17 Static Variables - Example public class Point { // class variable, one for the Point class, how many points private static int numberofinstances = 0; // Constructors... public Point(int newx, int newy) { x = newx; y = newy; numberofinstances++; public Point() { x = 0; y = 0; numberofinstances++; 17

18 Class Variables - Example public class Point { public static void main(string[] args) { Point pointone = new Point(10, 100); // numberofinstances =1 Point pointtwo = new Point(20,-200); // numberofinstances =2 pointone = new Point(10, 100); pointtwo = new Point(20,-200); numberofinstances 18

19 Instance Vs Static Variables Instance variables : One copy per object. Every object has its own instance variable. E.g. x, y Static variables : One copy per class. E.g. numberofinstances (total number of point objects created) 19

20 Static Methods A class can have methods that are defined as static (e.g., main method). Static methods can be accessed without using objects. Also, there is NO need to create objects. They are prefixed with keyword static 20

21 Static Method - Example public class Point { private static int numberofinstances = 0; public Point(int newx, int newy) { x = newx; y = newy; numberofinstances++; public Point() { x = 0; y = 0; numberofinstances++; public static int getnumberofinstances() { return numberofinstances; 21

22 Static Method - Example public class Point { public static void main(string[] args) { Point pointone = new Point(10, 100); System.out.println("x: " + pointone.getx()); System.out.println("y: " + pointone.gety()); System.out.println("Instances before PointTwo is created: " + Point.getNumberOfInstances()); Point pointtwo = new Point(20,-200); pointone.setx(20); pointone.sety(200); Point pointthree = pointone; System.out.println("new x: " + pointone.getx()); System.out.println("new y: " + pointone.gety()); System.out.println("Instances after PointTwo is created: " + Point.getNumberOfInstances()); 22

23 Output X : 10 Y : 100 New x : 20 New y : 200 Instances before PointTwo is created: 1 Instances after PointTwo is created: 2 23

24 Static main method An application requires a public static void main(string args[]) method. It must be static because, before your program starts, there aren t any objects to send messages to. public static void main(string[] args) { 24

25 Static methods restrictions They can only call other static methods. They can only access static data. They cannot refer to this or super (more later) in anyway. 25

26 Accessor and Mutator Methods An accessor method returns the current value of a variable Named getvariablename; A mutator method changes the value of a variable Named setvariablename; 26

27 Example: Getters and Setters public class BankAccount{ String accountnumber; int balance; BankAccount (String accnumber, int start){ accountnumber = accnumber; balance = start; String getaccountnumber () { return accountnumber; int getbalance () { return balance; void setbalance (int amount) { balance = balance + amount; 27

28 Encapsulation In general, instance variables should not be directly reachable by other classes using the dot (.) operator We need to build setter methods for all the instance variables in a class and find a way to force other code to call the setters rather than access the data directly. Why? By forcing other classes to call a setter method, we can protect instance variables from unacceptable changes (e.g. weight = -1) 28

29 Encapsulation An encapsulated object can be thought of as a black box -- its inner workings are hidden from the client The client invokes the interface methods of the object, which manages the instance data Client Methods Data 29

30 Visibility Modifiers In Java, we accomplish encapsulation through the appropriate use of visibility modifiers Visibility modifiers control who may access: classes methods data members Java has four visibility modifiers public protected (friendly) private 30

31 Public and Private Access public Anyone may access the item. private The item may only be accessed from the current class. 31

32 Friendly and Protected Access Friendly Access (Package local) Marked by the absence of access modifiers. The item may be accessed from anywhere within the same package. protected The item may be accessed from any subclass of the current class, or from anywhere within the same package. 32

33 Encapsulation Rule of Thumb Mark instance variables private Provide public accessors and mutators for access control 33

34 Keyword final Methods and data members can be declared final. The meaning is that a final item cannot be changed. Most common use so far: static final. 34

35 Meanings of final final variable: Value cannot be assigned anymore. final method: No subclass can override this method. final class: No class can inherit from this class. 35

36 Topics Covered Today 2.1 Implementing Classes Defining Classes Inheritance Method equals and Method tostring 36

37 Inheritance Using inheritance to implement specialization / generalization relationship in JAVA 37

38 Superclasses and Subclasses Person is called superclass or base class or parent class Employee is called subclass or derived class or child class 38

39 The is a relationship Inheritance creates an is-a relationship. Employee is a Person. Everything that can be done with a Person object can also be done with an Employee object. An Employee is a special kind of Person. It has all the functionality of a Person and some more. The subclass instances are more specific than the instances of the superclass. 39

40 Declare a subclass public class DerivedClass extends BaseClass { 40

41 Superclasses and Subclasses Any class can be both at same time e.g., Mammal is superclass of Moose and subclass of Animal Can only inherit from one superclass in Java C++ allows a subclass to inherit from multiple superclasses 41

42 Implementation of Class Person public class Person { private String name; private String address; public Person (String initialname, String initialaddress) { name = initialname; address = initialaddress; public String getname() { return this.name; public String getaddress() { return this.address; 42

43 Implementation of Class Employee public class Employee extends Person { private double salary; public Employee (String initialname, String initialaddress, double initialsalary) { super(initialname, initialaddress); salary = initialsalary; public double getsalary() { return this.salary; public void setsalary(double newsalary) { salary = newsalary; 43

44 What is Inherited? When you derive a class from a given base class: The subclass inherits all the fields of the base class It inherits all the methods of the base class You have to declare the constructors of the subclass from scratch Public fields and methods of the super-class can be used just like the fields and methods of the subclass Private fields and methods are inherited but cannot be accessed directly from the code of the subclass 44

45 Constructors Must Be Redefined Constructors of the subclass are not inherited They must be redefined in the subclass The constructor of the sub-class will normally need to use the constructor of the super-class This is done using the super keyword 45

46 Calling super(...) The first line in the constructor must be either: a call to a constructor of the super-class using super(...). A call to another constructor of the subclass using this( ). If you do not call super(...) or this(..) in the first line of the constructor, the compiler automatically places a call to the empty constructor of the superclass. If there is no empty constructor in the super-class the code will not compile! 46

47 Automatic Default Construction If we do not declare any constructor in a class then the compiler automatically adds an empty (default) constructor to it. In addition, the compiler puts in the first line of the empty constructor a call to the empty constructor of the super-class. 47

48 Using Person and Employee Classes public class test { public static void main(string[] args) { Employee e = new Employee("John","San Hao Street",1500); System.out.println("The employee name, address and salary are: " + e.getname() + "," + e.getaddress() + "," + e.getsalary()); 48

49 Person & Employee An object with the type of the subclass can be assigned to an object reference of the superclass (Upcasting) Person person = new Employee("Joe Smith", "100 Main Ave", ); The object reference of the superclass could not invoke the method defined in the subclass double salary = person.getsalary(); String name = person.getname(); String address = person.getaddress(); 49

50 Person & Employee Type conversion between Person and Employee Employee employee = (Employee) person; double salary = employee.getsalary(); or double salary = ((Employee) person).getsalary(); If the object reference points to a Person object,it can not converted to Employee Person person = new Person ("Joe Smith", "100 Main Ave"); double salary = ((Employee) person).getsalary(); 50

51 Casting Objects In Java, it is only possible to convert between superclasses and subclasses with casting. Two kinds of cast: Upcast Downcast 51

52 Upcast: Subclass Superclass Consider an object to be a parent class of the object s declared class. Always possible because substitutability is assumed. Can be implicit. Person person = new Employee("Joe Smith", "100 Main Ave", ); Animal Mammal Dog 52

53 Downcast: Superclass Subclass Consider an object to be of a subclass of its declared class. Not always possible. The type of the object to be cast is checked at runtime. Must always be explicit. Animal Mammal Dog 53

54 Example Using Downcast Person person = new Employee("Joe Smith", "100 Main Ave", ); Employee employee = (Employee) person; double salary = employee.getsalary(); Person person = new Person ("Joe Smith", "100 Main Ave"); double salary = ((Employee)person).getSalary(); JVM will throw a ClassCastException 54

55 Instanceof Operator Instanceof Operator Syntax: object instanceof ClassX Take an object reference as its first operand and a class or interface as its second operand and produces a boolean result. The instanceof operator evaluates to true if and only if the runtime type of the object is compatible with the class or interface. Use instanceof for safe casts: Person person = new Person ("Joe Smith", "100 Main Ave"); if (person instanceof Employee) { salary = ((Employee) person).getsalary(); 55

56 Review questions Visibility for class, attribute and method Usage of key word static for class, attribute, and method Usage of key word final for class, attribute, and method Why and how to do encapsulation Type conversion of object reference (Upcast and Downcast) 56

57 Answer: Practical Quiz

58 Answer: Practical Quiz