Java for C++ Programmers A Brief Tutorial

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

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; }

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

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

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

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

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)

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

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

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++)

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

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

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

__.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(); }

__.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”); }

__.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

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

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; }

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; }

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

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

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

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

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)

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

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

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

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); }

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();... }

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();... }

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

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