1. Java for C++ Programmers A Brief Tutorial

2. Overview Classes and Objects Simple Program Constructors Arrays Strings Inheritance and Interfaces Exceptions

3. Classes Everything is contained in a class Simple Example class Foo { private int x; public void setX(int num) { x = num; } public int getX() { return x; }

4. Classes Fields: member variables –initialized to 0, false, null, or ‘\u000’ Methods: member functions Accessibility –private: only local methods –public: any method –protected: only local and derived classes

5. Objects All objects are accessed and passed by reference –similar to pointers in C/C++ No explicit control of these “pointers” Warning: use of ==, !=, and = –more on this later

6. Simple Program Class FirstProgram { public static void main(String [] args) { Foo bar = new Foo(); bar.setX(5); System.out.println(“X is “ + bar.getX()); } compiling: prompt> javac FirstProgram.java –javac determines dependencies –above line create the file FirstProgram.class running: prompt> java FirstProgram

7. Programming Conventions class naming –capitalize first letter of each word –examples: Foo, NumBooks, ThisIsATest field, method, and object naming –capitalize all words except the first –examples: bar, testFlag, thisIsAnotherTest constants naming –capitalize all letters –examples: PI, MAX_ELEMENTS

8. Constructors called on object creation (similar to C++) to do some initial work and/or initialization can have multiple constructors constructors are always public and always the same name as the class no such thing as a destructor (java uses garbage collection to clean up memory)

9. Constructor Example class Example { private boolean flag; public Example() { flag = true; } public Example(boolean flag) { this.flag = flag; } this.___ operator used to access object field otherwise, parameter overrides object field

10. Arrays similar to C++ in function –consecutive blocks of memory (first index is 0) different from C++ in key ways –creation:int [] grades = new int[25]; –__.length operator: keeps track of array size –out-of-bounds exception: trying to access data outside of array bounds generates an exception

11. Array Example public void arrayTest() { int [] grades = new int(25); for(int i=0; i<grades.length; i++) array[i] = 0; } access arrays same as in C++ notice no parenthesis after the.length could also make an array of objects (similar to a 2-D array in C++)

12. Strings standard class in Java comparing strings –__.equals(String st): returns true if equal –__.toCompare(String st): similar to strcmp warning: using ==, !=, and = concatenation: use the + operator string length: use the __.length() method lots more methods for strings

13. Inheritance lets one class inherit fields and methods from another class use keyword extends to explicitly inherit another classes public and protected fields/methods can only explicitly extend from one class all classes implicitly extend the Object class

14. Object Class an Object object can refer to any object –similar to void pointer in C/C++ key methods in Object class –__.equals(Object obj) –__.hashCode() –__.clone() above methods inherited by all classes

15. __.equals(Object obj) Method by default only true if obj is the same as this usually need to override this method warning: ==, !=, = Example class Foo { private Character ch; public Foo(Character ch) { this.ch = ch; } public Character getCh() { return ch; } public boolean equals(Object ch) { return this.ch.charValue() == ((Foo)ch).getCh().charValue(); }

16. __.equals(Object obj) Method Example (continued) class Tester { public void static main(Strings [] args) { Character c1 = new Character(‘a’); Character c2 = new Character(‘a’); Foo obj1 = new Foo(c1); Foo obj2 = new Foo(c2); if(obj1.equals(obj2)) System.out.println(“Equal”); else System.out.println(“Not Equal”); }

17. __.hashCode and __.clone Methods __.hashcode hashes object to an integer –default usually returns a unique hash __.clone returns a copy of object –default sets all fields to the same as original can overide either of these functions

18. Inheritance overriding a method –must have the same signature as original –declaring a method final means future derived classes cannot override the method overloading a method –method has same name but different signature –they are actually different methods

19. Inheritance Example class Pixel { protected int xPos, yPos; public Pixel(int xPos, int yPos) { this.xPos = xPos; this.yPos = yPos; } public int getXPos() { return xPos; } public int getYPos() { return yPos; }

20. Inheritance Example (cont.) class ColorPixel extends Pixel { private int red, green, blue; public ColorPixel(int xPos, int yPos, int red, int green, int blue) { super(xPos, yPos); this.red = red; this.green = green; this.blue = blue; } public int getRed() { return red; } public int getGreen() { return green; } public int getBlue() { return blue; }

21. Inheritance abstract classes and methods –declaring a class abstract must have an abstract method class cannot be directly used to create an object class must be inherited to be used –declaring a method abstract method must be defined in derived class

22. Abstract Class abstract class Pixel {... public abstract void refresh(); } class ColorPixel extends Pixel {... public void refresh() { do some work } Note: signature of method in derived class must be identical to parent declaration of the method

23. Interface basically an abstract class where all methods are abstract cannot use an interface to create an object class that uses an interface must implement all of the interfaces methods use the implements keyword a class can implement more than one interface

24. Interface simple example class Tester implements Foo, Bar {... } Foo and Bar are interfaces Tester must define all methods declared in Foo and Bar

25. Static Fields and Methods field or methods can be declared static only one copy of static field or method per class (not one per object) static methods can only access static fields and other static methods accessed through class name (usually)

26. Static Fields and Methods simple example class Product { private static int totalNumber = 0; private int partNumber; public Product() { partNumber = totalNumber; totalNumber++; }... } only one copy of totalNumber

27. Static Fields and Methods class Product object one object two totalNumber = 2 partNumber = 0partNumber = 1

28. Exceptions some methods throw exceptions –public void checkIt() throws tooBadException methods that throw exceptions must be called from within try block usually have a catch block that is only executed if an exception is thrown any block of code can be executed in a try block

29. Exception Example class ExceptTest { public static void main(String [] args) { int [] grades = new int(25); try{ for(int i=0; i<=25; i++) grades[i] = 100; } catch(Exception e) { System.out.println(e); }

30. Odds and Ends reading data from users –more complicated than simple cin –example public static void main(String [] args) { InputStreamReader input = new InputStreamReader(System.in); BufferedReader in = new BufferedReader(input); String line = in.readLine();... }

31. Odds and Ends using string tokens –words in a sentence –StringTokenizer class hasMoreTokens() and nextToken() methods default delimitter is white space (could use anything) –example String line = new String(“Hello there all!”); StringTokenizer tok = new StringTokenizer(line); while(tok.hasMoreTokens()) { String tmp = tok.nextToken();... }

32. Odds and Ends using string tokens (continued) 3 separate strings inside the tokenizer class Hello there all! Hello thereall! call to new StringTokenizer()

33. Odds and Ends utilizing files in a code library –use the import command –example import java.lang.*; –* indicates to include all files in the library