Advanced Object Oriented Programming. EECS2030 Section A

Transcription

1 Advanced Object Oriented Programming EECS2030 Section A 1

2 Who Am I? Dr. Mufleh Al-Shatnawi office Lassonde 3057 hours : 5:30PM -- 6:30PM on Tuesdays and Thursdays; or by appointments mufleh@eecs.yorku.ca 2

3 Course Format Everything you need to know will eventually be on the York University Moodle site. York course Moodle [ ] Check this site regularly for announcements and learning resources 3

4 Course Description While LE/EECS1020 and LE/EECS1021 focuses on the client concern, this course focuses on the concern of the implementer. Hence, rather than using an API (Application Programming Interface) to build an application, the student is asked to implement a given API. 4

5 Course Description (cont.) Topics include implementing classes (non-utilities, delegation within the class definition, documentation and API generation, implementing contracts), aggregations(implementing aggregates versus compositions and implementing collections), inheritance hierarchies (attribute visibility, overriding methods, abstract classes versus interfaces, inner classes); applications of aggregation and inheritance in concurrent programming and event-driven programming; recursion; searching and sorting including quick and merge sorts; stacks and queues; linked lists; binary trees. 5

6 Prerequisites You must at least have the below prerequisites: LE/EECS or LE/EECS 1020 (prior to Fall 2015) 3.00 or LE/EECS or LE/EECS The General Prerequisite is a cumulative GPA of 4.50 or better over all major EECS courses. 6

7 Lectures One person talks at a time in class, please! Do not use Cell phones during lectures. Attendance to all lectures and labs are necessary. Don t consider coming to classes as pressure. 7

8 Labs In Prism computing labs (LAS1006) Lab Zero starts in Week 1 self-guided, can be done anytime before the start of Week 2 using the Prism lab environment using eclipse Labs (<=8) consist of a different set of programming problems for each lab It is expected that you know how to use the lab computing environment. Fun, hard work, a great learning experience 8

9 Labs Lab Times LAB (Section-01): Tuesdays: 14:30-16:00 (LAS 1006) LAB (Section-02): Thursdays: 14:30-16:00 (LAS 1006) group lab work is allowed and strongly encouraged for Labs (not Lab Zero) groups of up to size 3 see Academic Honesty section of syllabus Do not submit work that is not wholly your own It is absolutely not acceptable that you: share your (programming or written) solutions with others; copy and paste solutions from elsewhere and claim that they are yours. 9

10 Labs Tips for effective group work alternate who is doing the typing (the driver) every few minutes don t allow the stronger programmer to do everything!! if you are the stronger programmer then try explaining your thought processes to your group partners if you aren t typing then you are a navigator you should be: 10 watching what the driver is doing to catch mistakes planning what the group should do next developing test cases to test the code that is being written

11 EECS Account needed for EECS2030 You must at least have a Prism Lab account before starting the course. If you don't have a Prism Lab account for EECS courses, please consult lab monitors at LAS You must have a YoRkU ID card with you at all times. If you don t have the account ready, you cannot do the labs and tests. 11

12 Lab Tests Computer test, based on lab exercises and lecture materials Each lab section has its own lab tests 12

13 Tests All testing occurs during your regularly scheduled lab using the EECS labtest environment Test Weight Lab Test 1 20% Lab Test 2 15% Lab Test 3 15% Exam 40% miss a test for an acceptable reason? see Evaluation: Missed tests section of syllabus 13

14 Textbook Aset of freely available electronic notes is available from the Moodle site Recommended textbooks Building Java Programs, 4 th Edition, S Rogesand M Stepp Introduction to Programming in Java, 2 nd Edition, R Sedgewick and K Wayne does not cover inheritance Absolute Java, 6 th Edition, W Savitch Recommended references Java 8 Pocket Guide,Liguoriand Liguori Effective Java, 3 rd Edition, J Bloch 14

15 Need Accommodation for Tests/Exams? Please approach me ( , in person) as soon as possible, so we can make proper arrangements for you. 15

16 Prepare your own machine Install Java, and Eclipse index.html IDE for Java Developers] 16

17 Organization of a Java Program Packages, classes, fields, and methods 17

18 Organization of a Typical Java Program one or more files 18

19 Organization of a Typical Java Program one or more files zero or one package name 19

20 Organization of a Typical Java Program one or more files zero or one package name zero or more import statements 20

21 Organization of a Typical Java Program one or more files zero or one package name zero or more import statements one class 21

22 Organization of a Typical Java Program one or more files zero or one package name zero or more import statements one class one or more fields (class variables) 22

23 Organization of a Typical Java Program one or more files zero or one package name zero or more import statements one class zero or more fields (class variables) zero or more more constructors 23

24 Organization of a Typical Java Program one or more files zero or one package name zero or more import statements one class zero or more fields (class variables) zero or more more constructors zero or more methods 24

25 Organization of a Typical Java Program it's actually more complicated than this static initialization blocks non-static initialization blocks classes inside of classes (inside of classes...) classes inside of methods anonymous classes lambda expressions (in Java 8) see 25

26 Packages Packages are used to organize Java classes into namespaces we organize files into different directories according to their functionality, usability as well as category they should belong to. A namespace is a container for names the namespace also has a name Hint: Java packages can be stored in compressed files called JAR files. 26

27 Packages Packages are use to organize related classes and interfaces e.g., all of the Java API classes are in the package named java package class directory (folder) file 27

28 Packages Packages can contain subpackages e.g., the package javacontains packages named lang, util, io, etc. The fully qualified name of the subpackageis the fully qualified name of the parent package followed by a period followed by the subpackage name e.g., java.lang, java.util, java.io 28

29 Examples: The Java API javax.swing: classes dealing with the development of GUIs. java.lang: essential classes required by the Java language. java.text: facilities for formatting text output. java.util: classes for storing/accessing collections of objects. java.net: for network communication. 29

30 Packages Packages can contain classes and interfaces e.g., the package java.lang contains the classes Object, String, Math, etc. The fully qualified name of the class is the fully qualified name of the containing package followed by a period followed by the class name e.g., java.lang.object, java.lang.string, java.lang.math 30

31 Packages Packages are supposed to ensure that fully qualified names are unique For example, if we have a class name called "Vector", its name would crash with the Vector class from JDK. However, this never happens because JDK uses java.utilas a package name for the Vector class (java.util.vector ). This allows the compiler to disambiguate classes with the same unqualified name, e.g., your.string s = new your.string("hello"); String t = "hello"; 31

32 Packages How do we ensure that fully qualified names are unique? Package naming convention packages should be organized using your domain name in reverse, e.g., EECS domain name eecs.yorku.ca package name ca.yorku.eecs We might consider putting everything for this course under the following package eecs

33 Packages We might consider putting everything for this course under the following package eecs2030 Labs might be organized into subpackages: eecs2030.lab0 eecs2030.lab1 and so on Tests might be organized into subpackages: eecs2030.test1 eecs2030.test2 and so on 33

34 Packages Most Java implementations assume that your directory structure matches the package structure, e.g., there is a folder eecs2030inside the project srcfolder there is a folder lab0inside the eecs2030folder there is a folder lab1inside the eecs2030folder, and so on 34

35 Packages project folder project sources folder eecs2030 folder lab0 folder To put a class into a package, one uses the "package" statement 35

36 Importing a package import packagename.*; // all classes import packagename.classname;// one class 36

37 Importing a package -Static import import static packagename.classname.*; Example: import static java.lang.math.*;... double angle = sin(pi / 2) + ln(e * E); Static import allows you to refer to themembers of another class without writing that class's name. Should be used rarely and only with classes whose contents are entirely static "utility" code. 37

38 Package access Java provides the following access modifiers: public: Visible to all other classes. private: Visible only to the current class (and any nested types). protected : Visible to the current class, any of its subclasses, and any other types within the same package. default (package): Visible to the current class and any other types within the same package. 38

39 Notes on the import statement Import ONLY imports public classes from the specified package Classes which are not public cannot be referenced from outside their package. There is no way to "import all classes except one" import either imports a single class or all classes within the package Note: importing has no runtime or performance implications. It is only importing a namespace so that the compiler can resolve class names. Import statements must appear at the top of the file after the package statement and before any class or interface definitions. 39

40 Objects in JAVA Basics 40

41 Define Your Own Objects In the previous course, you may have already gained experience in defining your own data structures (a.k.a. data types, objects) that you used within your program in order to group various data elements together. we create this object by defining a class. Each class that we define represents a new type (or category) of object. 41

42 Objects A object represents multiple pieces of information that are grouped together. A primitive data type (e.g., int, float, char) represents a single simple piece of information. An object, however, is a bundle of data, which can be made up of multiple primitives or possibly other objects as well. 42

43 Objects Once we define Address class/object, then we were allowed to create Address objects and use them within our programs. Address addr; addr = new Address(); 2030 addr.name = "EECS Student One"; addr.streetnumber = 2030; addr.streetname = "EECS Department ST"; addr.city = "Tornoro"; addr.province = "ON"; addr.postalcode = "M3J 1P3"; System.out.print(addr.name + " lives at "); System.out.println(addr.streetNumber + " " + addr.streetname); 43

44 Overview An object can contain variables as well as methods. Variable in an object is called a field. Declare fields in the class definition. Generally, make fields privateso they can t be seen from outside the class. May add getter methods (functions) and setter methods (procedures) to allow access to some or all fields. Use a new kind of method, the constructor, to initialize fields of a new object during evaluation of a new-expression. 44

45 Example public class Circle { public double x, y; // centre coordinate public double r; // radius of the circle } The fields (data) are also called the instance variables. 45

46 public class Circle { public double x, y; // centre of the circle public double r; // radius of circle } //Methods to return circumference and area public double circumference() { return 2*3.14*r; } public double area() { return 3.14 * r * r; } Method Body 46

47 Data Abstraction Declare the Circle class, have created a new data type Data Abstraction Can define variables (objects) of that type: Circle acircle; Circle bcircle; acircle, bcirclesimply refers to a Circle object, not an object itself. acircle bcircle Points to nothing (Null Reference) null null 47

48 Creating objects of a class Objects are created dynamically using the new keyword. acircle = new Circle() ; bcircle = new Circle() ; 48

49 49 Non-static classes

50 Non-static classes A utility class has features (fields and methods) that are all static. therefore, you do not need objects to use those features a well implemented utility class should have a single, empty private constructor to prevent the creation of objects Most Java classes are not utility classes they are intended to be used to create to objects each object has its own copy of all non-static fields it is also useful to imagine that each object has its own copy of all non-static methods 50

51 Why objects? Each object has its own copy of all non-static fields this allows objects to have their own state in Java the state of an object is the set of current values of all of its non-static fields Object-oriented programming in Java: Use classes to define templates Use objects to instantiate classes At runtime, create objects and call methods on objects, to simulate interactions between real-life entities. 51

52 Implementing classes Many classes represent kinds of values examples of values: name, date, colour, mathematical point or vector Java examples: String, Date, Integer When implementing a class you need to choose appropriate fields to represent the state of each object Consider implementing a class that represents 2- dimensional points a possible implementation would have: a field to represent the x-coordinate of the point a field to represent the y-coordinate of the point 52

53 /** * A simple class for representing points in 2D Cartesian * coordinates. Every <code>simplepoint2d</code> instance has a * public x and y coordinate that can be directly accessed * and modified. * EECS2030 Winter * */ public class SimplePoint2 { } public float x; public float y; public class: any client can use this class public fields: any client can use these fields by name Note: Client is any class with its main method using the utility methods, Supplier: A single utility class. 53

54 Using SimplePoint2 Even in its current form, we can use SimplePoint2to create and manipulate point objects 54

55 public static void main(string[] args) { // create a point SimplePoint2 p = new SimplePoint2(); // set its coordinates p.x = -1.0f; p.y = 1.5f; } // get its coordinates System.out.println("p = (" + p.x + ", " + p.y + ")"); 55

56 Using SimplePoint2 Notice that printing a point is somewhat inconvenient we have to manually compute a string representation of the point Initializing the coordinates of the point is somewhat inconvenient we have to manually set the x and y coordinates we get unusual results when using equals 56

57 public static void main(string[] args) { // create a point SimplePoint2 p = new SimplePoint2(); // set its coordinates p.x = -1.0f; p.y = 1.5f; // get its coordinates System.out.println("p = (" + p.x + ", " + p.y + ")"); SimplePoint2 q = new SimplePoint2(); q.x = p.x; q.y = p.y; } // equals? System.out.println("p.equals(q) is: " + p.equals(q)); 57

58 Encapsulation We can add features to SimplePoint2to make it easier to use we can add methods that use the fieldsof SimplePoint2to perform some sort of computation (like compute a string representation of the point) we can add constructors that set the values of the fieldsof a SimplePoint2 object when it is created In object oriented programming the term encapsulationmeans bundling data and methods that use the data into a single unit 58 That involves enclosing an object with a kind of protective bubble so that it cannot be accessed or modified without proper permission.

59 Constructors The purpose of a constructor is to initialize the state of an object it should set the values of all of the non-static fields to appropriate values Aconstructor: must have the same name as the class never returns a value (not even void) constructors are not methods can have zero or more parameters 59

60 Default constructor The default constructor has zero parameters The default constructor initializes the state of an object to some well defined state chosen by the implementer 60

61 public class SimplePoint2 { public float x; public float y; /** * The default constructor. Sets both the x and y coordinate * of the point to 0.0f. */ public SimplePoint2() { } this.x = 0.0f; this.y = 0.0f; Inside a constructor, the keyword this is a reference to the object that is currently being initialized. 61

62 Custom constructors A class can have multiple constructors but the signatures of the constructors must be unique i.e., each constructor must have a unique list of parameter types It would be convenient for clients if SimplePoint2 had a constructor that let the client set the x and y coordinate of the point 62

63 public class SimplePoint2 { public float x; public float y; /** * Sets the x and y coordinate of the point to the argument * values. * x the x coordinate of the point y the y coordinate of the point */ public SimplePoint2(float x, float y) { } this.x = x; this.y = y; this.x : the field named xof thispoint this.y : the field named yof this point x : the parameter named xof the constructor y : the parameter named yof the constructor 63

64 SimplePoint2 p = new SimplePoint2(-1.0f, 1.5f); 1. newallocates memory for a SimplePoint2 object p 64 client 600a 2. the SimplePoint2 constructor is invoked by passing the memory address of the object and the arguments -1.0fand 1.5f to the constructor 3. the constructor runs, setting the values of the fields this.xand this.y fields x y 600 SimplePoint2 object -1.0f 1.5f 4. the value of p is set to the memory address of the constructed object parameters this x 700 SimplePoint2 constructor 600a -1.0f y 1.5f 64

65 this In our constructor public SimplePoint2(float x, float y) { this.x = x; this.y = y; } there are parameters with the same names as fields when this occurs, the parameter has precedence over the field we say that the parameter shadowsthe field when shadowing occurs you must use thisto refer to the field 65

66 Custom constructors Adding the constructor SimplePoint2(float x, float y) allows the client to simplify their code 66

67 public static void main(string[] args) { // create a point SimplePoint2 p = new SimplePoint2(); // set its coordinates p.x = -1.0f; p.y = 1.5f; // get its coordinates System.out.println("p = (" + p.x + ", " + p.y + ")"); SimplePoint2 q = new SimplePoint2(); q.x = p.x; q.y = p.y; } // equals? System.out.println("p.equals(q) is: " + p.equals(q)); 67

68 public static void main(string[] args) { // create a point SimplePoint2 p = new SimplePoint2(-1.0f, 1.5f); // set its coordinates p.x = -1.0f; p.y = 1.5f; // get its coordinates System.out.println("p = (" + p.x + ", " + p.y + ")"); SimplePoint2 q = new SimplePoint2(p.x, p.y); q.x = p.x; q.y = p.y; } // equals? System.out.println("p.equals(q) is: " + p.equals(q)); 68

69 Copy constructor A copy constructor initializes the state of an object by copying the state of another object (having the same type) it has a single parameter that is the same type as the class 69

70 public class SimplePoint2 { public float x; public float y; /** * Sets the x and y coordinate of this point by copying * the x and y coordinate of another point. * other a point to copy */ public SimplePoint2(SimplePoint2 other) { this.x = other.x; this.y = other.y; } 70

71 Copy constructor Adding a copy constructor allows the client to simplify their code 71

72 public static void main(string[] args) { // create a point SimplePoint2 p = new SimplePoint2(-1.0f, 1.5f); // set its coordinates p.x = -1.0f; p.y = 1.5f; // get its coordinates System.out.println("p = (" + p.x + ", " + p.y + ")"); SimplePoint2 q = new SimplePoint2(p.x, p.y); q.x = p.x; q.y = p.y; } // equals? System.out.println("p.equals(q) is: " + p.equals(q)); 72

73 public static void main(string[] args) { // create a point SimplePoint2 p = new SimplePoint2(-1.0f, 1.5f); // set its coordinates p.x = -1.0f; p.y = 1.5f; // get its coordinates System.out.println("p = (" + p.x + ", " + p.y + ")"); SimplePoint2 q = new SimplePoint2(p); q.x = p.x; q.y = p.y; } // equals? System.out.println("p.equals(q) is: " + p.equals(q)); 73

74 Avoiding Code Duplication Notice that the constructor bodies are almost identical to each other all three constructors have 2 lines of code all three constructors set the x and y coordinate of the point Whenever you see duplicated code you should consider moving the duplicated code into a method In this case, one of the constructors already does everything we need to implement the other constructors 74

75 Constructor chaining A constructor is allowed to invoke another constructor When a constructor invokes another constructor it is called constructor chaining To invoke a constructor in the same class you use the this keyword if you do this then it must occuron the first line of the constructor body but you cannotuse this in a method to invoke a constructor We can re-write two of our constructors to use constructor chaining... 75

76 public class SimplePoint2 { public float x; public float y; public SimplePoint2() { } this(0.0f, 0.0f); invokes public SimplePoint2(float x, float y) { this.x = x; this.y = y; } public SimplePoint2(SimplePoint2 other) { } this(other.x, other.y); invokes 76

77 References for EECS 2030] 77