Review of Java

1. Review of Java • Basic Concepts • Names and Reserved Words • Expressions and Precedence of Operators • Flow of Control – conditional statements • Flow of Control – loops • Arrays • Reading: Your CS110 Text/Notes

2. Review of Java • If you are not completely familiar with this material, please see me. You should not be taking this course! • Don’t expect that you’ll catch up as we go through the CS210 material. That is not going to work!

3. Names and Reserved Words • Names are used for classes and methods: • Classes: Scanner, BingoBall • Methods: next( ), hasNext( ) • Names are used for variables and constants • Variables: i, j, current, currentValue, isOn • Constants: SIZE, MAX_VALUE • Reserved words are java language identifiers: • Examples: class, return, public, static, int, boolean

4. Expressions and Precedence • There are three major groups of basic operations in Java: • Arithmetic (+, -, * , /, %, ++, --, ... ) • Comparison ( !=, ==, <=, => , < , ...) • Logical ( ||, &&, !) Arithmetic operators have the highest precedence followed by comparison operators. Logical operators have the least precedence.

5. Expressions and Precedence • The precedence of operators determines the order of evaluation for expressions. Here is the order precedence of For arithmetic operations from highest to lowest: • Highest: [ ], ( ), ++, -- • Next: +(unary), -(unary), ~, ! • Next: new, (type) • Next: *, /, % • Next: +(binary), -(binary) • Etc.

6. Expressions and Precedence • An Expression is a construct made up of operators and method invocations applied on variables and constants. • Each expression has a type. • Examples: • x+y+3 (x and y are integer variables) • z/3+y%2 (z is a double and y is an int) • x<=z && ~(y > 2) • obj.doIt()

7. Flow of Control - Selection • If statements with optional else clauses: if (boolean condition){ statement; } else { statement; } • Switch statements switch (integer value) { case FIRST_VALUE: statements; case SECOND_VALUE: statements; default: statements; }

8. Flow of Control - Repetition • While while (scan.hasNext()) { statements; // repeated until false above } • For for (int i = 0; i < MAX; i++) { statements; // repeated until false above } • Do … while do { statements; // repeated until false below } while (!done);

9. Arrays • Arrays are a group of elements that can be referenced via a name and an index value • Declaring an array with or w/o initialization int [] digits = new int [10]; OR int [] digits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; • Setting the value of an element of an array digits [0] = 0; • Using the values of elements of an array int sum = digits[2] + digits[4];

10. Review of Java • Object Oriented Programming Concepts • Objects and Classes • Encapsulation, Constructors, and Methods • References and Aliases • Interfaces and Inheritance • Class Hierarchies and Polymorphism • Generic Types (ArrayList Class) • Exceptions • Reading: L&C Appendix B (3rd Ed.) or Chap. 2 (2nd ed.)

11. Data Types • Java Primitive types: int, double, boolean, char, byte, … • Arrays (Array of ints, Array of boolean, …)

12. Data Types • Java Primitive types: int, double, boolean, char, byte, … • Arrays (Array of ints, Array of boolean, …) • To define more complex customized types, we write our own classes which define the type of the data objects (instances) of that class. • We define a class by using and combining other types (primitive types, arrays and other defined classes)

13. Objects and Classes • Object and class relationship • Class Definition public class ClassName { // attributes <=== defines the state of the objects of this type (instances of the class) // methods <=== defines the behavior of the } objects • Instantiating Objects using Classes ClassName myClassName = new ClassName();

14. Class Definition • public class Car { • private int speed; <== object attributes or • private Engine engine; instance variables • public int getSpeed() { • return speed; • } • public void drive() { • .... • } • }

15. Encapsulation • Encapsulation of Attributes public class ClassName { // constants public static final int MAX_SIZE = 20; private static final int DEFAULT_SIZE = 10; // class variables private static int largestSizeOfAll; // instance variables private int mySize; }

16. Constructors and Methods • Constructor (ClassName with no return type) public class ClassName { public ClassName (parameter list if any) { statements; } • Method (Method name with a return type) public type methodName(parameter list if any) { statements; } }

17. Constructor • A constructor is a special method that is designed to create an object (initialize an object). • A constructor is different from a regular method in three ways.

18. Using References • Using a class constant if (size <= ClassName.MAX_SIZE) statement; • Using a class method (static method) type returnValue = ClassName.methodName(...); • Using an instance method via a reference type returnValue = myClassName.methodName(...);

19. Aliases and Garbage Collection • Creating an alias of a reference ClassName yourClassName = myClassName; • Making object eligible for garbage collection myClassName = yourClassName = null; myClassName Object of class ClassName yourClassName myClassName null Object of class ClassName yourClassName null “Garbage”

20. Primitive/Non-primitive Types • int x; x • x = 12; x • String y; y • String y = new String(“ABC”); y • y = null; y 0 12 null “ABC” null “ABC”

21. Method Overloading • public class Car { • .... • public void drive() { • int temp = 12; <------------- local attribute (scope?) • .... • } • public void drive(int speed) { • .... • } • } • ------------------------------------------------------------------------------------- • Car ford = new Car(...); • ford.drive(110); this method call binds to ??? instance mthod

22. public class YourClass { priavate static classAttr; .... } static variable (class variable): there is only one copy of the attribute which is associated with the class itself. All Objects of type YourClass can access and modify this class variable and changing it in one object is seen by all other objects. Static/non-static var • public class MyClass { • private int objAttr; • .... • } • instance variable (object attribute): one copy of attribute for each Object of type MyClass. Each object can access and modify its own copy. An object changing its own attribute will not be seen by other instances.

23. public class YourClass { public static String yourMethod(int y) { .... } } static method is associated with the class itself. To call the method: String y = YourClass.yourMethod(211); Static/non-static method • public class MyClass { • public String myMethod() { • .... • } • } • instance method or object method is associated with an object of type MyCLass. To call the method: • MyClass mine= new MyClass(...); • String x = mine.myMethod();

24. Interface • An interface is a collection of constants and abstract methods. • An abstract method has no code attached to it. It is just composed of the method header. • A class implements an interface by providing method implementation for each of the abstract methods of the interface.

25. Interfaces • A class that implements an interface public class ClassName implements InterfaceName { . . . } <<interface>> InterfaceName Interface defines the method signature for all required methods ClassName Class must define code for all methods defined in InterfaceName

26. Inheritance • A class that extends another class public class ClassName extends SuperClassName { . . . } SuperClass defines all the methods for all SubClasses. SuperClassName ClassName SubClass may define code to override some or all of the SuperClass methods

27. Inheritance • All the public and protected methods of the super-class are accessible by the subclasses, but not the private ones. • A subclass may have additional methods and instance variables of its own. • The super-class does not know anything about its subclasses. • A sub-class may override some or all of the methods of the super-class. (Example)

28. class/interface/abstarct class • Difference between: • class and abstract class? • abstract class and interface?

29. Inheritance • A class that extends an abstract class public class ClassName extends SuperClassName { . . . } <<abstract>> SuperClassName SuperClass defines some of the methods for all SubClasses, but only defines method signatures for the rest of the methods ClassName SubClass may define code to override some or all of the SuperClass methods, but must define code for the signatures

30. Class Hierarchies and Polymorphism • An object reference variable may hold as a reference to any compatible type of object • Compatibility may be via implementing an interface or inheritance from another class ClassName a = new ClassName(); InterfaceName b = new ClassName(); SuperClassName c = new ClassName(); • Object behaves as class it was “born as” (i.e. class used with the new operator)

31. Polymorphism via interface interface Service public int provide(); Clas Class Service A implements Service public int provide() { … } Class Service A Class Service B implements Service public int provide() { … } Service[] services = new Service[2]; services[0] = new ServiceA(...); services[1] = new ServiceB(...); for(int i = 0; i < services.length; i++) { services[i].provide(); }

32. Generic Types • Collection classes like the ArrayList class can be defined to hold a specific type of object via a generic type designation <T> ArrayList<String> myList = new ArrayList<String>(); • We will use generics often in CS210 with many other types of “collection” classes

33. Exceptions • When code encounters a situation that is impossible for it to resolve at that point, it may throw an Exception object, e.g. NameOfException instead of executing its normal return • If a method may throw an exception, it should indicate that in its method header public void methodName() throws NameOfException { if (boolean condition of impossible situation) throw new NameOfException(); }

34. Process the Exception • Three options to handle an Exception: • Not handle it at all and let the program terminate • Handle the exception where it occurs • Handle the exception at another point in the program (for example the caller of the method or caller of the caller of the method and ... )

35. Exception Handling • Code that calls a method that may throw a checked exception must use try-catch or indicate that it throws that exception in its own method header try { statements with call to methodName(); } catch (NameOfException e) // may be multiple catch clauses { statements to recover from occurrence of exception } finally // optional finally clause { statements always performed, e.g. clean up actions }

36. File Input: Example import java.util.Scanner; import java.io.*; public class FileDisplay { public static void main (String [] args) throws IOException { Scanner scan = new Scanner(System.in); System.out.println("Enter name of file to display"); File file = new File(scan.nextLine()); Scanner fileScan = new Scanner (file); while (fileScan.hasNext()) System.out.println(fileScan.nextLine()); } }

37. File Output: Example import java.util.Scanner; import java.io.*; public class FileWrite { public static void main (String [] args) throws IOException { // Get filename and instantiate File object as before PrintStream out = new PrintStream(file); while (scan.hasNext()) { String line = scan.nextLine(); if (line.equals("END")) // A sentinel String value break; else out.println(line); } out.close(); } }