1 / 43

Java Lecture 1

Java Lecture 1. Introduction John Black CS 425. Overview. Java is: Like C/C++ Object-Oriented Interpreted Portable Multi-Threaded. Types of Java Programs. Standalone (has main()) Applet A dynamically loaded class (so no main()) Special environment (browser or applet viewer)

idalee
Download Presentation

Java Lecture 1

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Java Lecture 1 Introduction John Black CS 425

  2. Overview • Java is: • Like C/C++ • Object-Oriented • Interpreted • Portable • Multi-Threaded

  3. Types of Java Programs • Standalone (has main()) • Applet • A dynamically loaded class (so no main()) • Special environment (browser or applet viewer) • Restricted (memory, disk access, screen area) • Servlet • Java program which runs on Server • Dynamically loaded (so no main() again)

  4. Standalone Java Program • Collection of “class” files • Each class file has one public class • This class is the same as the filename of this class file • Exactly one file contains main() • Prototype for main() is public static void main(String args[]) (You can’t omit the parameters or the interpreter will consider this a different method!!)

  5. More on main() • Notice that main has type void • Cannot “return(val)” from main() • Use System.exit(val) instead • Interpreter runs until main() exits and then waits for all threads to complete before terminating

  6. Example: echo.java echo.java: public class echo { public static void main(String argv[]) { for (int i=0; i < argv.length; i++) System.out.print(argv[i] + “ “); System.out.print(“\n”); System.exit(0); } } You can find this example on the web page.

  7. CompilingandRunning • Say we have this echo class in a file called echo.java % javac echo.java // compiles % ls echo.class // is the class file there? echo.class % java echo hello world // now run it! hello world %

  8. The CLASSPATH variable • All public classes are in different files, so how does the compiler find them? • class file containing main() must import them import echo; • javac looks in directories indicated in CLASSPATH environment variable ex. % setenv CLASSPATH /home/jrb/java/classes:. set CLASSPATH C:\java\classes;.

  9. CLASSPATH (cont.) • If javac doesn’t find class file, it makes one • If echo.class doesn’t exist and echo.java does, javac compiles echo.java for you • At run-time classes must be available also % java echo // looks for echo.class in // CLASSPATH list • All classes used must be available for java interpreter at run-time

  10. Packages • A package is a set of associated classes • Package names are words separated by dots ex: java.lang.String.substring() • System classes (like java.lang.String) are automatically found by the compiler/interpreter • User-defined packages must be in a directory within CLASSPATH following package name package class method

  11. Packages (cont.) • Ex: cs425.std.echo must be in a directory cs425/std rooted in some CLASSPATH directory • The “package” statement must appear first • The package statement tells the compiler which package this class belongs to • If no package statement, classes are placed in a default package

  12. Packages (cont.) • Semantics of Packages • A class can access any other class in the same package (public or non-public) • A class can access any non-private fields or methods in the other classes of the package • Let’s look at an example.

  13. The import Statement • import provides a shorthand for class names • Details: • must appear after optional “package” statement • has two forms: • import utils.echo; // import just this class • import utils.*; // import all classes in this pkg • let’s you refer to classes directly by class name • import java.lang.*; is automatic

  14. A Brief Tour of java.lang • java.lang is the package containing the “core classes” of the language (kind of like the stdlib of C) Contains routines to manipulate: Boolean, Character, Numbers, Strings, has Math routines, Threading library, Exception Handling • Check the JDK 1.1 API doc for details

  15. Storage Classifiers for Classes • All classes in a package are visible to all others in that same package. You can’t change this! • Other than “public” your only other option for declaring a class is <nothing>; this means the class is visible only within the same package. • Only one class may be declared public in a given java source file.

  16. Visibility of Class Members • Storage classes for class members (ie, variables and methods) • private: only members of the same class • package: only classes within the same package (this is the default) • protected: only classes within the same package or any subclass of host class • public: visible everywhere

  17. Comments and Preprocessor • Three comment styles, but we’ll use only 2: • /* comment */ nesting not allowed • // comment just like C++ • There is no preprocessor • No #include, #define, #if, etc.

  18. Declaring Constants • Use “static final” to declare constants • ex: public final class Math { public static final double PI = 3.141592653589…; } • Always use all CAPS for constants • (Note: we can use Math.PI instead of java.lang.Math.PI. Why?)

  19. Primitive Data Types

  20. Primitive Data Types (cont.) • boolean type; assume int i and boolean b • i = (i != 0); // illegal! • i = (i != 0) ? 1 : 0; // that’s more like it • b = (i != 0); // that’s ok too • char type • just like C: ‘h’ is a char • the usual escape codes: ‘\n’, ‘\”’, etc.

  21. Primitive Data Types (cont.) • Integer Types • All integer types are signed • long literals are signaled by appending l or L • Floating Point Types • for float literals append f or F • for double literals append d or D

  22. The String type • Unlike C, “String” is a supplied type in Java • Note that it is not a primitive type, but has extra support nonetheless (for convenience) • Note the capitalization: String is a class (What package is the class in?) • String literals are enclosed in quotes: “hi” (This automatically creates a String object.)

  23. Reference Data Types • If it’s not primitive, it’s an object or array • Passing a primitive type is by value int i = 2; j = i; j = 3; // i = = 2, j = = 3 • Passing a reference type is by reference Button p, q; p = new Button(); q = p; // q refers to same object as p p.setLabel(“Ok”); String s = q.getLabel(); // s contains “Ok”

  24. Pop Quiz on Object References • Does this work? public void swap(Object a, Object b) { Object temp = a; a = b; b = temp; } • Does Not Work! Each parameter is passed in as the value of a reference, these values are rearranged with no outside effects!

  25. Misc. Reference Issues • If a and b are objects, what does a = = b mean? (Use strcmp() or equals() instead) • How do you copy objects (no copy constructors in java) • No pointers at all! (Fewer bugs!?) • null is a reserved keyword, not a value which is #defined to 0

  26. A First Look at Objects • Object Creation: • Window w; // does NOT create an object • Window w = new Window(); // this does • Special shortcut for Strings: String s = “This creates a string”; // The above is shorthand for // String s = new String(“This creates a string”); • Object members accessed with ‘.’ operator

  27. What about Arrays? • Arrays are objects, but with special syntax: • byte b[] = new byte[10]; // no constructor // Elements initialized to default for this datatype • char c[] = {‘h’,’i’}; // initialize to ‘h’ ‘i’ • In both cases, array is dynamically allocated • Initialization values need not be constant since array is allocated and initialized at runtime

  28. More on Arrays • Access array elements with arr[x] as usual • Bounds-checking done at runtime; is this good? • To get an array’s length, use arr.length (“length” is the only field allowed for array objects and is declared “final” so you cannot change it) • Quiz: what does this declaration do? byte[] row, column, matrix[];

  29. More on Strings • The String class is immutable • Use class StringBuffer if you want to change the contents of a string: StringBuffer sb = new StringBuffer(“Hi”); • Strings are NOT arrays (so don’t use s[x]) • String concatenation is done with + System.out.println(“hi there, “ + name);

  30. Common String Methods Assume s and t are Strings and i and j are ints; (strings indices start at 0) s.length() // # chars in string s.charAt(i) // return character at index i of s s.equals(t) // returns true iff s and t are equal s.compareTo(t) // return strcmp(s,t) (ie, -1, 0, 1) s.indexOf(t) // return index of first t within s s.lastIndexOf(t) // return index of last t within s s.substring(i) // return String from index i to end, incl s.substring(i,j) // return String from index i to j-1, incl

  31. Operators • Basically the same as C; table on the web • + is String concatenation; for primitive types operands are implicitly converted • Note >> is with sign extension; >>> is not • o instanceof C returns true if o is object of class C (or subclass of C); true means o is assignable to objects of type C • boolean & and | do not short-circuit

  32. Statements • if/else, while, do/while same as in C • switch statement is the same also (case labels must be constants or “final” variables) • for loops are different from C in two ways: • comma separated init and increment sections: for (i=0, j=0; i+j < 10; i++, j++) • loop declarations in init section: for (int i=0, j=0; …)

  33. Labeled break Statement • Used alone, “break” works the same as in C • But in Java we can have labels attached test: for (j=0; j < 10; j++) { for (i=0; i < 10; i++) { if (a[i][j] == null) break test; // break out of BOTH loops } }

  34. Labeled continue Statement • Used alone, “continue” works just like in C • In Java, we can have labels: resume: for (j=0; j < 10; j++) { for (i=0; i < 10; i++) { if (a[i][j] == null) continue resume; } }

  35. The synchronized Statement • Used to synchronize multiple threads which share data • Syntax: synchronized (expr) statement • expr must resolve to an object or array public static void SortIntArray(int[] a) { synchronized (a) { // sort the array } }

  36. Exceptions, Exceptions... • An exception in Java is much like C++: a signal that some important event (like an error) has occurred • To “throw” an exception is to signal that it has occurred • To “catch” an exception is to handle this occurrence

  37. Exceptions Propagate • If an exception is not caught within a local block, it propagates • First propagates through enclosing blocks • Then propagates up the method call stack • If propagates all the way to main() and main() does not catch it, the java interpreters prints an error msg and a stack trace • Well-designed code has centralized exception-handling!

  38. Exception Objects • An exception is an object • Its class is some subclass of java.lang.Throwable • Two common subclasses are java.lang.Error and java.lang.Exception • java.lang.Error indicates a serious problem (eg, out of memory) and should not be caught • Subclasses of java.lang.Exception are often caught and recovered from (eg, the exception java.lang.ArrayAccessOutOfBounds)

  39. Exceptions (cont.) • Since an exception is an object, it has fields • To get a description, call Throwable.getMessage() • Handling is done via try/catch/finally try { // some block of code } catch (SomeException e1) { // handle SomeException or a subclass of this type } finally { // always execute this code }

  40. Exceptions (cont.) • A try block is followed by zero or more catch blocks • exception is caught by the first catch() which matches in type • finally clause should do clean-up work • a finally block is always executed if any part of the try block is executed, even if exit is via a break, continue, or return statement

  41. Exceptions (cont.) • “Normal Exceptions” must be caught or propagated by your methods public void open_file() throws IOException { // code that might cause an uncaught java.io.IOException } • Some exceptions you don’t have to declare • eg, InternalError (that would be ridiculous) • How do we know when we have to declare it? • Just try it and let the compiler tell you

  42. Exceptions (cont.) • To generate your own exceptions, use Throw • Often the exception object is allocated as it is thrown: throw new MyException(“bad thing happened”); • Let’s look at a detailed example.

  43. Conclusion I've Always Wanted to Do This

More Related