Java

Java is a language that is purely object oriented, all code must be included in any class

It was defined by the company Sun Microsystems, which was acquired in 2009 by Oracle Corporation, formerly part of Silicon Valley, a maker of semiconductors and software; but the language remains in the public domain. In particular, Oracle offers in their website, for free, a JDK (Java Development Kit) which allows you to compile, debug, and run Java programs

If we have a program in a file programa.java we can compile it from the command line with:

java programa.java

This generates a collection of files extension .class, one for each class that appears in programa.java and with the name of the corresponding class

Only in one of the classes (in the active environment) must have a method called main (the main method); suppose that is in the class program, we will be able to run the program from the command line:

java programa.class

In the previous case, the extension would be optional

For this to work correctly, we have installed the JDK and make sure that the path stored in the variable CLASSPATH is in the path by default of the system

Normally the programs are developed in an environment of comprehensive programming that contains in addition to the functionality of the JDK, at least a program editor. Sun offers on their website an integrated environment for Java: Netbeans

The result of the compilation a java program (the files .class) is expressed in an intermediate language called bytecode

The bytecode is interpreted by the Java virtual machine (JVM), which is a program that is invoked by the command java in the command line

The different modern browsers include a JVM, so that it can run Java programs from the browser through Applets embedded within html pages

Although the Google Chrome browser has restricted its use for safety and the JVM is not included by default, in the event that the user wishes to use them, you should install a pluging to any third party or use a dedicated server for Java applications as for example Tomcat

Differences between Java and C++

The syntax of Java is inspired by C and is superficially very similar to C++ for that reason. But it also has important differences

Access modes in Java:

• Each attribute or method is associated with a permission
• In addition public and private (both without the two dots) is the mode by default package

In contrast, in C++, the default access mode is private

To use something by default in Java you use the package (packets), which is a simulation of the notion of namespace C++

To create or extend a package using the package:

• Must be in the 1st line of the source file (everything in that file belongs to the package)
• Will be followed by the name of the package that you want to use

If you want to use from a package, classes, attributes, methods from another package, use the command import (it is very similar to the using namespaces C++)

If the programmer does not define any package explicitly, the system creates one by default without name, that will contain all the names of the files (that do not have package explicit) that belong to that operating system directory

In conclusion, in case of the absence of packages explicit, the default access mode for a class, an attribute or a method, it is accessible from all files in a same directory

The classes in Java also have a mode of access: public, private, or default

If we find public when you define a class, has two consequences:

• It is accessible from any point, regardless of the packages
• Your name must be the file .java-what it contains; there can be only one public class per file

Comments

Java has three kinds of comments:

• The // he says until the end of the line
• The /* he says to the first */ (no nesting)
• The /** he says to the first **/

Packages

As you incorporate third-party class increases the possibility to find classes with the same name

The possibilities are even greater in Java, where classes of millions of programmers have to travel through the network

The solution that provides Java are the packages (packages)

To specify the desired class simply indicate the name of the package to which it belongs

Sun gave in its day some recommendations for the names of the packages were unique:

• If you are going to use within the company will be able to use any convention internal

• If you are going to use outside the company should be used as a prefix in the Internet domain of the company invested (this ensures it is unique), for example com.sun.graphics3D

• The standard classes are reserved for prefixes java and javax

The entire class must belong to some package

The Java classes are distributed in several basic packages:

The name of a class includes a prefix of the package to which it belongs

java.util.Vector v = new java.util.Vector();

In the example, the Vector class is inside the java package.util

import java.util.Vector;

Vector v = new Vector();

In the example we have used the reserved word import that allows you to indicate the package to which belongs one or more classes, in such a way that you didn't have to repeat it with each use of the same

import does not load any type of file (not equivalent to #include in C / C++)

The package java.lang it is imported automatically

Collision of names

In the case of a repeat of a class name in two imported packages, we would have to use the full name of the class to undo the ambiguity

import EDU.ur.*;	//Contains a Vector class
import java.util.*;	// Contains a different Vector class
EDU.ur.Vector v1 = new EDU.ur.Vector();
java.util.Vector v2 = new java.util.Vector();

In the example you have specified the package that you want to take the Vector class, with the asterisk you're saying that you take all the package

import EDU.ur.*;	//Contains a Vector class
import java.util.*;	//Contains a different Vector class
import java.util.Vector; //Contains the specific Vector class

EDU.ur.Vector v1 = new EDU.ur.Vector();
java.util.Vector v2 = new java.util.Vector();
Vector v3 = new Vector();

In the example you have used an import of the concrete class Vector and another of all the package

Keep in mind that the import of the class will have priority over the import of an entire package

So it could be removed if you do not want to use the rest of the classes of that package, to be redundant

Creation of packages

To indicate that a class belongs to a package, use the clause package

package examples;

class Example1 {
     // class code
}

In the example, we have created the package examples contains only the class Example1

If we are to use in another class, the name of the package may be formed by multiple words separated by dot

In this case the class name will be examples.Example1

If you would like to run it to use it in other classes from the command line:

java examples.Example1

Classpath

Java does not have the concept of executable file (file with extension .EXE or .COM)

Each class generates a file class independent

To run a program you need to specify the name of a class that contains at least a main function

The rest of the classes will be loaded dynamically on demand

You can have multiple classes with main but there can only be one main that is the main

In the case of local applications you will locate the code of the classes:

• The JVM adds the name of the class the extension class to form the name of the file

• To locate this file using the environment variable CLASSPATH

• CLASSPATH indicates a series of locations in which to find the classes that can be:

  • A directory
  • A file ZIP or JAR (Java Archive Resource)

c:\> set CLASSPATH=c:\examples; c:\java\lib\classes.zip

In the example we have used Windows command line to define the CLASSPATH

The class Test would look for (in this order):

1. c:\examples\Test.class
2. inside the file
3. c:\java\lib\classes.zip and nowhere else

When using classes made by third parties it is necessary to include its directory (or ZIP, JAR) in the CLASSPATH for the JVM to be able to find them

Packages and Classpath

In the JDK there is a relationship between the package of a class and the directory in which it is located

All the classes in a package must be in a directory with the same name

If a package name has multiple words, each word corresponds with the name of a subdirectory

For example, the classes in the package ur.my.examples would be in the directory ur/my/examples

This directory must be accessible from any of the locations CLASSPATH

The mechanism of the JVM of the JDK to locate the implementation of a class at runtime is:

1. adds .class the full name of the class
2. transforms the points into directory separators \
3. adds the resulting string to each of the locations CLASSPATH
4. if it is not found in any of them produces a runtime error

Let us follow the process with an example in which we want to load in the JDK class UR.examples.example1:

1. We define the CLASSPATH as:

   c:\> set CLASSPATH=c:\programas; c:\temp

2. The JVM searches for the class in the file UR\examples\example1.class

3. The file will be searched in the locations of the CLASSPATH c:\programs\UR\examples\example1.class and c:\temp\UR\examples\example1.class

4. If the class is not found in either of these two sites, will result in a runtime error

Primitive types

The primitive types are divided into:

• Characters
  • char
  • String
• boolean
• Numeric
  • Integers
    • byte
    • short
    • int
    • long
  • Real
    • float
    • double
• Arrays

The primitive types are characterized by having defined a same size on all platforms (unlike the C / C++)

The literal real are of type double unless you include the suffix F

3.14 it is not of the same type 3.14 Fthe first will be double and the second float

When you want to cause a conversion uses the operator cast

It has the following syntax:

(type to convert) expression

Using the cast, you can perform those conversions that the compiler does not by default

int i = (int) 5.4;

double x = 5 / (double) 2;

In the example, has carried out a casting of the double 5.4 a int to store it in the variable i

The result of that operation will be the compiler to take only the integer part of the double, that is to say, will keep on i the value 5

In the second operation example, it is divided 5 by 2, this operation will return its result as a double, but if the result would not have decimal places, would be saved as a whole

To make a casting in the denominator, we force the compiler to store the result of the division as a double even if you have no decimal

Keep in mind, that a casting does not correct the error of division by 0, should be controlled by the use of exceptions

Wrappers

A wapper is a wrap that is applied to a primitive type concrete

There are a class wrapper is associated to each primitive type

java.util.Vector

class Example{
    class Integer{
        private int value;

        public Integer (int value){
            this.value = i;
        }

	public intValue(){
            return this.value;
        }
    }

    class Double{
        private double value;

        public Double (double value){
            this.value = value;
        }

	public doubleValue(){
            return this.value;
        }
    }

    public static void main(String args[] ){
        Vector v = new Vector();

        v.addElement(new Integer(5));
        v.addElement(new Double(3.14));
    }
}

In the example, we have redefined the wrappers for int (it is Integer) and for double (it is Double) to be able to add the primitive data int and double in the class Vector

The class Wrapper have a second functionality

Are used to locate all those services of the primitive types that they represent

Some methods of wrappers are important:

Characters

A character it is a symbol that follows the ASCII standard which we use to generate the texts of our programs

A string of characters it is an array of characters that allow you to save texts or phrases

char

It is a letter that follows the ASCII standard and is the smallest unit of string

Its size is 8 bit

Its value could be considered a small integer since its range is -128 to 127

Values char are associated with the class Character

Is initialized with single quotation marks

char ch = 'A';

In the example initialized the variable ch as a string and as you can see has been saved to the ASCII symbol that corresponds to the letter to uppercase

String

The character strings are not a primitive type

However Java provides special classes for your treatment

Strings are objects that are manipulated using the classes String and StringBuffer

Is used String when the string will not be modified

Use StringBuffer when you want to manipulate the string

It is recommended to use typically the String (to be constant) to be more efficient

Initialization of a String

The strings are between double quotation marks, and character with single quotation marks

When the compiler encounters a string literal, it will create a String object with the text of the same

String s1 = "Hello";

String s2= new String("Hello");

In the example, we have initialized two variables that might be equivalent

s1 has been initialized using only the double quotation marks

s2 has initializing the constructor for objects of the String class, passing it as an argument the value with double quotation marks

Both initializations are valid and the contents of the variables s1 and s2 will be in both Hello

The only difference is that to be different objects, their reference in memory will also be different

Basic methods

length

The method length returns the number of characters in a string

"Hello".length();

s1.length();

In the example, we have asked two strings of characters number of characters

In the first you have used double quotation marks, and in the second the String object s1 of the above example

The two previous expressions would be equivalent, return an integer with the number of characters in the string

charAt

The method charAt returns the character at the specified position

If the argument of charAt is not a number between 0 and length – 1 will cause an exception

int charcount (String str, char search) {
     int counter = 0;

     for (int i = 0; i ‹str.length (); i ++) {
         if (str.charAt (i) == search) {
             counter ++;
         }
     }

     return counter;
}

In the example you have created a function that given a String str and char are looking for, you search for the character in that string and if found, the return value will be greater than 0

To achieve this they have used the method charAt has passed the value of i that represents the position of a character read up to the time

As returns the character read in that time we have been able to compare it with the character search that we passed as an argument

Search methods

Methods to perform searches in strings return the position of the searched item or -1 if not found:

• indexOf(int ch)
• indexOf(int ch, int start)
• indexOf(String str)
• indexOf(String, int start)
• lastIndexOf(int ch)
• lastIndexOf(int ch, int start)
• lastIndexOf(String str)
• lastIndexOf(String str, int start)

String s = "Hello Caracola";

s.indexOf('o');    //return 4

s.indexOf('o', 2);    //return 11

s.indexOf("la");    //return 12

s.indexOf("la", 3);    //return -1

s.lastIndexOf('o');    //return 10

s.lastIndexOf("la");    //return 12

In the example we have used each of the methods and discussed its return value to be able to understand them better

Comparison of strings

To compare strings does not serve the = = operator, because in reality we are comparing objects

The String class has several methods for comparing strings

Two strings will be equal if they have the same length and the same characters Unicode (to and unto are different)

The most common methods are:

• equals
• equalsIgnoreCase

  distinguishes between uppercase and lowercase

• compareTo

  in addition to allowing us to find out if two strings are the same, it also tells us which one is greater than the two:

  • Equal to 0

    They were the same

  • Greater than 0

    The second value was greater

  • Less than 0

    The second value was less

String s1 = "Hello";
String s2 = "hello";
String s3 ="Goodbye";

System.out.println(s1 == s2);    //returns False, although this result is not very reliable

System.out.println(s1.equals(s2));    //returns False

System.out.println(s1.equalsIgnoreCase(s2));    //returns True

System.out.println(s3.compareTo("Hello"));    //returns False and tells us numerically that the second is greater

System.out.println("Hello".compareTo(s3));    //returns False and tells us numerically that the first is greater

System.out.println(s3.compareTo("Goodbye"));    //returns True and tells us they were the same

In the example we have used each of the methods and discussed its return value to be able to understand them better

Methods for comparing prefixes and suffixes

• boolean starsWith(String)
• boolean starsWith(String, int start)
• boolean endsWith(String)

String s1 = "Hello";
String s2 = "Caracola";

System.out.println(s1.startWith("He"));    //return True

System.out.prinln(s1.endsWith("lo"));    //return True

System.out.println(s2.startWith("He"));   //return False

System.out.prinln(s2.endsWith("la"));    //return True

In the example we have used each of the methods and discussed its return value to be able to understand them better

Extraction of strings

There are a number of methods that return a new string that is the result of manipulating the original string

The original string is not modified (a new instance of the string is created, that is, another memory position is used)

• String concat(String)
• String replace(char, char)
• String replaceAll(String, String)
• String substring(int start)
• String substring(int start, int end)
• String toLowerCase()
• String toUpperCase()
• String trim()

String s1 = "Hello";
String s2 = "Caracola";
String s3 = s1.concat(s2);    //variables s1 and s2 are concatenated, the result is saved in s3

System.out.println(s3);    //return HolaCaracola
System.out.println(s1);    //returns Hello, variable s1 has not been modified

s3 = s2.substring(4, 8);  //string contained in positions 4 to 8 of s2 is obtained and stored in s3

System.out.println(s3);   //returns cola, as the previous content of s3 has been overwritten
System.out.println(s2);   //returns Caracola, la variable s2 no ha sido modificada
System.out.println("Hello ".trim().toUpperCase());
/* returns HELLO, the trim method is applied first, which removes the spaces from the string
    and then the toUpperCase method is applied, which changes all characters to uppercase characters */

In the example we have used some of the methods and discussed its return value to be able to understand them better

String conversions

The primitive types can be converted automatically to strings

To convert strings to primitive types, use one of the following functions:

• boolean new Boolean(String).booleanValue()
• int Integer.parseInt(String)
• long Long.parseLong(String)
• float Float.parseFloat(String)
• double Double.parseDouble(String)

Other methods

• char[] toCharArray()
• void getChars(int srcBegin, int srcEnd, char[] dest, int destBegin)
• int hashCode()
• String valueOf(boolean)
• String valueOf(int)
• String valueOf(long)
• String valueOf(float)
• String valueOf(double)
• String[] split(String)

String cad = "Hello caracola".split(" "); //the string is chopped using space as a token

System.out.println(cad[0]); //returns Hello
System.out.println(cad[1]); //returns caracola

As you can see in the example, we'll use split to slice strings using a token, in this case we've used space

This method is quite useful for working with text files in CSV format, since the symbol is usually used; (or other token symbol) to separate the different columns or cells

StringBuffer

Although the String class is the most common it is not appropriate for strings that need to be changed frequently

String ad1 = '¡';
String ad2 = '!'
String str = 'Example'
String admiration1 = ad1 + str + ad2;
String admiration2 = String.valueOf(ad1).concat(str).concat(String.valueOf(ad2));

//If we use only String we can see that admiration1 and admiration2 are equivalent in their value
System.out.println(admiration1); //returns ¡Example!
System.out.println(admiration2); //returns ¡Example!

The example creates four String objects of which only one will be used, admiration1 or admiration2

The class StringBuffer lets you modify the original string without the need to create intermediate objects as done in the example

Initialization of a StringBuffer

Supports the following constructors:

• StringBuffer()
• StringBuffer(int i)
• StringBuffer(String str)

Methods of modification

Supports the following modification methods:

• append(Objetc obj)
• append(String str)
• append(char str[] )
• append(boolean b)
• append(int i)
• append(long l)
• append(float f)
• append(double d)
• append(char ch)
• insert(int offset, Object obj)
• insert(int offset, String str)
• insert(int offset, char str[] )
• insert(int offset, boolean b)
• insert(int offset, int i)
• insert(int offset, long l)
• insert(int offset, float f)
• insert(int offset, double d)
• insert(int offset, char ch)
• setCharAt(int index, char c)
• setLength(int longitud)

StringBuffer s1 = new StringBuffer("hello");

s1.append("caracola");

System.out.println(s1);  //returns hellocaracola

s1.insert(5, ' ');

System.out.println(s1); //returns hello caracola

s1.setCharAt(0, 'H');

System.out.println(s1); //returns Hello caracola

In the example we have used some of the methods and discussed its return value to be able to understand them better

Basic methods

length

It is similar to the String

charAt

It is similar to the String

toString

Performs the conversion of the BufferString to String

Operador +

Java allows concatenation of strings using the +

String greeting = "Hello";

System.out.println(greeting+ " to all");    //returns Hello to all

In the example, internally the compiler uses a StringBuffer instead of a String

String greeting= "Hello";

System.out.println(new StringBuffer(greeting).append(" to all"));   //returns Hello to all

So this example is completely compatible with the previous

int value = 5;

System.out.println("Value = " + value);    //returns Value = 5

In the example we concatenated the string with another type (integer), the latter is automatically converted to string (the compiler implicitly invokes the toString() method of the StringBuffer class)

boolean

Its size is 1 bit

Its value could be considered a small integer since its range is 0 to 1

Being the value 0 equal to FALSE and 1 equal to TRUE

The boolean values are associated to the class Boolean

boolean b = 0;	//declaration of a variable of a primitive type, it can be declared either in number or in letter

Boolean b = new Boolean(TRUE);	//declaration of an object of class Boolean

Basic methods

booleanValue

Returns the value of the boolean

toString

Converts the boolean type to a string

Numeric

Are all types that allow you to work with numbers and can be distinguished according to whether they are integers or decimals, or as to its accuracy

Integers

They are all types that allow you to work with integers, there are several types depending on their accuracy and the range of numbers that can be handled

byte

Its size is 8 bit

Its value could be considered an unsigned small integer since its range is 0 to 255

The byte values are associated with the class Byte

short

Its size is 16 bits

Its value could be considered an unsigned integer since its range is 0 to 65535

The values short are associated to the class Short

int

Its size is 16 bits

Its value could be considered a signed integer since its range is -32768 to 32767

The int values are associated to the class Integer

long

Its size is 32 bits

Its value could be considered a large integer as its range is -2147483648 to 2147483647

The long values are associated with the class Long

Real

They are all types that allow you to work with decimal numbers, there are several types depending on their accuracy and the range of numbers they can handle

float

Its size is 32 bits

Its value would be a decimal smaller as their range is 3.4 E-38 to 3.4 E+38

The float values are associated with the class Float

double

Its size is 64 bits

Its value could be considered as a decimal great since its range is 1.7 E-308 to 1.7 E+308

The double values are associated to the class Double

Arrays

An array is a grouping of elements of the same type

Arrays in Java are objects

Therefore, a reference will be needed to manipulate them

int v[]; //Size not indicated

v = new int[10]; //when using new we must specify the size or it will throw an exception
v[0]=5;    //a value is assigned to position 0 of the array

System.out.println(v[0]); //returns 5

In the example we can see that like any other object, it is initialized with new

Classic array notation (using an index) is used to access array elements (using an index)

If the maximum value of the index is not specified, the compiler will take it as a dynamic array

We can consider that the rating is equivalent to send a message to the array to view an item or edit it

The range of an array is between 0 and N-1 (N being the size of the array)

If you have access to a position out of range an exception will be thrown

int [] a = {1, 2, 3, 4};

for(int i=0; i < a.length; i++){
    System.out.println(a[i]);
}

In the example we have initialized the array to then be able to view all its contents by screen

As can be seen, Java allows you to initialize the array in its declaration

The operator length allows you to find out the size of an array

Cronometro[] v={new Chronometer(), new Chronometer()};
Cronometro[] v=new Chronometer[2];

v[0]=new Chronometer();
v[1]=new Chronometer();

In the example we have initialized an array of references in your statement

As can be seen, both statements are equivalent

Arrays two dimensional

A two dimensional array can have multiple rows, and in each row there does not have to be the same number of elements or columns

double[][]   matriz={{1,2,3,4},{5,6},{7,8,9,10,11,12},{13}};

for (int i=0; i < matrix.length; i++){
    for (int j=0; j < matrix[i].length; j++){
    	System.out.print(matrix[i][j]+"\t");
    }

    System.out.println("");
}

In the example we have declared and initialized two dimensional array of doubles array then walk it and display it on the screen

The first row has four elements {1,2,3,4}

The second row has two elements {5,6}

The third row has six elements {7,8,9,10,11,12}

The fourth row has an element {13}

array.length gives us the number of rows which in this case is

matrix [i] .length gives us the number of elements in each row

We show the elements of a row separated by a tab using the print function

Once a row is passed to the next by using println

Example of identity matrix

To show the power of a two dimensional matrix, this example builds a dimension identity matrix 4

A identity matrix is the one whose elements are zero except those of the main diagonal, i= =j, which are some

double[][] identidad = new double[4][4];

for (int i=0; i < identity.length; i++){
    for (int j=0; j < identity[i].length; j++){
        if (i == j){
            identity[i][j] = 1.0;
        }else{
            identity[i][j] = 0.0;
        }
    }
}
for (int i=0; i < identity.length; i++){
    for (int j=0; j < identity[i].length; j++){
        System.out.print(identity[i][j]+"\t");
    }
    System.out.println("");
}

Using a double for loop we loop through the elements of the array specifying its row i and its column j by population the matrix with 1 or 0 depending on whether i and j match

Using a double for loop we go through the elements of the array by specifying its row i and its column j

We show the elements of a row separated by a tab using the print function

Once a row is passed to the next by using println

Classes in Java

In Java, every object (classes) is manipulated through a reference

This reference saves the identifier of the object

And is responsible for sending messages to the object associated

The type of the reference indicates what type of messages you can send

Access modifiers

When you create classes, the need arises to indicate the use of their attributes and methods

Some attributes will be internal:

• Must not be modified

• It is not necessary to know of its existence

The same goes for methods:

• Should not be invoked from outside the class

• Do not need to know about its usefulness

The access modifiers control the visibility of class members

Indicate which of them are of interest to the outside

Java offers four access modifiers:

• private

  is visibility more restrictive

  Only allows the invocation from the class itself

• public

  is visibility less restrictive

  Enables the invocation from any class

• package

  is the visibility by default

  Only allows the invocation from the classes that they belong to the same package

• protected

  is the visibility associated with the inheritance

  Only allows the invocation from derived classes

Builders

When a class does not declare any constructor, it automatically creates a default constructor

class Example {
     class A {
         int i;
     }

     public static void main(String args[]) {
         A a = new A(); //Invokes the default constructor
     }
}

In the example the constructor has been called from the main method and is responsible for leaving the object in an initial state in which we can work with him

Since we haven't created the constructor, the default constructor was automatically used

class Example {
     class Person {
         private String name;

         public Person() {
             this.name = ""; //start with the empty string
         }

         //get method that returns the value of the variable name
         public String getName() {
             return this.name;
         }

         //set method that modifies the value of the variable name
         public void setName(String name) {
             this.name = name;
         }
     }

     public static void main(String args[]) {
         Person p = new Person(); //Invoke the constructor
         p.getName(); //returns an empty string, since that was its initial value
     }
}

In the example, we've defined a class called Person that has only the attribute name that is private

The constructor was used to initialize it and to access it (as it is private it is not directly accessible) the get and set methods have been added

In case you have not used the constructor to initialize it with new, by using p we would have obtained a value null, since the object would not yet be defined in memory

To refer to an attribute of the class itself, we use the reserved word this

In this case, it has been used to refer to the attribute name

Constructor with parameters

When we need to add external information, we can use parameter builders

A constructor can declare the parameters that are needed to create the object

class Example {
     class Person {
         private String name;

         public Person() {
             this.name = ""; //start with the empty string
         }

         public Person(String name) {
             this.name = name; //start with the empty string
         }

         //get method that returns the value of the variable name
         public String getName() {
             return this.name;
         }

         //set method that modifies the value of the variable name
         public void setName(String name) {
             this.name = name;
         }
     }

     public static void main(String args[]) {
         Person p = new Person(); //Invoke the constructor
         p.getName(); //returns an empty string, since that was its initial value
     }
}

This example is very similar to the previous one, however we now have two constructors, a default constructor and a parameterted constructor

In the event that we have the same name in a parameter and an attribute, we can distinguish them if we use the reserved word this

We did with the parameter name and the attribute name, when using this have become unambiguated

A constructor can also be overloaded, that is, it receives different types of arguments to have different behavior

class Example {
     class Point {
          int x, y;
          
         //constructor with parameters
         public Point(int x, int y) {
              this.x = x;
              this.y = y;
          }
     }
     
     class Rectangle {
         private int x1, y1, x2, y2;

        //the parameters of this constructor are all the attributes of the class, it is not mandatory to use all
        public Rectangle(int x1, int y1, int x2, int y2) {
            this.x1 = x1;
            this.y1 = y1;
            this.x2 = x2;
            this.y2 = y2;
        }

        //the constructor parameters can also be another class
        public Rectangle(Point origin, int width, int height) {
            this.x1 = origin.x;
            this.y1 = origin y;
            this.x2 = x1 + width;
            this.y2 = y2 + height;
        }

        //from a constructor other constructors can be used
        public Rectangle(Point p1, Point p2) {
            this(p1.x, p1.y, p2.x, p2.y);
        }
    }

    public static void main(String args[]) {
        Point p1 = new Point(2, 2);
        Point p2 = new Point(4, 4);
        Rectangle r1 = Rectange(2, 2, 4, 4);
        Rectangle r2 = Rectange(p1, 2, 4);
        Rectangle r3 = Rectange(p1, p2);
    }
}

In this example we have defined classes Point and Rectangle

By defining multiple constructors with parameters of different types to the class Rectangle

So we have overloaded the constructor to be getting different results in the main method

Attributes static

A class describes the attributes of each object (instance attributes)

Sometimes you need attributes that are shared by everyone: that remain to the class

The reserved word static declares a class attribute

class Example {
     class A {
         static int common;
     }

     public static void main(String args[]) {
         A common = 5;
     }
}

In the example you have declared an attribute static of type int, it's not a class but as you can see you can also use primitive types

To access the attribute static we've given you the name of the class, in this case A

There is No need any class instance to be able to access the attribute

It is created when you load the class and initialize with the values from the default constructor

class Chronometer {
     int h;
     int m;
     int s;
}

class A {
     static int i;
     static Chronometer lotus;

     static {
         i = 5;
         lotus = new Chronometer();
     }
}

In the example, we have used the classes Timer and A initializing their attributes in a block static

With static should not create new objects because they are back on track with each new instantiation

The class attributes are initialized using a block static

The blocks static running to load the class

Can be considered as a builder most of the class

class Chronometer {
     int h;
     int m;
     int s;
}

class A {
     static int i = 5;
     static Chronometer lotus = new Chronometer();
}

In this example I've reduced the code to use an equivalent alternative to initialize in the declaration

Static methods

In the same way that there are attributes static there are methods static

Recommended for use with utility methods that are not performed on any object but about primitive types

For example the class Math it offers the methods static sqrt, random, pow, etc

Are declared by using the word static

class Example {
     class A {
         static void f() {}
     }

     public static void main (String args[]) {
         A.f();
     }
}

In the example you have declared the method static f in the class A

The class name is used to invoke them, in this case the class A

A method static you can only access:

• attributes static

• other static methods

class A{
    int i;
    
    void f() {}
    static void g(A a){
        a.i = 5;
        a.f();
    }
}

In the example a reference has been added to the method static g what that allows us to access the elements of the instance of the class A without being static

Keep in mind that to access instance items must obtain a reference to previously

Inheritance

A derived class can add new operations (expand the number of messages that the object understands)

class example {
      class A {
          void methodA() {
              System.out.println ("methodA");
          }
      }
     
      class B extends A {
          void methodB() {
              System.out.println ("methodB");
          }
      }

      public static void main(String args ()) {
          A a = new A();
          B b = new B();

          a.metodoB(); //ERROR: a does not understand methodB, only understands methodA
          b.methodA(); //b understands methodA
          b.methodB(); //b understands methodB
      }
}

In the example you have created the classes A and B

As B inherited methods A y por tanto, podía usar methodA without problems

However, A non inherited methods B, that's why it gave us an execution error

class example {
     class A {
         void methodA() {
             System.out.println ("methodA");
         }
     }

     class B extends A {
         void methodA() {
             System.out.println ("methodA inside B");
         }
     }

     public static void main (String args ()) {
          A a = new A();
          B b = new B();

          a.methodA(); //show methodA
          b.methodB(); //show method A inside B
     }
}

In the example we have used a derived class to redefine operations

Redefining one method is to give a different implementation to the same message (which will be treated by another method)

It is important not to confuse the overhead of a method with its redefinition

class example {
      class A {
          void methodA() {
              System.out.println ("methodA");
          }
      }

      class B extends A {
          void methodA() {
              System.out.println("Before");
              super.methodA();
              System.out.println("After");
          }
      }

      public static void main(String args()) {
           B b = new B();

           b.methodA(); //show Before, methodA, After
      }
}

In the example, has redefined the method methodA of the class A in the class B, reusing it by replacing its implementation

It has been used the reserved word super to refer to the methods of the base class

You can also use the reserved word super to refer to the attributes of the base class

class Example {
      class Vehicle {
           void walk() {
               System.out.println ("Walking");
           }
      }

      class Car extends Vehicle {}

      class Bicycle extends Vehicle {}

      public static drives(Vehicle v) {//rest of the driving code}

      public static void main(String args[]) {
          Vehicle v;
          Car c = new Car();

          v = c; //The car is a subtype of Vehicle
          v = new Bicycle();
          /* drives supports Vehicle type parameters
          c will be used the same as if it were a Vehicle */
          leads (c);
      }
}

In the example there is a base object Vehicle, two derivatives Car and Bike

A fundamental aspect of inheritance is the relationship between the base type and the derived type

The derived class has at least the operations of the base class

That is, an object of the first class understands all the messages that an object of the second class might understand

Therefore, any reference of the base type can point to an object of the derived type (since it understands all its messages)

Polymorphism

Inheritance allows different classes to share a common set of operations (those in the base class)

Dynamic binding allows that even if two objects accept the same messages they can perform them differently

class Example {
     class Vehicle {
         void walk() {
             System.out.println("Walking");
         }
      }

      class Car extends Vehicle {
          void walk() {
             System.out.println("Speeding up");
          }
      }

     class Bicycle extends Vehicle {
         void walk() {
             System.out.println("Pedaling");
         }
     }

     public static leads(Vehicle v) {
          v.walk(); // depending on who invokes it, it will use one method or another
     }

     public static void main(String args[]) {
         drive (new Vehicle());
         drive (new Car());
         drive (new Bike());
     }
}

In the example we can see that thanks to polymorphism, even though v is of type Vehicle it takes into account the type of object pointed

It is important to differentiate the two types that participate in sending a message:

• The type of reference

  it is the one that determines the messages that it can transmit to its associated object

  Therefore, it can only be associated with objects that understand at least those messages (objects of the same type or of a derived type)

• The type of the associated object

  it is the one that determines which method is the one that dispatched the message received

Constructors and inheritance

The constructors cannot be inherited

class Example {
     class A {
         public A() {}

         public A(int i) {}
     }

     class B extends A {}

     public static void main (String args []) {
         B b = new B(14); //ERROR: the constructor cannot be inherited
     }
}

In the example we have declared two constructors for the class A and then it has been inherited in the class B

When you try to use the constructor with integer parameter will give us an error because B did not have an appropriate constructor though A yes that was

A class you can only use the constructors that declare

If you have not declared, none will be assigned the default constructor

class Example {
     class A {
         int i;

         public A() {}

         public A(int i) {
            this.i = i;
         }
     }

     class B extends A {
         int j;

         public B() {
             super (100);
             this.j = 200;
}
      }

     public static void main(String args []) {
         B b = new B(); //this time it does not give us an error and it is not the default constructor
     }
}

In the example we have declared two constructors for the class A and then it has been inherited in the class B

But on this occasion it has made a call to the default constructor of the base class within the constructor of the derived class

Some constructor of the base class is required to be invoked (to ensure its state)

By super you can select the proper builder

super can only appear once and must be the first line of the constructor

Will support only the parameters that support the constructors of the base class

Abstract classes

An abstract class is one which has one or more abstract methods

An abstract method is one that has not been implemented in the base class

Your code will have to be provided in each of the derived classes

To define a class as abstract using the reserved word abstract

abstract class Vehicle{
    abstract void walk();
    abstract void stop();
}

In the example we have defined the abstract class Vehicle with two abstract methods

As can be seen, methods are also defined using the reserved word abstract

Abstract classes have the restriction that they cannot be instantiated (because they have undeployed methods)

If a derived class does not redefine all abstract methods, it will in turn be an abstract class

Creating abstract classes:

• Identify the common operations that have to have objects to manipulate

• Create with them an abstract class base

• Identify the operations to redefine and give an implementation to the rest

Use of abstract classes:

• Their only goal is the derivation

• The class derived will have to implement the abstract methods

• Others may be inherited, replaced or expanded

Classes end

You may want a class to be un derived (for security reasons, you do not want anyone to be able to replace it with a derived class)

It uses the reserved word end so that the class can not be derived

final class A{}

class B extends A{} //ERROR: the compiler does not allow inheriting class A because it is final

In the example we have tried to inherit the class B the class A that was end

As we have defined A as end the interpreter will not allow you to have inherited classes

class A {
     final void validatePassword() {}
     void f () {}
}

class B extends A {
      void validatePassword () {} //ERROR: this method was final, it cannot be redefined
      void f() {} //In this case there is no problem, because it was not final
}

In the example we have defined a final method and one that is not

There is also an intermediate level: that can be derived from the class but not certain methods

A method you can also use the reserved word end

A final method cannot be redefined

import java.math.*;

class A{
    final double x = Math.random();  
    
    void f(){
        this.x = 7; //ERROR: being a final type, its value cannot be modified, although it can be consulted
    }
}

In the example we tried to modify a final attribute, the interpreter will give us an error

Make a class or method final is a major constraint

Should only be done in special situations and putting the utmost care

A final attribute cannot be modified once it has been started

class A{
    final double x = Math.random();
    final int x = 100; //Redundant

}

In the example, we have defined two variables called x as a final

If the value of the final attribute is the same for all instances, it is wasting space in memory

class A{
    static final double PI = 3.141592;
    static final int MAX = 100;
}

In this example, we have used constant variables to solve the problem of the previous example

In Java, constants are declared by combining the reserved words static followed by end

Constants do not take up memory and by convention, they are usually defined with a capitalized name

Downcasting

When a class is not derived explicitly from another class then derived implicitly from the class java.lang.Object

class Example {
     class Vehicle {
         void walk() {
             System.out.println("Walking");
         }
     }

     public static void main(String args[]) {
         Object v = new Vehicle();
        
         v.toString(); //show the string associated with the Object object, it can be redefined in Vehicle
     }
}

The class Object it's not a primitive type, but it's the class from which all the language classes derive and those that the programmer believes

However, you don't need to use the reserved word extends because it implicitly drifts

Therefore, all kinds of Java is a Object and will inherit the methods of this

Some of the outlined methods of the class Object:

• boolean equals(Object)
• void finalize()
• int hashCode()
• String toString()

There are occasions in which it is known with certainty that the object is of the appropriate class

In these cases you may be able to force the assignment using a cast

class Example {
     class Vehicle {
         void walk() {
             System.out.println("Walking");
         }
     }

     class Canoe extends Vehicle {
         void walk() {
             System.out.println("Rowing");
         }
     }
     public static void main(String args[]) {
         Vehicle v = new Canoe();
         Canoe c = (Canoe) v;
     }
}

In the example we have used the classes Vehicle and Canoe that inherits from it

To then make a declaration of a Vehicle v for that we have used the constructor Canoe

And has been declared a Canoe c for which the type was previously known (Canoe) por lo que se ha realizado un cast

The cast checks that the object is of the appropriate class and performs the assignment

In the event of not being of the appropriate class or is not able to perform the assignment will throw an exception ClassCastException

Operator instanceof

The operator instanceof allows you to find out if an object belongs to a certain class

class Example {
     class Vehicle {
         void walk() {
             System.out.println("Walking");
         }
     }

     class Canoe extends Vehicle {
         void walk() {
             System.out.println("Rowing");
         }
     }
     public static void main (String args []) {
         Vehicle v = new Canoe ();

         if (vehicle instanceof Object) {//will always be True
             Canoe c = (Object) v;
         }
         if (vehicle instanceof Canoe) {//True only if the object belongs to class Canoe
             Canoe c = (Canoe) v;
         }
     }
}

In the example, has carried out two checks with instanceof

When we tested with Object will always return True because it is a supertype of the class of the instance

When we tested with Canoe we have checked if the cast can be applied

In this way we avoid having to handle the exception ClassCastException

Interfaces

Interfaces, like classes, are a way to create objects

They are characterized by only one behavior (and/or constants)

• Have No attributes

• Do not have associated code for methods

Are defined with the reserved word interface in a similar way as is done with the classes

interface anInterface{
     void method1();
     int method2(char c, Objetc o);
}

In the example we have defined the interface anInterface with the methods method1 and method2

Similar to abstract classes, because they have no implementation it is possible to instantiate the interface

You can only use it to create new data types (other classes or interfaces)

interface anInterface {
      void method1();
      int method2(char c, Object o);
}

class aClass implements anInterface {
     void method1() {
         System.out.println("Method 1");
     }

     void method2() {
         System.out.println("Method 2");
     }
}

In this example it has implemented the interface anInterface heredandola in the class aClass

When the class aClass inherited methods anInterface it has become a subtype of that interface

For that reason we must give them an implementation in the class, since sinó we would be obliged to declare it abstract

But precisely because he has used an interface, the interpreter will show us an error message telling us which specific methods have not been implemented

Differences between class and interface

Class:

• Type that extending it by inheritance results in its behavior and implementation (both attributes and its methods)

• Advantage: Less coding when creating new subtypes as its behavior comes to its implementation

• Drawback: It can only be derived from one of them, multiple inheritance is not allowed

Interfaces:

• Type that extending it by inheritance gets only its behavior (description of methods)

• Advantage: You can inherit multiple interfaces without conflicts

• Drawback: There is hard-coding the implementation of each method for each subtype inherited

Control statements

Control statements are nothing more than a set of words that tell the interpreter things like what the next statement to execute is, how many times to evaluate a particular expression, and so on

Sentences of selection

They serve to group statements and statements into a compound statement or block, which from that moment can be considered syntactically equivalent to a simple

if-else

The expression if-else lets you choose whether to run the next or following sentences on the basis of a boolean value

It has the following syntax:

if (<Boolean expression>) {
     <statement block>;
} else {
     <statement block>;
}

First evaluates the boolean expression and in the case that your result is equal to TRUE to run the block of sentences then if

In the case that your result is equal to FALSE to run the block of sentences then the else

else is optional and we may not use it, although if we want to have all the options covered, it is advisable to use it

Within a block of statements can include additional if-else, this practice is known as nesting and it is very useful to continue adding conditions to check the code

int a = 5;
int b = 6;
int c = -1;

if(a >= b){
    if(a >= c){
        System.out.println("The highest value was: %d", a);
    }
}else {
    if(b >= c){
        System.out.println("The highest value was: %d", b);
    }else{
        System.out.println("The highest value was: %d", c);
    }
}

The example compared the integer values contained in variables a, b, and c, using nested if-else, showing the user the highest value per screen

else-if

The else-if expression is an improvement to the if-else expression, its operation is similar, however it allows to have a multiple selection without resorting to nesting, although within the block of sentences it will be possible to perform nesting

It has the following syntax:

if (<Boolean expression>) {
     <statement block>;
} else if (<Boolean expression>) {
     <statement block>;
} else {
     <statement block>;
}

else is optional and we may not use it, although if we want to have all the options covered, it is advisable to use it

int a = 5;
int b = 6;
int c = -1;

if(a >= b){
    if(a >= c){
        System.out.println("The highest value was: %d", a);
    }
}else (b >= c){
        System.out.println("The highest value was: %d", b);
}else{
        System.out.println("The highest value was: %d", c);
}

The code in this example is very similar to the previous one used with if-else, they are syntactically equivalent, but it has managed to reduce the number of lines of code a bit

switch

Since multiple selection is a very common construction, it is more advisable to use the switch

But keep in mind that it only works with whole expressions, we can't use any Boolean expression as with if-else or else-if

It has the following syntax:

switch (<integer expression>) {
     case <integer1>:
         <statement block>;
         break;
     case <integer2>:
         <statement block>;
         break;
     case <integer3>:
         <statement block>;
         break;
         ...
     default:
        <statement block>;
}

First evaluates the entire expression and checks whether it equals the value contained in the first case, in case its result is equal to TRUE to run the block of sentences then in that case

The execution will not end until find a break, therefore ending the execution of the switch expression

break it can be omitted and then it would check the next case

In the event that no case has value TRUE, then it would work in a similiar way to the else, executing the block of sentences then the default

int day = 3;

switch(day) {
     case 1:
         System.out.println("It's Monday");
         break;
     case 2:
         System.out.println("It's Tuesday");
         break;
     case 3:
         System.out.println("It's Wednesday");
         break;
     case 4:
         System.out.println("It's Thursday");
         break;
     case 5:
         System.out.println("It's Friday");
         break;
     default:
         System.out.println("It's non school, weekend");
}

The example has checked which day of the week is the integer value by displaying the name of the day and if it is Saturday or Sunday, showing that it is a non-school day and weekend

This example would only work with values from 1 to 5, because if we enter any other value, it would show us by screen the default, that is, that it is weekend

Sentences jump

Sometimes we need to exit unconditionally of any expression and to do this we will use the sentences jump

break

This expression provides the option to unconditionally exit a while, do-while, for, for-each, or switch expression

In case the expression is nested, what it will do is exit the innerdest expression

It has the following syntax:

break;

Although syntactically correct, its use makes the code difficult to read, since it is adding an exit point not controlled by a Boolean expression

continue

This expression is similar to the break expression, however, it is less aggressive

Breaks the execution of the block of sentences but it re-evaluates the boolean expression

It cannot be used on a switch, as it would have no effect

In case the expression is nested, what it will do is exit the innerdest expression

It has the following syntax:

continue;

Sentences of iteration

Sometimes we need to run a block of sentences un determinado o indeterminado número de veces, a estas sentencias se las denomina loops

while

This expression repeats a block of statements while is satisfied a boolean expression

It has the following syntax:

while (<Boolean expression>) {
     <statement block>;
}

Within the block of sentences we must make sure that you modify in any way the value of the boolean expression, because otherwise we can fall into a loop that never ends and is called infinite loop

This situation is not desirable, as our program will be hung and it is likely that the user would not know what to do in that situation, since the programmer has not bothered to control it

int i = 0;

while(i < 100){ 		
    System.out.println("%d", i + 1);
    i++;
}

The example walks through numbers 1 through 100 and shows the user per screen

The counter started at 0, because it is an agreement that was used to initialize variables in C and is still used in Java

Just like using variable names i, k, or j for counters

do-while

This expression is similar to while, however the statement block is always executed at least once and the condition check is performed after that execution

It has the following syntax:

do{
     <statement block>;
}while(<Boolean expression>);

Within the block of sentences we must make sure that you modify in any way the value of the boolean expression, because otherwise we can fall into a infinite loop

Also supports expressions break and continue

int i = 0;

do{ 		
    System.out.println("%d", i + 1);
    i++;
}while(i < 100);

The example walks through numbers 1 through 100 and shows the user per screen

It should be noted that the first time the Boolean expression is not evaluated, but rather because of that situation, it would be totally equivalent to the expression while

for

This expression is similar to while, however it allows you to initialize the variable that will handle the loop

It has the following syntax:

for (<initialization>; <Boolean expression>; <variable variation>) {
     <statement block>;
};

Within the variation of the variable we must make sure that you modify in any way the value of the boolean expression, because otherwise we can fall into a infinite loop

Also supports expressions break and continue although its use is discouraged, as it is considered that for this expression they break the normal flow of the program

for(int i = 0; i < 100; i++){
    System.out.println("%d", i + 1);
}

The example walks through numbers 1 through 100 and shows the user per screen

It is totally equivalent to the while expression, but saves some lines of code by including its own initialization and in this case, an increase in the variable outside the expression block

for-each

This expression is similar to the for but is specialized in travel objects that support the Iterator class

It was introduced in Java version 5

It has the following syntax:

for (<initialization>: <variable name>) {
     <statement block>;
};

It is not necessary to make sure that it is changed in any way the value of the boolean expression as in a for, because when based on the Iterator class, the loop will end when there are no more elements of the object, the preventing it from falling into a infinite loop

Also supports expressions break and continue although its use is discouraged, as it is considered that for this expression they break the normal flow of the program

int num[] = {1, 2, 3, 4, 5}

for(int i: num){
    System.out.println("%d", n);
}

The example walks through an array containing numbers 1 through 5 and shows the user per screen

In this case, a simple array has been traversed, but more specialized objects could be traversed (as long as they support the Iterator class) such as an ArrayList, a Vector, a Map, etc

Exceptions in Java

If an operation cannot be completed due to an error, the program must:

• return to a stable state and allow other operations

• try to save your work and finish

This task is difficult because usually the code that detects the error is not the one that can perform such tasks this is why you should inform that you can handle it

The most common solution are the error codes

Java offers another way to deal with errors under exceptional conditions: the exceptions

An exceptional condition is one that prevents the continuation of an operation

It's not known how to handle it, but you can't continue

In Java an exception is thrown to someone who knows how to handle the question in a higher context

import java.io.File;
import java.io.IOException;

File f = new File("readme.txt");    //a file object named readme.txt is created

if(!f.exists() ){    //it is checked if the file existed in the system
    throw new IOException();    //an exception of type IOException is thrown
}

In the example it is checked by the conditional if the file readme.txt there was in the system and in case it does not exist it throws the exception IOException, which at the moment is without trying

The reserved word throw terminates the current method and throws an object that provide information about the error that occurred

Normally you would use a class for each type of error

Java requires that a method report the explicit exceptions that it can throw

A method doesn't just have to say it returns if everything goes well; should also indicate what may fail

import java.io.File;
import java.io.EOFException;
import java.io.FileNotFoundException;

void fichero() throws EOFException FileNotFoundException {
    File f = new File("readme.txt");    //a file object named readme.txt is created

    if(!f.canRead() ){    //it is checked if the file can be read
        throw new EOFException();   //an exception of type IOException is thrown
    }
    if(!f.exists() ){    //it is checked if the file existed in the system
        throw new FileNotFoundException();    //an exception of type IOException is thrown
    }
}

In the example, we have declared exceptions EOFException and FileNotFoundException affecting the method file

The specification of exceptions is performed using the word throws in the method declaration, and there can be as many as needed separated by a space

Handling of the exceptions

Once detected the error makes it necessary to indicate who is in charge of treating it

An exception handler has the following format:

try{
    //operations that can raise exceptions
}catch (<type of exception> ref){
    //Treatment of the exception
}

The block try delimits the group of operations that may produce exceptions

The block catch it is the place to which control is passed if any of the operations throws an exception

import java.io.File;
import java.lang.Exception; //this import may be redundant because java.lang. * is loaded by default

try{
    File f = new File("readme.txt");    //a file object named readme.txt is created
}catch (Exception ref){
    System.out.println("I/O error");
}

In the example it has been used a try block to your catch block to handle the errors of the previous example

If any of the operations in the block throw an exception, the block is interrupted try and runs the catch

At the end of this, it is normally continued

If no exception is thrown, the catch block is ignored

There is also the possibility of using the generic exception Exception, but it is best to use the specific exception type for the error

import java.io.File;
import java.io.FileNotFoundException;
import java.io.EOFException;

try{
    File f = new File("readme.txt");    //a file object named readme.txt is created
}catch (FileNotFoundException ref){
    System.out.println("I/O error");
}catch (EOFException ref){
    System.out.println("End of file error");
}

In the example it has been used a try block to your catch block to handle multiple exceptions as in the previous example

A try block can have multiple catch statements associated

When an exception does not correspond to any catch is propagated backward in the sequence of invocations until a catch right

import java.io.File;
import java.io.FileNotFoundException;
import java.io.EOFException;

void f1(int action) throws EOFException {
     try {
         if (action == 1) {
             throw new FileNotFoundException ();
         } else if (action == 2) {
             throw new EOFException ();
         }
     } catch (FileNotFoundException e) {
         System.out.println ("Fixed bug f1");
     }
     System.out.println ("Normal completion f1");
}

void f2 (int value) {
     try {
         f1 (value);
     } catch (EOFException e) {
         System.out.println ("Fixed bug f2");
     }
     System.out.println ("Normal completion f2");
}

In the example is managed the exceptions of the methods f1 and f2 and if you don't find any, it continues the execution of the code in the normal way outside of the block try

import java.io.IOFException;

void f1() throws IOException{
    //code
}

//Alternativa 1: el método f1 lanza una excepción IOException que será tratada en otra parte
void f2(){
    f1();
}

//Alternativa 2: el método f2 se trata la excepción IOException en el bloque catch
void f2(){
    try{
        f1();
    }catch (IOEXception e){
        //Treatment
    }
}

//Alternativa 3: el método f2 se lanza una excepción IOException que será tratada en otra parte
void f2() throws IOException {
    f1();
}

This example has tried to show the 3 alternatives we can use to handle the exception IOException from the method f2

When a method that throws exceptions is invoked, it is mandatory:

• to handle the error with a block catch

• that is indicated by throws its spread

Finally block

There may be occasions in which you want to perform some operation if exceptions occur as if not

Such operations can be located within a finally block

A finally block has the following format:

try{
    //operations that can raise exceptions
}catch(<Exception type> ref){
    //Treatment of the exception
}finally{
    //Common operations executed whether or not exceptions occur
}

If there is any exception it will execute the try block and the finally

import java.io.File;
import java.io.FileNotFoundException;
import java.io.EOFException;

try{
    File f = new File("readme.txt");    //a file object named readme.txt is created
}catch (FileNotFoundException ref){
    System.out.println("I/O error");
}catch (EOFException ref){
    System.out.println("End of file error");
}finaly{
    try{
        f.close();    //the file is closed regardless of whether there have been exceptions or not
    }catch(IOEXception e){
        System.out.println("I/O error");
    }
}

In the example it has controlled the closing of the file f in the block finaly, always running

If any exceptions occur:

• If it is caught by a catch the same try it runs east and then the finally

  The execution continues after the finally normally

• If this is not trapped it is running the finally and the exception is propagated to the previous context

Hierarchy of exceptions

Any exception must be an instance of the class Throwable

It inherits the following methods from it:

• getMessage()

  returns a string with a message that details of details the exception

• toString()

  returns a brief description which is the result is concatenate:

  • the name of the class of this object
  • el token :
  • the result of the method getLocalizedMessage() this object
• fillInStackTrace()

  records information about the current state of the stack frames for the current thread

  If the stack status cannot be written, there will be no return value

• printStackTrace()

  returns the trace that has followed the exception

  The first line of output contains the result of the method toString() this object

  The remaining lines represent data previously recorded by the method fillInStackTrace()

The basis of the Java exception hierarchy is:

• Throwable

  • Error

  • Exception

    • RuntimeException

Derived classes Error describe internal JVM errors:

• should not be thrown by the classes of user

• these exceptions rarely occur and when it is the only thing you can do is try to close the program without losing the data

• Examples: OutOfMemoryError; StackOverflow; etc

Java programs will work with the exceptions of the branch Exception

This group is in turn divided into:

• The classes that are derived directly from Exception (explicit)

• Arising from a course of RuntimeException (implicit)

Use the RunTimeException to indicate a programming error

If there is an exception of this type is that fixing the code

Examples:

• A cast wrong

• Access to an array out of range

• Use of a pointer null

The rest of Exception indicate that has happened some error due to any cause beyond the program

Examples:

• An I/O error

• Connection Error

Declaration of exceptions

The methods should be declared only with the explicit exceptions

Implicit ones should not be declared (although they can occur equally)

Therefore, when a method declares an exception, warning you that it may occur that error in addition to any error implicit

Creation of exceptions

If you need to handle any errors not covered by the standards that Java has, we can create our own kind of exception

The only condition is that the class derives from Throwable or in any arising out of it

In practice, the following shall generally be derived:

• of RunTimeException if you want to report a programming error

• of Exception in any other case

Exceptions and inheritance

When you redefine a method it is giving another implementation for the same behavior

The new method may only throw exceptions declared in the original method

class A{
    void f() throws EOFException {}
}

class B extends A{
    void f() throws EOFException, FileNotFoundException {}
}

In the example, has redefined the method f of the class A in the class B with an additional exception

A method can declare the exceptions that do not throw really

A base method may allow the redefinitions may cause exceptions

Constructors, not inherited, can throw new exceptions

Rules of use

1. Standard

   • If an exception can be handle should not be spread

   • It is more convenient to use methods that do not produce errors

2. Standard

   • Do not use exceptions to avoid a query

     • Not to abuse them

       class Heap{
           int pop() throws EmptyStackException;
       }

3. Standard

   • To separate the error handling logic

     All together
     String c = "example"; for(int i = 0; i < c.length(); i++){ try{ obj1.mesg1(); }catch (Exception a){ //Treatment } try{ obj2.mesg2(); }catch (Exception b){ //Treatment } }

     Separate
     String c = "example"; try{ for(int i = 0; i < c.length(); i++){ obj1.mesg1(); obj2.mesg2(); } }catch(Exception a){ //Treatment }catch(Exception b){ //Treatment }

4. Standard

   • Do not ignore an exception already that we leave the code with errors without control

     try{
         //Operations
     }catch(EmptyStackExecution e) {} //For the compiler to shut up

I/O streams

The I/O streams in Java is performed through sorted sequences of bytes (streams)

These can be input (InputStream) or output (OutputStream) independent objects from data

The classes of E/S are in the package java.io

The methods of OutputStream and InputStream throw the exception IOException for any failure related to the attempt to read/write

The class OutputStream

Abstract class from which derive the other output streams

It essentially offers the following methods:

• public abstract void write(int b) throws IOException
• public void write(byte b[]) throws IOException
• public void write(byte b[], int off, int len) throws IOException
• public void flush() throws IOException

  Force the write

• public void close() throws IOException

There are several classes that are derived from OutputStream and redefine the method write to give you a different implementation:

• FileOutputStream

  it redefines the method write to send bytes to a file

  import java.io.FileOutputStream;
  
  try{
      FileOutputStream out = new FileOutputStream("data.dat");
  
      for(int i =0; i < 100; i++){
          out.write(i);
      }
  }catch(IOEXception e){
      System.out.println("I/O error");
  }finally{
      try{
          out.close();   //The flow of the data.dat file is closed
      }catch(IOEXception e){
          System.out.println("I/O error");
      }
  }

• ByteArrayOutputStream
• PipedOutputStream
• Sun.net.TelnetOutputStream

FilterOutputStream

A output filter it is a OutputStream to which will be associated to it in its constructor another OutputStream (a decorator pattern)

The filter forwarded all of the information you receive to your OutputStream associated, after carrying out some kind of transformation in it

In this way each filter adds an additional functionality to the OutputStream that encapsulates

You can chain multiple filters to obtain multiple functionalities, combined

import java.io.FileOutputStream;

try{
    int i;
    FileOutputStream out = new FileOutputStream("data.dat");

    out.write((i >>> 24) & 0xFF);
    out.write((i >>> 16) & 0xFF);
    out.write((i >>> 8) & 0xFF);
    out.write((i >>> 0) & 0xFF); //Likewise for String, float, etc
}catch(IOEXception e){
    System.out.println("I/O error");
}finally{
    try{
        out.close();   //Stream data.dat file is closed
    }catch(IOEXception e){
        System.out.println("I/O error");
    }
}

In the example the file has loaded data.dat for writing and using the method write have saved several integer values that are stored in the variable i

He adds & 0xFF at the end of the write stream to indicate within the file that a data has finished writing

Filter DataOutputStream

The methods of the class OutputStream only allow you to send bytes

Any other type must be broken down into a sequence of bytes before it can be written

Among the most prominent methods:

• void writeBytes(String s) throws IOException
• void writeBoolean(boolean v) throws IOException
• void writeShort(int v) throws IOException
• void writeChar(int v) throws IOException
• void writeInt(int v) throws IOException
• void writeLong(long v) throws IOException
• void writeFloat(float v) throws IOException
• void writeDouble(double v) throws IOException
• void writeChars(Strings s) throws IOException

  Almost uns used, the filter is more used PrintStream

import java.io.DataOutputStream;
import java.io.FileOutputStream;

try{
    DataOutputStream out = new DataOutputStream(new FileOutputStream("data.dat");

    out.writeInt(45);
    out.writeDouble(3.14);
    out.writeChars("Hello");
}catch(IOEXception e){
    System.out.println("I/O error");
}finally{
    try{
        out.close();   //Stream data.dat file is closed
    }catch(IOEXception e){
        System.out.println("I/O error");
    }
}

In the example, two filters have been used, the FileOutputStream seen above and the DataOutputStream seen now

The class DataOutputStream adds the functionality of being able to send all primitive types directly

So you can write in the file any primitive type and even attributes of an object, as long as they are primitive types, since you do not write the entire object

Filter PrintStream

The class PrintStream adds the functionality of being able to send all of the primitive types in text format

import java.io.FileOutputStream;
import java.io.PrintStream;

try{
    PrintStream out = new PrintStream(new FileOutputStream("data.dat"));

    out.println(45);
    out.println(3.14);
    out.println("Hello");
}catch(IOEXception e){
    System.out.println("I/O error");
}finally{
    try{
        out.close();   //Stream data.dat file is closed
    }catch(IOEXception e){
        System.out.println("I/O error");
    }
}

In the example, two filters have been used, the FileOutputStream seen above and the PrintStream seen now

Methods print and println are overloaded for all primitive types

System.out is of type PrintStream and that's why it is not necessary to reference it by using this filter

The most common way of use OutputStream will be combining several filters

The class InputStream

Abstract class from which derive the other input streams

It essentially offers the following methods:

• public abstract int read() throws IOException
• public int read(byte b[]) throws IOException
• public int read(byte b[], int off, int len) throws IOException
• public int available() throws IOException
• public void close() throws IOException

There are several classes that are derived from InputStream and redifinen the method read to give you a different implementation:

• FileInputStream

  it redefines the method read to read bytes from a file

  import java.io.FileInputStream;
  
  try{
      int dat;
      FileInputStream in = new FileInputStream("data.dat");
      
      while((dat = in.read()) != -1){
          System.out.println(dat);
      }
  }catch(IOEXception e){
      System.out.println("I/O error");
  }finally{
      try{
          in.close();   //Stream data.dat file is closed
      }catch(IOEXception e){
          System.out.println("I/O error");
      }
  }

• ByteArrayInputStream
• StringInputStream
• SequenceInputStream
• PipedInputStream
• Sun.net.TelnetInputStream

FilterInputStream

An input filter is a InputStream to which will be associated to it in its constructor another InputStream

The filters return the information which they have read of his InputStream associated, after carrying out some kind of transformation in it

In this way each filter adds an additional functionality to the InputStream basic

You can chain multiple filters to obtain multiple functionalities, combined

import java.io.FileInputStream;

try{
    int i = 0;
    int ch[];
    FileInputStream in = new FileInputStream("data.dat");

    while((ch[i] = in.read()) != -1){
        System.out.println("%d", ch[i]);
        i++;
    }
}catch(IOEXception e){
    System.out.println("I/O error");
}finally{
    try{
        in.close();   //Stream data.dat file is closed
    }catch(IOEXception e){
        System.out.println("I/O error");
    }
}

In the example the file has loaded data.dat for reading and using the method read have read several integer values that are stored in the variable ch in the positions i + 1 and we've shown by screen

So we have been able to read the file that we write with the example of FileOutputStream

Filter DataInputStream

The methods of the class InputStream only allow to read bytes

Any other type should be read as a sequence of bytes, and to pick up the pieces before it can be used

It essentially offers the following methods:

• readBoolean()
• readChar()
• readByte()
• readShort()
• readInt()
• readLong()
• readFloat()
• readLong()
• readFloat()
• readDouble()
• readLine()
• readFully(byte[] b)

import java.io.FileInputStream;

try{
    DataInputStream in = new DataInitStream(new FileInputStream("data.dat");

    System.out.println("%d", in.readInt() );
    System.out.println("%.4f", in.readDouble() );
    System.out.println("%s", in.readLine() );
}catch(IOEXception e){
    System.out.println("I/O error");
}finally{
    try{
        in.close();   //Stream data.dat file is closed
    }catch(IOEXception e){
        System.out.println("I/O error");
    }
}

In the example, two filters have been used, the FileInputStream seen previously, and the DataInputStream seen now

The class DataInputStream adds the functionality of being able to receive all of the primitive types directly

That has allowed us to display primitive data contents of the file directly on the screen

So read from the file any primitive type and even attributes of an object, as long as they are primitive types, since it does not read the entire object

The most common way of use InputStream will be combining several filters

Utilities

There is a set of utilities within the Java language

Found in the package java.util

These are useful and everyday classes, among which we highlight:

• Collections
  • Collection
    • List
    • Set
    • Map
• Dates
  • Date
  • Calendar
• Properties
• Scanner

Collection

The API of collections of Java includes classes that are able to hold sets of objects

Represent containers of objects

They are dynamic structures, grow as elements are added and work with Objects

• You can add any thing

• To retrieve the item must be done casting

There are basically two sets:

• Classes that implement Collection

  • Represent containers of objects

  • There are basically lists (List) and sets (Set)

• Classes that implement Map

Some of its most important methods are:

• boolean add(Object o)

  adds an item to the collection

• boolean addAll(Collection c)

  adds a group of objects (another collection) to the collection

• void clear()

  empty the collection

• boolean contains(Object o)

  checks if an element is within the collection

• boolean isEmpty()

  checks if the collection is empty

• Iterator iterator()

  returns a java.util.Iterator to iterate through the elements of the collection

• boolean remove(Object o)

  removes an item from the collection

• int size()

  number of objects stored

• Object[] toArray(Object[] a)

  returns an array with the elements of the collection

List

Serves as the interface for classes that represent data lists or dynamic arrays

Its elements are accessible by means of an index

Inherits the methods of Collection and also adds:

• void add(int index, Object element)

  adds an element at a given position

• Object get(int index)

  returns the item that occupies a certain position

• int indexOf(Object o)

  returns the index of the first occurrence of the item in the list (or -1 if it cannot be found)

• Object remove(int index)

  it removes the element that occupies a certain position

• Object set(int index, Object element)

  changes the element that occupies a particular position with another element

When you add an object with add(Object), the element is added at the end

When you delete an object with remove(Object), everyone else moves so as not to leave gaps

The objects List most common are Vector (is threadsafe) and ArrayList (not threadsafe)

import java.util.List;
import java.util.Vector;

class Example {
    class Person {
        private String name;

        public Person(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

    public static void main(String args[]) {
        List pers = Vector();

        pers.add (new Person("PEPE"));
        pers.add (new Person("LUIS"));
        pers.add (new Person("ANA"));
        Person juan = new Person("JUAN");
        pers.add(juan);
        Person carlos = new Person("CARLOS");
        pers.add(carlos);
        System.out.println("Carlos is at" + pers.indexOf(Carlos); //returns 4
        pers.remove(juan);
        System.out.println ("Carlos is at" + pers.indexOf(Carlos); //returns 3
        System.out.println("The size is" + pers.size()); //returns 4
        System.out.println("Is Carlos there?" + Pers.contains (new Person("CARLOS"))); //returns false
        System.out.println("Is Carlos there?" + Pers.contains(Carlos)); //returns true
    }
}

Set

Serves as an interface for classes that represent datasets

Can not have duplicate elements

Its elements are not accessible by an index

Adds No new methods

The objects Set most common are HashSet and TreeSet

import java.util.Set;
import java.util.HashSet;

class Example {
     class Person {
         private String name;

         public Person(String name) {
             this.name = name;
         }

         public String getName() {
             return this.name;
         }

         public void setName(String name) {
             this.name = name;
         }
     }

     public static void main(String args[]) {
         Set pers = HashSet();

         pers.add(new Person("PEPE"));
         pers.add(new Person("LUIS"));
         pers.add(new Person("ANA"));
         pers.add(new Person("JUAN"));
         pers.add(new Person("CARLOS"));
         pers.remove(new Person("JOHN"));
         System.out.println("The size is" + pers.size()); //returns 4
         System.out.println("Is Ana there?" + Pers.contains(new Person("ANA"))); //returns true
         System.out.println("Is Carlos here?" + Pers.contains(new Person ("JUAN"))); //returns false
     }
}

Map

Represent tables of data

The whole map consists of a set of entries composed of:

• A key, it serves to retrieve the item
• A value

import java.util.Map;

class Example {
     class Person {
         private String name;

         public Person(String name) {
             this.name = name;
         }

         public String getName() {
             return this.name;
         }

         public void setName(String name) {
             this.name = name;
         }
     }

     public static void main(String args[]) {
         Map agenda;
         Person p = new Person("PEPE");

         agenda.put("16444444E", p); //we store a Person with key 16444444E
         //To retrieve it, it is not necessary to search for it or go through the structure, it is requested directly using the key
         p = (Person) agenda.get("16444444E");
         System.out.println(p.getName());
}

The most important methods are:

• void clear()

  empty the structure

• boolean containsKey(Object key)

  returns true if there is any object stored with that key

• boolean containsKey(Object value)

  returns true if the Map contains that object

• Object get(Object key)

  allows you to retrieve a specific item from its key

• boolean isEmpty()

  indicates if the Map is empty

• Set keySet()

  returns a set of keys in the Map

• Object put(Object key, Object value)

  stores an object on the map with a particular class. If the key is already stored it is replaced by an associated object with the new

• void putAll(Map t)

  includes a submap on the map

• Object remove(Object key)

  deletes an object from given key

• int size()

  returns the number of objects stored

• Collection values()

  returns the set of values stored in the map

Are implemented as Hash tables

The most common are HashMap (not threadsafe) and Hashtable (is threadsafe)

import java.util.Map;
import java.util.Hashtable;

class Example {
    class Person {
        private String name;

        public Person(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

    public static void main(String args[]) {
        Map agenda = new Hashtable ();
        Person p = new Person("PEPE");

        agenda.put("1644444E", p);
        agenda.put("2222222A", new Person ("ANA"));
        agenda.put("3333333A", new Person ("LUIS"));
        agenda.put("4444444A", new Person ("MARIA");
        System.out.println("Does the DNI 2222222A exist?"; + Agenda.containsKey("2222222A")); //returns true
        Person pr = (Person) agenda.get("1644444E"); //pr will be Pepe
        System.out.println ("Is it Pepe?" + Pr.equals(p)); //returns true
        System.out.println ("The size is" + agenda.size()); //returns 4
}

Iterator

There are collections that are accessed through an index, others not

Iterator lets you iterate over collections of objects regardless of how they are organized

Otra ventaja, permite eliminar objetos sin tener que gestionar los indices

The most important methods are:

• boolean hasNext()

  returns True if the iterator has any more element

• Object next()

  returns the next element of the iteration

• void remove()

  removes from the collection the last element returned by the iterator

import java.util.List;
import java.util.Vector;

class Example {
     class Person {
         private String name;

         public Person(String name) {
             this.name = name;
         }

         public String getName() {
             return this.name;
         }

         public void setName(String name) {
             this.name = name;
         }
     }

     public static void main(String args[]) {
         List pers = Vector();

         pers.add (new Person("PEPE"));
         pers.add (new Person("LUIS"));
         pers.add (new Person("ANA"));
         pers.add (new Person("JUAN");
         pers.add (new Person("CARLOS");

         for (int i = 0; i < pers.size(); i ++) {
            Person p = (Person) pers.get(i);

            System.out.println (p.getName());
         }
     }
}

import java.util.List;
import java.util.Vector;
import java.util.Iterator;

class Example {
     class Person {
         private String name;

         public Person(String name) {
             this.name = name;
         }

         public String getName() {
             return this.name;
         }

         public void setName(String name) {
             this.name = name;
         }
     }

     public static void main(String args[]) {
         List pers = Vector();
         Iterator iter = pers.iterator();

         pers.add(new Person("PEPE"));
         pers.add(new Person("LUIS"));
         pers.add(new Person("ANA"));
         pers.add(new Person("JUAN");
         pers.add(new Person("CARLOS");

         while (iter.hasNext()) {
            Person p = (Person) iter.next();

            System.out.println(p.getName());
         }
     }
}

Dates

There are two classes that allow you to work with dates:

• Date

  almost all of its methods are deprecated so it is not recommended to use

• Calendar

  it is an interface which is very easy to give you the behavior you want

Both of the internally represented time by a value of type long that represents the number of milliseconds from the January 1, 1970 at 00:00:00 GMT

That value can be obtained using System.currentTimeMillis()

Calendar allows for many more operations with dates Date, although it is more difficult build (being an interface we will have to do its implementation ourselves)

Date

It is easy to build:

• new Date()

  constructs an object Date with the current system date

Methods that are not deprecated:

• boolean after(Date when)

  checks to see if the date is later than the one supplied as a parameter

• boolean before(Date when)

  checks to see if the date is previous to the one supplied as a parameter

• long getTime()

  returns the number of milliseconds since the 1 de Enero de 1970 a las 00:00:00 GTM

• void setTime(long time)

  changes the date to another date in milliseconds

Deprecated methods:

• int getDay()

  returns the day of the week for that date or returns the day that represents that instant in the local area

  Day of the week

  Day	Sunday	Monday	Tuesday	Wednesday	Thursday	Friday	Saturday
  Value	0	1	2	3	4	5	6

• getMonth()

  returns the month for that date starting with 0

  Months

  Month	January	February	March	April	May	June	July	August	September	October	November	December
  Value	0	1	2	3	4	5	6	7	8	9	10	11

• getYear()

  returns the year for that date that has been subtracted from 1900

• getHours()

  returns the time for that date, which will be between 0 and 23

• getMinutes()

  returns the minutes for that date, which will be between 0 and 59

• getSeconds()

  returns seconds for that date, which will be between 0 and 61, values 60 and 61 will only appear when the MVJ skips for a few seconds in an account

import java.util.Date;
import java.text.SimpleDateFormat;

class Example {
     public static void main(String args[]) {
         Date d = new Date(); //The system time was 02-05-2004 7:35 AM
         SimpleDateFormat df = new SimpleDateFormat("dd-mm-yyyy hh: mm"); //we put the format dd-mm-yyyy hh: mm

         System.out.println(df.format(d)); //we will see it on the screen as 5-2-2004
         Sytem.out.println("Day" + d.getDay()); //returns 4
         Sytem.out.println("Month" + d.getMonth()); //returns 1
         Sytem.out.println("Year" + d.getYear()); //returns 104
         Sytem.out.println("Time" + d.getHours()); //returns 7
         Sytem.out.println("Day" + d.getMinutes()); //returns 35
     }
}

Calendar

Abstract class for representing dates in different types of calendars

It includes a lot of constants for all days of the week, months, fields of a date...

In the west, to get the date of the system we will use the GregorianCalendar:

• new GregorianCalendar()
• new GregorianCalendar(2007, 1, 5)

  Attention should be paid to the date:

  • es año, mes, día

  • Corresponds to the February 5, 2007 and not the January 5, 2007 as it might seem at first glance

    January corresponds to the value 0

We can also get the system date by using the static method Calendar.getInstance()

The most noteworthy methods are:

• void add(int field, int amount)

  adds (or subtracts, depending on the sign of the operand) time to a date

• boolean after(Object when)

  checks to see if the date is later than the one supplied as a parameter

• boolean before(Object when)

  checks to see if the date is previous to the one supplied as a parameter

• int get(int field)

  returns the value of some field of the date, which we specify with the parameter field

• Date getTime()

  converts the type Calendar to Date

• void set(int field, int value)

  change of value of a date field

• void set(int year, int month, int date)

  changes the year, month and day of the date

• void setTime(Date date)

  from a Date, creates a Calendar

import java.util.Calendar;
import Java.util.GregorianCalendar;
import java.text.SimpleDateFormat;

class Example {
     public static void main(String args[]) {
         Calendar gc = new GregorianCalendar(2004, 1, 28); //2-28-2004

         System.out.println("Day" + gc.get(Calendar.DAY_OF_MONTH); //returns 28
         System.out.println("Month" + gc.get(Calendar.MONTH); //returns 1 (February)
         System.out.println("Year" + gc.get(Calendar.YEAR); //returns 2004
         System.out.println("Day of the week" + gc.get(Calendar.DAY_OF_WEEK); //returns 7 (Sunday)
         gc.add(Calendar.DAY_OF_MONTH, 1); //we add one day

         SimpleDateFormat df = new SimpleDateFormat("dd-mm-yyyy"); //we put the format dd-mm-yyyy
         System.out.println(df.format (gc.getTime())); //we will see it on the screen as 29-2-2004
     }
}

Properties

Usually the behavior of applications can change in function of parameters

It is very comfortable to place those settings in the files for the application to the lea as needed

Java has the class Properties that automates this management

Each line in the property file saves a variable and is formatted as:

<name> = <value>

We will use the file called connection.properties which will have the following content:

user=manpower 
pwd=qwerty486intelinside 
ip=192.168.0.48 
machine=larioja.org

To show the use of Properties with the following example:

import java.io.FileInputStream;
import java.util.Properties;

class Example {
     public static void main(String args[]) {
         try {
             FileInputStream in = new FileInputStream("connection.properties");
             Properties props = new Properties();

             props.load(in);
             System.out.println(props.getProperty("user")); //show manpower
             System.out.println(props.getProperty("pwd")); //show qwerty486intelinside
             System.out.println(props.getProperty("ip")); //shows 192.168.0.48
             System.out.println(props.getProperty("machine")); //show larioja.org
         } catch (IOEXception e) {
             System.out.println("I/O error");
         } finally {
            try {
               in.close(); //Close the flow of the connection.properties file
            } catch (IOEXception e) {
               System.out.println("I/O error");
            }
         }
     }
}

Scanner

You can use the class Scanner to read primitive types and Strings using regular expressions

The class Scanner collect the characters typed from the keyboard until you find a delimiter which by default is space

The collected data are converted to different types using the method next<type>(), to collect texts like String we will use only next()

In this way we will be able to collect from the keyboard or other means, the types of data that we need

java.util.Scanner;

class Example {
     public static void main(String args[]) {
         try {
             Scanner sc = new Scanner(System.in);
             int i = sc.nextInt();
 
             System.out.println(i); //shows the integer that we have read by keyboard
         } catch (IOEXception e) {
             System.out.println("I/O error");
         } finally {
            try {
               sc.close(); //Close the flow with the keyboard
            } catch (IOEXception e) {
               System.out.println("I/O error");
            }
         }
     }
}

In the example we have read a int from the keyboard

java.util.Scanner;
java.io.File;

class Example {
     public static void main(String args[]) {
         try {
             Scanner sc = new Scanner(new File ("numbers.txt"));
             long aLong = 0;

             while (sc.hasNextLong()) {
                 aLong = sc.nextLong();
                 System.out.println("% d", aLong); //shows the long we have read from the file
             }
         } catch (IOEXception e) {
             System.out.println("I/O error");
         } finally {
            try {
               sc.close(); //The flow is closed with the file numbers.txt
            } catch (IOEXception e) {
               System.out.println("I/O error");
            }
         }
     }
}

In the example we have read several long from a file called numbers.txt

java.util.Scanner;

class Example {
     public static void main(String args[]) {
         try {
             String input = "Three sad tigers";
             Scanner sc = new Scanner(input);

             while(sc.hasNext()) {
                 System.out.println(sc.next());
             }
         } catch (IOEXception e) {
             System.out.println("I/O error");
         } finally {
            try {
               sc.close(); //Close the flow with the String
            } catch (IOEXception e) {
               System.out.println("I/O error");
            }
         }
     }
}

In the example we read several words from a String

Showing us on screen:

Three
sad
tigers

That is, the words contained in the String, each on one line at a time because we used println to display them on the screen

Threesadtigers

As we can see, if instead, we would have used print the would have shown all on the same line without any delimiter between them

java.util.Scanner;

class Example {
     public static void main(String args[]) {
         try {
             String input = "Three1sad1tigers";
             Scanner sc = new Scanner(input).useDelimiter("\\ s * 1 \\ s *");

             while(sc.hasNext()) {
                 System.out.println(sc.next());
             }
         } catch(IOEXception e) {
             System.out.println("I/O error");
         } finally {
            try {
               sc.close(); //Close the flow with the String
            } catch (IOEXception e) {
               System.out.println("I/O error");
            }
         }
     }
}

In the example we read several words from a String changing the delimiter space by the delimiter 1

To set the new delimiter we use the method useDelimiter and we pass it parameter a string containing a regular expression, in this case \\s*1\\s*

Showing on the screen the same as in the previous example, despite using a different delimiter