Showing posts with label Instantiation. Show all posts
Showing posts with label Instantiation. Show all posts

Monday, February 25, 2013

Getting input

DOWNLOAD THE CODE: InputFromScannerPkg

The Scanner class
A class is a template for an object. A class contains methods for performing particular tasks. From one class we can create many object instances.

The Scanner class belongs to the Java library of classes. It contains methods for reading many different types of data, from different types of input.

System.out
You have already seen System.out in action when we print to the console. This is the default stream for output.

This statement causes the words “Print this’ to be printed to the console in Eclipse.

System.out.println(“Print this”);

What you cannot see, however, are the special line ending characters which this method places at the end of the line. When subsequent lines are printed using println(), they each begin on a new line.

Here’s a different way to print to the console:

System.out.print(“Print this”);

Notice that we are now using the print() method. This method does not include special line ending characters. Each subsequent line of characters that is printed using print() will begin immediately where the last line of characters left off.




and the output...


System.in
The following code example uses Scanner’s nextInt() method to read an int input from System.in (default input from console). The input is assigned to the int variable called aNumber.

Scanner myScanner = new Scanner(System.in);
int aNumber = myScanner.nextInt();


Scanner can be told to read different types of data - or tokens. By default, Scanner uses whitespace characters as delimiters of tokens (the characters that separate tokens).

In the case of the nextInt() function, Scanner is using whitespace to delimit tokens, and return the token as an int. (seen in the figure below).

Other Scanner functions of note include:

next() - Return the next token, of any type.
next(String pattern) - the next token is delimited by the pattern supplied as a parameter.
nextLine() - reads the current line and returns it.



and the output...

In the figures above, the user is prompted to enter information. Methods of the scanner class are used to read the input typed into the console, and assign it to variables. The variable values are then printed to the console.

You can read the entire Scanner class specification here:
http://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html

Java I/O and Import statements
When we wish to use Scanner:
At the top of the code file we import a reference to the Scanner class by using the line:

import java.util.Scanner;

This line says that we intend to use the class called Scanner from the package called java.util.

In Java, all input and output (I/O) is performed by importing methods from the java.io or java.util packages.

Any source of input or destination of output is called a stream: keyboard, screen, network connection, a file, etc., are all streams.

There are three predefined Streams already open and ready to use in every program:
  •     System.in
  •     System.out
  •     System.err



Object Instantiation
To use the Scanner class, we must first declare an instance of Scanner and give it a name. Similar to declaring a variable in that we declare a type and an identifier. In this case, the type is Scanner.

As well as being declared, an object also needs to be instantiated. The use of the new keyword, instantiates the object called myScanner from the Scanner class.

Scanner myScanner = new Scanner(System.in);

In the next statement, we declare an int variable and assign it the value of the next int that is returned myScanner’s nextInt() function.


int aNumber = myScanner.nextInt();

You will notice that when we instantiated a Scanner object, we have also included System.in, inside of the parenthesis (round brackets). This is an example of passing data to a method. Often, a method needs data passed to it so that it can perform its task.

System.in is the input stream from the keyboard, via the Java console, so, we are telling the Scanner object to use this as its source.

Monday, June 11, 2012

File class

The Scanner & PrintWriter classes can read from & write to text files, respectively.

Each of these classes contains a constructor that accepts a File object.

The File class belongs to the java.io library (io stands for Input Output).

The example below declares a File object that references the io library directly. Notice that a String containing a filepath/filename is passed to the file's constructor. This File object called file, is then passed to the constructor of the Scanner object. In essence we are saying, read from this file at this location.


The next example declares a File object using a shorter declaration. The library reference has been done via an imports statement at the top of the code (not shown). Once again a String filepath/filename has been passed to the constructor. The file object is then passed to the constructor of the PrintWriter object. In short, we are saying, write (print) to this file at this location.


"File (Java)" ( http://bit.ly/JWg0sp )

"java.io (Java Platform SE 6)" ( http://bit.ly/JWhUcw )

Sunday, April 29, 2012

Instantiation and object arrays

When we create an object from a class we are said to be 'instantiating an object from a class'.

Format:
ObjectType Identifier = new ObjectType(Parameters if any);

'new' is a keyword that calls the constructor of the class.

Consider the following class called NetworkUser:


To create an object from this class, we must declare a new NetworkUser. Each object we create from the class must have a unique identifier/name. The following code instantiates 3 NetworkUser objects, and calls a couple of their methods:


The following output is produced:



Object arrays
Alternatively, the NetworkUsers could be stored in an array and we could loop through each one to display their credentials:


The first statement instantiates an array of type NetworkUser. Only objects of type NetworkUser can be stored in the array. The array has a length of 3 which means that the first index (position) is 0 and the final is 2.

The next 3 statements instantiate a NetworkUser object directly into each index of the array. CurrentUsers[0] is a reference to the first index of the array called currentUsers. This is followed by the assignment operator (=) which is then followed by the object that will be stored in this index.

The for loop is primed to loop for as many times are there are indexes in the currentUsers array - the loop counter (x) starts at 0 (the same as the first index of the array) and is incremented on each pass of the loop by 1 until it reaches 2 (the final index of the array).

The print statements inside of the loop get the current NetworkUser in the array by using the statement currentUsers[x]. 

On the first pass of the loop, this will return the NetworkUser object at currentUsers[0].
On the second pass of the loop, this will return the NetworkUser object at currentUsers[1].
On the third pass of the loop, this will return the NetworkUser object at currentUsers[2].

All that's left to do is call the methods of NetworkUser. In this case, getUserName() and getPassword() are called.

Here's what the output looks like:


See more at pastebin.

Err, here's a cat (at animals[2]):











Tuesday, April 24, 2012

Constructors and instantiation

"Providing Constructors for Your Classes (The Java™ Tutorials > Learning the Java Language > Classes and Objects)" ( http://bit.ly/I67fRB )

Every class has at least one Constructor. This is a special method that prepares the object for use. It has the same name as the class.


A class can have multiple constructors - this is known as method overloading.

The constructor is always the first method called on an object. Think of it as an 'on-switch'. When we instantiate an object of a class, we call it's constructor using the new keyword:

Syntax:
Type identifier = new Type(parameters, if any);

Example:
Telephone myTelephone = new Telephone();


In UML notation, the constructor is always referred to as new(). This is because UML is language independent and not Java specific. Different programming languages have different rules for naming a constructor.

Monday, March 19, 2012

The Static keyword

The static keyword is a Java modifier which associates a class member or method with a class rather than an instance of a class.

For instance, the main method of a class is always static as there must be exactly one instance of the class containing main in order for the compiler to find it.

A class containing static members or methods does not require instantiation in order to use the static methods of the class.