java intro n.
Skip this Video
Loading SlideShow in 5 Seconds..
Java intro PowerPoint Presentation
Download Presentation
Java intro

Loading in 2 Seconds...

play fullscreen
1 / 47

Java intro - PowerPoint PPT Presentation

  • Updated on

Java intro. Part 2. Access control in Java classes. Public members: accessible to any code that can access the class Private members: accessible only within the class (no friend functions!) Protected members: accessible by code in: Same package Subclass as inherited member

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

Java intro

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
access control in java classes
Access control in Java classes
  • Public members: accessible to any code that can access the class
  • Private members: accessible only within the class (no friend functions!)
  • Protected members: accessible by code in:
    • Same package
    • Subclass as inherited member
    • Used more often than private because it allows extensibility
object creation
Object creation
  • A variable of a class type is simply a reference to an object
  • A declaration is just a declaration, NOT a call to the object’s constructor
  • To call the constructor, invoke operator new
    • Allocates dynamic memory for objects
    • All objects are dynamic objects
constructors in java
Constructors in Java
  • Method with same name as class
  • Performs initializations of object members
  • Has no return type
  • May be overloaded
    • Can have multiple constructors
    • But no such thing as default arguments
assignment in java
Assignment in Java
  • For primitive data types, works in familiar manner:
    • variable represents memory location sized to hold specific data type
    • value is stored in memory location via assignment operator
    • example:

int x; // allocates 4 bytes of memory

x = 5; // stores value 0000 0000 0000 0101

assignment in java1
Assignment in Java
  • For objects, variables represent locations that can hold references; Java’s oh-so-gentle way of saying “pointers”
  • An object reference is created when a constructor is called using the new operator
  • A variable of the object type stores the reference
objects assignment
Objects & assignment
  • Because variables hold references to objects, and not actual objects, two variables can refer to the same object, as in the example below:

Greeter worldGreeter = new Greeter (“world”);

Greeter anotherGreeter = worldGreeter;

example continued
Example continued

// worldGreeter and anotherGreeter both store references to

// the same object


// changes the String variable as referenced by both worldGreeter

// and anotherGreeter; thus:

String s = worldGreeter.sayHello();


// prints Hello Cate! instead of Hello world!

copying an object
Copying an object
  • If it is not your intention to have two variables referencing the same object (it rarely is), can create a copy of an object to store in a second variable using the clone() method
  • Method is available for all library classes; we will see later how to define it for our own classes
clone method
clone() method
  • Returns generic data type Object
  • Use explicit casting to create reference to desired type
  • Example:

Date aDate = new Date();

// stores reference to current date & time

Date anotherDate = (Date)aDate.clone();

// creates new Object, casts as Date & assigns

null references
Null references
  • Because all object variables contain object references, can assign value null to any object variable
  • This is useful because null is a value that can be tested; should assign null to any variable that doesn’t immediately have an object reference assigned to it
pointers java
Pointers & Java
  • You may have heard that Java doesn’t use pointers; this is only true in the sense that Java doesn’t use pointers you have to deal with directly
    • all object variables contain references - they are, in fact, pointers
    • you can’t create invalid pointers
    • Java uses automatic garbage collection - you don’t have to worry about reclaiming memory
parameter passing in java
Parameter passing in Java
  • We can describe two types of parameters in a Java method:
    • implicit parameter: calling object
    • explicit parameter: argument passed to method; explicitly defined in method’s parameter list
  • When necessary, can refer to the implicit parameter using the keyword this
parameter passing in java1
Parameter passing in Java
  • Primitive type arguments (int, double, char, etc.) are passed by value
  • Objects are passed by reference (since all object variables hold references), but methods can’t change parameter values - basically, it’s pass by const reference
  • Method can change the state of the calling object (implicit parameter) but not the received object (explicit parameter)
basic error handling
Basic Error Handling
  • Error messages can be sent to System.err (analogous to cerr) instead of System.out

example: System.err.println (“Invalid input”);

  • Still prints to screen, in most cases - can be useful in situations where errors go somewhere else, like a printing terminal
ending a program prematurely
Ending a program prematurely
  • If a program must be aborted because of an input error, can use System.exit(#) (where # represents an integer)
  • exit is analogous to C++ return statement
  • System.exit(0) means everything was OK, any other number represents error status
exception handling
Exception Handling
  • Exception: a run-time event that disrupts program execution
  • Examples:
    • file that can’t be opened
    • input data inappropriate to variable type
  • Java forces programmer to deal with many such situations ahead of time
exception handling1
Exception Handling
  • Many standard methods, particularly those that perform I/O, are declared to “throw exceptions”
  • Compiler won’t recognize client methods that don’t handle such exceptions
examples of exceptions
Examples of Exceptions
  • NullPointerException: attempting to call a method on a null reference
  • IllegalArgumentException: indicates that data value passed to a method is outside the bounds of its domain; can be used to enforce preconditions
  • IOException: may occur when attempting to read or write data; for example, attempt to read data of wrong type into a variable
unchecked exceptions
Unchecked exceptions
  • An unchecked exception is one that the compiler doesn’t force the programmer to handle; a NullPointerException is this type of exception
    • an unchecked exception can cause your program to halt with a runtime error
    • generally, unchecked exceptions are caused by conditions under the programmer’s control; in other words, errors you could have prevented
checked exceptions
Checked exceptions
  • Checked exceptions are caused by external conditions beyond the programmer’s control; for example, I/O exceptions
  • The compiler insists that the programmer acknowledge such exceptions by providing exception-handling code
exception handling2
Exception Handling
  • Any method that might throw an exception must be invoked in one of two ways:
    • within a method that announces its propensity to throw the same type of exception:

public static void main(String [] args) throws IOException

public void read (String filename) throws IOException, ClassNotFoundException

    • within a method containing a try/catch block - described later
exception handling3
Exception handling
  • The method just described lets the exception pass through to a method higher on the chain of method calls
  • The second method traps the (potential) exception object in your method and treats the error appropriately
  • Catching exceptions means surrounding the error-prone code with a try block followed by one or more catch clauses
general form of try catch block
General form of try/catch block



// code that might throw an exception


catch (ExceptionType e)


// code that handles specific exception - can have as many

// catch blocks as needed to catch all pertinent exceptions




// optional clause: executes regardless of whether or not

// an exception was thrown in try block


notes on exception handling syntax
Notes on exception handling syntax
  • The exception mechanism deals with an object, which is an instance of class Throwable (defined in java.lang.*) or one of its subclasses
  • So catch block looks like a method declaration with a single parameter, the Throwable object
throwable objects
Throwable objects
  • Often contains useful information about exceptions - examples:
    • name of file that couldn’t be opened
    • value of illegal array index
  • Several methods are defined in Throwable class, including .getMessage(), which returns generic message associated with type of exception caught
strings in java
Strings in Java
  • String is a built-in class (not a simple type)
  • Sequence of Unicode characters
  • String methods include:
    • length: returns number of character in String

String name = “Cate Sheller”;

int letters = name.length();

    • charAt():returns character at specific index value

char first = name.charAt(0);

strings in java1
Strings in Java
  • A String variable can hold reference to any String object – so can assign a different reference to same variable:

name = “George W. Bush”;

    • But String object itself is read-only; can’t change first letter of George’s name to Q, for example – it’s NOT an array of char
    • String buffer class exists which does allow for this kind of manipulation
strings assignment
Strings & Assignment
  • Can assign reference to String to any String variable (as previously noted)
  • To copy String object use:

String name = “Donald Duck”;

String name2 = new String(name);

strings logical comparison
Strings & Logical Comparison
  • Operator == works as it does with pointers in C++: tests to see if 2 variables reference same object
  • Member method .equals can be used to test contents of 2 strings:

if (name2.equals(name))

strings logical comparison1
Strings & Logical Comparison
  • Member method .compareTo is more general comparison operator:
    • Returns positive value if calling object is greater than argument
    • Returns 0 if caller equals argument
    • Returns negative value if caller is less than argument
    • Example: if (name2.compareTo(name) > 0)
  • The substring method of the String class returns the string described by two arguments:
    • first argument is position of the first character in the substring
    • second argument is position of the first character NOT to include in the substring
    • difference is the length of the substring
  • The java.util package includes the StringTokenizer class, which can be used to extract substrings separated by delimiters
  • A StringTokenizer object is created using two arguments: the string to be broken down, and the delimiting character (space if not specified):

String colors = “Red&White&Blue”;

StringTokenizer breakup = new StringTokenizer(colors, “&”);

  • Once a StringTokenizer is created, can be used to access individual substrings in a sequential fashion
  • Example:

while (breakup.hasMoreTokens())


String theColor = breakup.nextToken();


string concatenation displaying objects
String Concatenation & Displaying Objects
  • The + operator concatenates strings with objects of other simple types
  • For implicit type conversion, can concatenate with an empty string
  • Since print() and println() work on Strings, the concatenation operation makes output of other types possible
string concatenation displaying objects1
String Concatenation & Displaying Objects
  • For newly-defined data type, can create a toString method which allows output using print or println
  • For example, the method on the following slide could be used for a Fraction class, with numerator and denominator represented by integer variables n and d
tostring example
toString example

public String toString()


return (“” + n + ‘/’ + d);


converting from string to numeric type
Converting from String to numeric type
  • To convert from a String to a primitive numeric type, use the wrapper classes Integer and Double and their parsing methods, parseInt() and parseDouble()
  • For example:

int n;

String number = “52402”;

n = Integer.parseInt(number);

  • The parsing methods will throw the unchecked NumberFormatException if the String argument doesn’t contain a number
i o in java
I/O in Java
  • Java I/O stream library provides, System.out and System.err
  • To do file I/O, need to declare
    • FileInputStream object for input
    • FileOutputStream object for output
  • No “open” command - use new instead:

FileInputStream infile = new FileInputStream(“source.txt”);

  • No need for “close” - another example of automatic garbage collection
character i o
Character I/O
  • Like C++, Java uses streamed I/O
  • Standard input is represented by (analogous to cin)
  • ) returns byte as an int: closest analog is cin.get(c) - ASCII input, in other words
system out
  • Represents stdout
  • String data can be printed using System.out.print and System.out.println
    • can print most primitive types, as they can be converted to String
    • System.out.write prints byte (ASCII character) data
code example
Code example


class Uppercase


public static void main (String [] args) throws IOException


int x;

System.out.println(“Enter text to be converted”);

System.out.println (“to uppercase. Hit Ctrl-Z to end”);

while ((x = != -1)


x = Character.toUpperCase((char)x);





notes on example
Notes on example
  • The two lines inside the loop:

x = Character.toUppercase((char)x);


  • Form the nucleus of the function:
    • Character is a class name, and toUppercase is a method defined in that class
    • the toUppercase method works on char (Unicode) data, so x, which is an int, is cast as char for function to work on it
    • the write method works on byte (ASCII) data
console char input
Console char input
  • As previously noted, reads byte data, not char
  • To read characters from the console, use to create an InputStreamReader object:

InputStreamReader reader = new InputStreamReader(;

  • To read Strings, create a BufferedReader object from the InputStreamReader, then invoke the readLine() method:

BufferedReader kbd = new BufferedReader(reader);

String myString = kbd.readLine();

gui input
GUI input
  • A simpler way to read input is via an input dialog box; you can create one by invoking the showInputDialog method of JOptionPane class, which is found in the javax.swing package:

String input = JOptionPane.showInputDialog(“Enter a number:”);

if (input != null)

num = Integer.parseInt(input);

// reads a number by extracting it from returned String

gui output
GUI output
  • Can also create dialog box for output using showMessageDialog method:

JOptionPane.showMessageDialog (null, “Hey!”);

// first parameter indicates no parent window

// second parameter is message displayed