java for c++ programmers a brief tutorial. overview classes and objects simple program constructors...
TRANSCRIPT
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 ProgramClass 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: ==, !=, =
• Exampleclass 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 Classabstract 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 exampleclass 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 exampleclass 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 = 0 partNumber = 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)
– exampleString 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 there all!
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