Redes IV: Practica y Ejercitación

En esta entrega plantearemos algunos ejercicios para comprender mejor como trabajar con subredes.

1.- Suponiendo que tenemos un Edificio con un Departamento distinto en cada piso, los cuales queremos diferenciar en la delegación de IP. Aunque no sabemos con cuantos dispositivos contamos en cada piso, sabemos que tenemos 7 pisos.

Siguiendo los parámetros del enunciado, debemos crear 7 subredes, con cantidad desconocida de dispositivos. Nos bastará (mientras los dispositivos no sean demasiados), con utilizar una mascara de Clase C 255.255.255.0 a la cual le pediremos tantos bits sea necesario del último octeto como para formar 4 subredes.

Para saber cuantos bits tomaremos prestado debemos traspasar 7 a binario, que sería 111. son 3 bits resignados, con lo cual conseguiríamos 8 subredes.

Nos quedaría de la siguiente manera 11111111.11111111.11111111.11100000, que es igual a 255.255.255.224 ó /27 (porque son 27 los bits utilizados).

Ahora, siguiendo las fórmulas, tendremos (2^5)-2 = 30 IPs disponibles por subred.
La tabla nos queda de la siguiente manera:

Dirección de Red                           Rango de IPs                                                      Dirección de Broadcast

192.168.0.0/27                               192.168.0.1     - 192.168.0.30                            192.168.0.31

192.168.0.32/27                             192.168.0.33   - 192.168.0.62                            192.168.0.63 

192.168.0.64/27                             192.168.0.65   - 192.168.0.94                            192.168.0.95

192.168.0.96/27                             192.168.0.97   - 192.168.0.126                          192.168.0.127

192.168.0.128/27                           192.168.0.129 - 192.168.0.158                          192.168.0.159

192.168.0.160/27                           192.168.0.161 - 192.168.0.190                          192.168.0.191

192.168.0.192/27                           192.168.0.193 - 192.168.0.222                          192.168.0.223

192.168.0.224/27                           192.168.0.225 - 192.168.0.254                          192.168.0.255

2.- Supongamos que tenemos que crear subredes en un call-center que esta dividido en varias áreas no mayor a 20 personas por área. Una vez que llegan a 20 personas se crea una nueva área.
Según los datos que tenemos las subredes van creciendo a medida que mas puestos se suman, pero siempre mantiene un máximo de 20 dispositivos.
Ahora, siguiendo la conversión, 20 en binario sería 10100, son 5 bits, por lo cual quedarían solo 3 bits para subredes 2^3= 8 y usando los 5 bits conseguiríamos (2^5)-2=30 IPs disponibles por rango.
La tabla de subredes quedaría de la siguiente forma:

Dirección de Red                           Rango de IPs                                                      Dirección de Broadcast

192.168.0.0/27                               192.168.0.1     - 192.168.0.30                            192.168.0.31

192.168.0.32/27                             192.168.0.33   - 192.168.0.62                            192.168.0.63 

192.168.0.64/27                             192.168.0.65   - 192.168.0.94                            192.168.0.95

192.168.0.96/27                             192.168.0.97   - 192.168.0.126                          192.168.0.127

192.168.0.128/27                           192.168.0.129 - 192.168.0.158                          192.168.0.159

192.168.0.160/27                           192.168.0.161 - 192.168.0.190                          192.168.0.191

192.168.0.192/27                           192.168.0.193 - 192.168.0.222                          192.168.0.223

192.168.0.224/27                           192.168.0.225 - 192.168.0.254                          192.168.0.255

3.- En este último ejercicio identificaremos la subred a la que pertenece una IP. Supongamos que tenemos la IP 192.168.0.166/29

Y la IP se traslada a 11000000.10101000.00000000.10100110

Teniendo la conversión, debemos poner en cero los bits resignados a host del octeto  de la IP, es decir

10100000

Como resultado, ahora sabemos que la dirección de subred de la IP 192.168.0.167/29 es la 192.168.0.160/29, esa sería su dirección de broadcast.

Redes VI: Subredes

Empezamos con la parte importante y que mas dolores de cabeza traerá.

Antes de avanzar mas, debemos tener algo en claro, el numero de IP, no define la clase en la que se encuentre, de ello se encarga la mascara de red. Es decir, ejemplificando, supongamos que tenemos una IP 192.168.0.1, y a simple vista dirán que es de Clase C, por el rango en el que se encuentra, pues si, el rango se corresponde con la Clase C, pero si tenemos como mascara de red 255.255.0.0 entonces significaría que esta red es de Clase B. Como ven, lo que define la Clase de red es la mascara, mas que el rango de direcciones.
Otra cosa que debemos tener presente es que la primer IP del rango y la última, no son utilizables, ya que la primera es la dirección usada para identificar la subred y la última es la dirección de dominio de broadcast. Por ejemplo, en una red Clase C de rango 192.168.0.X la dirección de identificación de subred es la 192.168.0.0 y la dirección de dominio de broadcast sería la 192.168.0.255, por ende, solo nos quedan 255-2 direcciones asignables.

BIT a BIT
Como dijimos antes, lo que nos identifica la clase de red, es la mascara, y si la mascara define la clase, por lógica también definirá la subred.
Cuando debemos crear una subred, lo primero que tenemos que tener presente, es la cantidad de dispositivos a conectar (suponiendo que no se trata de una red compleja con permisos y accesos por zonas), ya que esto determinara primeramente, la clase en la que nos posicionaremos para empezar a crear las subredes.
Vamos a suponer que estamos en una oficina con 50 dispositivos, divididos en impresoras, computadoras y dispositivos wireless (celulares, tablets, notebooks), y queremos crear una subred por cada tipo de dispositivo. Por la cantidad, podemos ubicarnos tranquilamente en la Clase C que nos permite 255-2 direcciones asignables. Ahora debemos identificar la cantidad de subredes o de dispositivos que debemos conectar (siempre partimos de la cantidad de subredes cuando no conocemos la cantidad de dispositivos que irán en cada subred, o bien, si sabemos cuantos dispositivos tendremos por subred haremos el cálculo desde allí), en este caso tenemos 50 dispositivos pero no sabemos cuantos van en cada subred.
Para crear una subred, debemos tomar el primer octeto destinado a identificación de host y de izquierda a derecha, tomar tantos bits como sea necesario para crear la subredes necesarias. 
Como 3 en binario se escribe 11 solo tomaremos dos bits del octeto, quedándome 6 mas para asignar direcciones.

11111111.11111111.11111111.00000000
Bits ocupados para designar las subredes
Bits restantes para designar a los host.

Con la cantidad de bits identificada, ya podemos formar la mascara de red que tendremos, esos bits que tomamos para identificar las subredes se representaran con 1 correspondientemente. Esto significa que para toda subred tendremos de mascara 255.255.255.192 ya que el último octeto quedaría como 1100000000 que en decimal es 192. 
Con esos dos bits podemos formar hasta 4 subredes, que serían 00, 01, 10 y 11, y como direcciones a host nos quedan (2^6)-2 = 62 IPs asignables.

Las 4 subredes resultantes serían:

Dirección de Red                           Rango de IPs                                                      Dirección de Broadcast
192.168.0.0/26                               192.168.0.1     - 192.168.0.62                            192.168.0.63
192.168.0.64/26                             192.168.0.65   - 192.168.0.126                          192.168.0.127
192.168.0.128/26                           192.168.0.129 - 192.168.0.190                          192.168.0.191
192.168.0.192/26                           192.168.0.193 - 192.168.0.254                          192.168.0.255

No se preocupen si ahora no lo entienden, en la próxima entrega estaremos haciendo practica de todo esto, para poder dejarlo mas claro y les sirva de ejercitación.

Curso de Java Orientado a Web: POO II

POO II

La clase Auto escrita hasta ahora, si bien utiliza la sintaxis de Java, no responde correctamente a algunos conceptos de POO. Por lo tanto, es correcto aclararlos para continuar escribiendo programas Java correctamente.

Estado Interno

Este concepto se refiere a las variables que le pertenecen a los objetos y no son visibles para el resto. 

En Java, se aplica con el modificador private, por ejemplo:

public class Empleado{
    private double sueldo;
}

double es un tipo de dato primitivo de Java que se usa para manipular datos de tipo Decimal.

De esta manera, si creamos dos instancias de Empleado (empleado1 y empleado2), entre ellos no podrian conocer el sueldo del otro.

La Teoria de Objetos nos dice que un objeto no debe modificar directamente los atributos de otro, sino que debemos crear metodos desde las clases que se encarguen de esa modificacion. De tal manera, supongamos que queremos aumentarle el sueldo al empleado. No hacemos asi:

empleado1.sueldo = empleado1.sueldo+ 1000;

Lo que hacemos es presentar desde la clase Empleado un método que permita modificar el sueldo de las instancias. Asi:

public class Empleado {
    private double sueldo;
    
    public void AumentarSueldo(double aumento) {
        sueldo = sueldo+aumento;
    }
}

void es un modificador para los metodos que nos permite decir que el mismo no tendra un valor de retorno.

De tal manera, en la instancia empleado1 se modifica el sueldo asi:

empleado1.AumentarSueldo(1000.0)

Por lo tanto, en ProyectoAuto modificaremos la clase Auto. para que los atributos ahora sean privados.

public class Auto {
    private int NumeroDePuertas;
    private int VelocidadMaxima;
    private int CaballosDeFuerza;
    private int VelocidadActual;
    private String Patente;
    private String Modelo;
    private String Marca;
    private String Origen;
    private String Estado;
    private String Color;


    String Prender(){
        Estado = "Prendido";
        return "Auto Encendido";
    }

    String Acelerar(int Aceleracion){
        VelocidadActual = VelocidadActual + Aceleracion;
        return "El auto se encuentra a: "+ VelocidadActual;
    }
}

Guardamos con Ctrl + S y vamos a la clase Main, vemos muchos errores del tipo "Color has private access in Auto". Debemos entonces, declarar metodos para inicializar los valores. Pero recuerden: tenemos que hacerlo en la clase Auto.

En la clase Auto vamos a Code ==> Generate...  y seleccionamos Getters and Setters. Seleccionamos todas las variables y damos a Ok.

public class Auto {
    private int NumeroDePuertas;
    private int VelocidadMaxima;
    private int CaballosDeFuerza;
    private int VelocidadActual;
    private String Patente;
    private String Modelo;
    private String Marca;
    private String Origen;
    private String Estado;
    private String Color;


    public int getNumeroDePuertas() {
        return NumeroDePuertas;
    }

    public void setNumeroDePuertas(int numeroDePuertas) {
        NumeroDePuertas = numeroDePuertas;
    }

    public int getVelocidadMaxima() {
        return VelocidadMaxima;
    }

    public void setVelocidadMaxima(int velocidadMaxima) {
        VelocidadMaxima = velocidadMaxima;
    }

    public int getCaballosDeFuerza() {
        return CaballosDeFuerza;
    }

    public void setCaballosDeFuerza(int caballosDeFuerza) {
        CaballosDeFuerza = caballosDeFuerza;
    }

    public int getVelocidadActual() {
        return VelocidadActual;
    }

    public void setVelocidadActual(int velocidadActual) {
        VelocidadActual = velocidadActual;
    }

    public String getPatente() {
        return Patente;
    }

    public void setPatente(String patente) {
        Patente = patente;
    }

    public String getModelo() {
        return Modelo;
    }

    public void setModelo(String modelo) {
        Modelo = modelo;
    }

    public String getMarca() {
        return Marca;
    }

    public void setMarca(String marca) {
        Marca = marca;
    }

    public String getOrigen() {
        return Origen;
    }

    public void setOrigen(String origen) {
        Origen = origen;
    }

    public String getEstado() {
        return Estado;
    }

    public void setEstado(String estado) {
        Estado = estado;
    }

    public String getColor() {
        return Color;
    }

    public void setColor(String color) {
        Color = color;
    }

    String Prender(){
        Estado = "Prendido";

        return "Auto Encendido";
    }

    String Acelerar(int Aceleracion){
        VelocidadActual = VelocidadActual + Aceleracion;
        return "El auto se encuentra a: "+ VelocidadActual;
    }
}

Entonces, para darle valores a los objetos debemos usar los metodos Setter y para Consultar los valores debemos usar los metodos Getter. Por ejemplo, para "settear" el color del objeto Gol1 a "Rojo" usaremos la siguiente sintaxis:

Gol1.setColor("Rojo");

Y para consultar el color, usaremos:

Gol1.getColor();

Reemplacen como corresponda en Main.java.

public class Main {
    public static void main(String[] args){
        Auto Gol1 = new Auto();
        Gol1.setColor( "Rojo");
        Gol1.setPatente( "AXT 100011");
        Gol1.setNumeroDePuertas( 5);
        Gol1.setVelocidadMaxima(185);
        Gol1.setCaballosDeFuerza(75);
        Gol1.setModelo("Gol");
        Gol1.setMarca("VolksWagen");
        Gol1.setOrigen("Brasil");
        Gol1.setVelocidadActual(0);
        Gol1.setEstado("Apagado");

        System.out.println(Gol1.Prender());
        System.out.println(Gol1.Acelerar(20));
    }

}

Guardamos con Ctrl + S y Damos en Run ==> Run Main.

Obtendremos el mismo resultado que antes. Pero ahora estamos respetando un poco más el Paradigma de Objetos.

Curso de Java Orientado a Web: Creando Instancias

Crear Instancia Gol1

Recordemos que tenemos esta Clase Auto:

public class Auto {
    int NumeroDePuertas;
    int VelocidadMaxima;
    int CaballosDeFuerza;
    int VelocidadActual;
    String Patente;
    String Modelo;
    String Marca;
    String Origen;
    String Estado;

    String Color;

    String Prender(){
        Estado = "Prendido";
        return "Auto Encendido";
    }

    String Acelerar(int Aceleracion){
        VelocidadActual = VelocidadActual + Aceleracion;
        return "El auto se encuentra a: "+ VelocidadActual;
    }
}

Hecha en base a lo planteado a continuacion:

Queda crear la instancia Gol1 de la clase Auto. Para ello vamos a crear en la carpeta src una clase Main que contendrá justamente el metodo main.

La sintaxis de Java para crear una instancia de una clase es la siguiente:

Clase instancia = new Clase();

Donde Clase es el nombre de la clase a la que pertenece el objeto, instancia es el nombre de la variable o instancia y Clase() es el método constructor vacio. Este tema lo veremos en el siguiente Capitulo.

En el caso de la instancia Gol1 de la clase Auto se escribe asi:

Auto Gol1 = new Auto();

Entonces el archivo Main.java

public class Main {
    public static void main(String[] args){
        Auto Gol1 = new Auto();

    }
}

Ahora, para ir modificando los valores del objeto, por ejemplo, el color, debemos usar la siguiente sintaxis:

Objeto.atributo = valor;

Entonces, para modificarle el color usamos:

Gol1.Color = "Rojo";

Seguimos modificando el objeto para que quede como necesitabamos:

public class Main {
    public static void main(String[] args){
        Auto Gol1 = new Auto();
        Gol1.Color = "Rojo";
        Gol1.Patente = "AXT 100011";
        Gol1.NumeroDePuertas = 5;
        Gol1.VelocidadMaxima=185;
        Gol1.CaballosDeFuerza=75;
        Gol1.Modelo="Gol";
        Gol1.Marca="VolksWagen";
        Gol1.Origen="Brasil";
        Gol1.VelocidadActual=0;
        Gol1.Estado="Apagado";
        
    }
}

Por ultimo hagamos el llamado a los metodos del objeto. Usando una sintaxis similar:

Objeto.Metodo();

Entonces, Llamamos a los metodos Prender y Acelerar (con 20 de aceleracion) y luego lo imprimimos por consola, enviandolo como parametro en el metodo println().

public class Main {
    public static void main(String[] args){
        Auto Gol1 = new Auto();
        Gol1.Color = "Rojo";
        Gol1.Patente = "AXT 100011";
        Gol1.NumeroDePuertas = 5;
        Gol1.VelocidadMaxima=185;
        Gol1.CaballosDeFuerza=75;
        Gol1.Modelo="Gol";
        Gol1.Marca="VolksWagen";
        Gol1.Origen="Brasil";
        Gol1.VelocidadActual=0;
        Gol1.Estado="Apagado";

        System.out.println(Gol1.Prender());
        System.out.println(Gol1.Acelerar(20));
    }

}

Tiempo de Correr el programa! Por si las dudas, vayan a File ==> Save All o apreten Ctrl + S. Luego vayan a Run ==> Run Main.

Ahora vamos a pasar a explicar unos conceptos importantes de POO.

Curso de Java Orientado a Web: Clase Auto

Clase Auto

Ahora vamos a crear nuestra primer clase. En el capitulo anterior vimos como abstraer de la realidad el concepto de objeto al paradigma POO. Si no tienes idea de lo que hablo, te invito a que revices el capitulo anterior.

Vamos a usar esta imagen como base: 

En el IntelliJ Creen un nuevo proyecto llamado "ProyectoAuto". (File ==> New ==> Project) 

En src creen una nueva clase llamada Auto. 

No voy a dedicar un apartado especial a los tipos de variables o propiedades, ya que son muchisimos. Lo importante es saber que hay algunos tipos nativos y muchas clases que usaremos como tipos, pero que no son mas que instancias de clases.

Un ejemplo de tipo de dato nativo es el int para variables enteras. Por otro lado para cadenas de texto usaremos instancias de la clase String.

Entonces, agreguemos las propiedades relacionadas con numeros primero:

public class Auto {
    int NumeroDePuertas;
    int VelocidadMaxima;
    int CaballosDeFuerza;
    int VelocidadActual;
}

¿Qué estamos haciendo en verdad? Estamos declarando los espacios de la clase. Es como si hiciéramos una plantilla que rellenaremos en cada caso particular. Por ahora, solo estamos creando campos en esa plantilla general.

Sigamos. Vamos a agregar el resto de las propiedades, que son de tipo Cadena de Texto o String.

public class Auto {
    int NumeroDePuertas;
    int VelocidadMaxima;
    int CaballosDeFuerza;
    int VelocidadActual;
    String Patente;
    String Modelo;
    String Marca;
    String Origen;
    String Estado;
}

Si tenes experiencia en Programacion quizas te incomode el tipo de variable que es Estado. Si sabes cambiarla convenientemente, adelante. Sino, espera que ya lo haremos.

Ya tenemos todos los atributos de la clase agregados. Ahora vamos a crear algunos métodos.

Para crear un método de una clase se necesita tener en claro:
* Tipo de Dato de Salida
* Datos de Entrada (Con sus respectivos tipos)
* Nombre del método

Vamos despacio con el primer ejemplo: Prender. Esta accion modificará la variable interna del objeto llamada "Estado", cambiandola de "Apagado" a "Prendido". Entonces queda claro que no hay ningun dato de entrada, pero devolveremos un mensaje diciendo "Auto encendido", que es un dato de salida de tipo String.

Entonces: No entra ningun dato, se procesa el encendido y se devuelve un String.

En codigo Java esto seria:

String Prender(){
        return "Auto Encendido";
}

"return"  es la sentencia utilizada en java para aclarar que va a devolver lo que le especifiquemos a la derecha. Luego veremos que existe la posibilidad de no retornar nada.
Por ahora el metodo no modifica nada. Hagamos que sí modifique el Estado del objeto.

String Prender(){
        Estado = "Prendido";
        return "Auto Encendido";
}

Aclaracion: esta no es la forma perfecta de escribir un método. Pero estamos yendo despacio, dentro de las posibilidades del lenguaje.

Metodo Acelerar:
En este método necesitaremos que se especifique cuanto acelerar el objeto. A partir de ese numero se le sumará a la VelocidadActual la Aceleracion y devolverá un mensaje diciendo "El Auto se encuentra a" (VelocidadActual).

Entonces: Recibe un int aceleracion , Procesa la VelocidadActual sumandole la aceleracion y retorna un String.

Hagamoslo en codigo Java:

String Acelerar(int Aceleracion){
        VelocidadActual = VelocidadActual + Aceleracion;
        return "El auto se encuentra a: "+ VelocidadActual;
}

Si miramos dentro del parentesis, "int Aceleracion" es la forma de especificar que el método aceptará un parametro de tipo entero, que dentro del mismo lo llamaremos "Aceleracion". Esto no significa que la variable a enviar tenga que llamarse así, solo es una declaracion y usamos nombres adecuados para poder entender el codigo, ya que, no debemos olvidarnos que el objetivo de Java junto con Poo es abstraer la realidad. Parte de la abstraccion es utilizar nombres de variables utiles.

Luego veremos que aceptaremos más de un parametro, de distintos tipos.

En la segunda linea vemos una suma. Lo que hace el programa es Asignarle a la variable VelocidadActual el valor que se encuentre en VelocidadActual y sumarle el parametro Aceleracion.
Vale la aclaracion que Java inicializa los enteros en Cero (0).

Finalmente tenemos la clase Auto.java (Que compilada resultará en la clase Auto.class) escrita de la siguiente manera :

public class Auto {
    int NumeroDePuertas;
    int VelocidadMaxima;
    int CaballosDeFuerza;
    int VelocidadActual;
    String Patente;
    String Modelo;
    String Marca;
    String Origen;
    String Estado;
    String Color

    String Prender(){
        Estado = "Prendido";
        return "Auto Encendido";
    }

    String Acelerar(int Aceleracion){
        VelocidadActual = VelocidadActual + Aceleracion;
        return "El auto se encuentra a: "+ VelocidadActual;
    }
}

En el proximo capitulo veremos como crear el objeto o instancia Gol1.

Curso de Java Orientado a Web: Poo

POO

Poo hace referencia a las siglas de Programación Orientada a Objetos. 

Java es un lenguaje orientado a Objetos. Básicamente podemos decir que todo en Java es un Objeto. 

Si ya estás naturalizado con el paradigma, sáltate esta explicación. Pero si no es el caso, te invito a mirar esta pequeña introducción y a continuar investigando en internet. 

POO es un Paradigma de programación. Un paradigma es algo que "no se discute" y usaremos como base para construir el resto. Los conceptos aportados por el paradigma, las reglas y restricciones no deben ser cuestionadas (O al menos dentro de lo posible).

Si vienes del paradigma funcional (con lenguajes del estilo de C), estas acostumbrado a las funciones. Las funciones son porciones de código reutilizables, que utilizan entradas para procesarlas y obtener salidas. 

Es fácil hacer una vinculación con las funciones que vemos en matemáticas, pero con menos restricciones... podemos hacer que tengan varias salidas, varias entradas, que estén anidadas, etc.

El cambio de mentalidad con Objetos es el siguiente: Los objetos manipulan sus propios datos e interactúan con otros para ser modificados o alterarlos de forma indirecta. De igual manera interactúan entre ellos para obtener información.

El paradigma de Objetos sirve debido a la posibilidad de abstraer la realidad a bloques de código.

Vamos de a poco...

Un objeto es una Instancia de una clase. Tienen Propiedades, métodos e identidades.

Una clase es lo más parecido a una plantilla donde se rellenan los datos propios de la instancia.

Una propiedad es un atributo que tiene un objeto en el caso particular del mismo. Estas propiedades son "variables" del programa, pero asociadas al objeto en sí. Los nombres suelen ser sustantivos o adjetivos.

Un método es una acción que puede ejercer el objeto. Se puede hacer una relación con las Funciones del paradigma funcional. Los nombres suelen ser verbos.

La identidad es una propiedad que permite diferenciar al objeto del resto de su misma clase.

Un ejemplo para ir entendiendo un poco mas.

Vamos con un ejemplo bastante típico: La clase Auto.

Un auto tiene un numero de patente que lo diferencia del resto, ese será su identificador (id). También tiene otras propiedades en común con el resto de los autos: tiene un Color, un NumeroDePuertas, VelocidadMaxima, CaballosDeFuerza, Modelo, Marca, PaisDeOrigen, VelocidadActual, Estado (Prendido o Apagado)... solo por enumerar unas pocas.

Bien, también un auto puede ejercer ciertas acciones que modifican el entorno en el que se encuentra o a si mismo. Por ejemplo, para ir de un lado al otro debe Acelerar. Si hay que usarlo, se debe poder Prender.

Ya con esto podemos hacer una clase. Parece poco, pero es bastante. El desafío en POO es saber abstraer la realidad (En este caso, un Auto) y llevarlo a código de la manera mas intuitiva posible. 

Ya analizamos la clase Auto y en la siguiente parte veremos como llevarla a código Java. Pero antes terminemos de entender Poo. 

Con la clase lista, podemos crear instancias de la misma u objetos. Por ejemplo el objeto Gol1 de la clase Auto. 

Un gol tiene 5 puertas, una velocidad máxima de 185km/h, 75 caballos de fuerza y es fabricado en Brasil.

Nuestra instancia Gol1 tendrá una patente "AXT 100011", será de color Rojo y, en un principio, estará apagado y quieto. 

Por ultimo vale aclarar que la instancia tendrá los métodos (acciones) Prender y Acelerar.

Aquí una imagen resumiendo: 

Curso de Java Orientado a Web: Hola Mundo

Hola Mundo

A la hora de aprender un lenguaje de programación, algo Básico, Necesario, Útil e Interesante es afrontar el desafío "Hola Mundo". Es decir, de la manera más simple posible, usando las herramientas más básicas que nos aporta la tecnología, lograr iniciar un programa y emitir un mensaje diciendo "Hola, Mundo". En Java en particular este desafío es considerablemente difícil, debido que conlleva entender conceptos complejos. 

Vamos paso a paso. 

Primero, vamos a crear un nuevo proyecto Java en IntelliJ (File ==> New ==> Project)

Aquí es donde van a tener que especificar el Jdk instalado. En mi caso: 

No elegimos ninguna librería ni framework adicional, damos en Next , Next. A continuación, nos pedirá un nombre de proyecto. Convenientemente lo llamaremos "HolaMundo".

Finlizamos con "Finish". 

Si observamos el Explorador del Proyecto a la izquierda, veremos al siguiente estructura:

En .idea veremos archivos de configuración del Ide. 

En External Libreries veremos las librerías de externos como el mismo jdk que incluimos anteriormente.

Por otro lado, en src  es donde crearemos las clases para trabajar. Mas adelante entraremos en detalles.

Por ahora, en src damos click derecho ==> New ==> Java Class.

Les generará el fichero HolaMundo.java. Borren el contenido del mismo y peguen lo siguiente: 

public class HolaMundo{

    public static void main(String[] args) {
        // Imprime "Hola, Mundo!" en la consola del Ide.
        System.out.println("Hola, Mundo!");
    }

}

Este es el momento de un "Mas despacio, cerebrito" necesario.

Voy a explicar este "pequeño" programa Java. Con conceptos en los que luego nos explayaremos.

public: Esto indica que es "visible" para el resto de las clases.
class: Todo codigo en java debe estar dentro de una clase.
HolaMundo: Este es el nombre de la clase.
static: Este modificador indica que no es necesario crear una Instancia de la clase para usarla.
void: Este modificador indica que el metodo no devolverà ningun valor.
main: Nombre del metodo. Este método es importante, debido a que al ejecutar, el programa java siempre empieza por la clase que tiene el método man. En este caso, la clase HolaMundo.
String[] args: Al correr un programa java podemos enviarle parametros que usemos en el programa. Esto es bastante avanzado, pero es necesario colocarlo para que corra el programa.
System.out.println: Es el metodo usado para imprimir en la consola.

Ya comete la maldita naranja!

En la barra de herramientas, buscamos Run ==> Run 'HolaMundo' . Esperamos un poco y este será el resultado: