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