JAVA-NIVEL BASICO

DESARROLLO DE MI CURSO.
Nombre: Cristina Arriaga Castro

6°B Programación
 INTRODUCCIÓN Al CURSO
Aprenderemos en qué consiste programar en Java y
sus conceptos principales, los cuales iremos
desarrollando en éste articulo y a lo largo de todo el
curso de Java del sitio, así que comencemos. Java es
un lenguaje 100% orientado a objetos de alto nivel,
para programar en Java, así sea la aplicación más
básica siempre necesitaremos como mínimo una clase
con el método principal (main). Dado que Java es un
lenguaje de alto nivel, hay muchos conceptos que se
facilitan en comparación a otros lenguajes de
programación, el ejemplo más claro es el manejo de
punteros y gestión de memoria, los cuales son
bastante fáciles en Java (es algo prácticamente
automático) mientras que en C y C++ es un poco más
complicado; sin embargo no todo es bueno, pues su
velocidad disminuye al necesitar de un mayor número
de instrucciones y el programador no tiene control
sobre algunas cosas pero no te preocupes por esto,
Java es un lenguaje bastante usado, extendido y
poderoso.

¡Espero y les pueda ayudar este curso.!

 ENTORNOS DE DESARROLLO
| INSTALACIÓN Y CONFIGURACIÓN DE JAVA.
Cualquiera que sea el editor (IDE) de Java que elijas, no debe
presentarte problema alguno para desarrollar tus aplicaciones. En
mi punto de vista personal, el entorno de desarrollo para Java más
potente es Netbeans, aclaro que es un mero punto de vista
personal y reconozco también que entornos para Java como Eclipse
presentan varias ventajas con respecto a Netbeans, pero bueno,
nada es perfecto y hace parte de nuestras competencias, sabernos
defender con uno o con el otro, tu simplemente para aprender
acomódate con el que más te llame la atención.
Veamos ahora sí, una lista de algunos de los principales editores
(IDE) para Java, en orden de utilidad:

Eclipse:
Eclipse es un entorno de desarrollo integrado de código abierto
multi-plataforma que nos permite entre varias cosas más
desarrollar aplicaciones en Java. Está también abierto a la
posibilidad de instalarle plugins para aumentar sus características y
llevar a cabo tareas más especificas y complejas. Eclipse es también
altamente usado por programadores y es de hecho una
herramienta que deberías saber usar en cualquier momento de tu
vida profesional.
Nota: En el enlace que daré a continuación tendrás varias opciones
para descargar, de todas estas te recomiendo el primer enlace
"Eclipse Standard", que es la versión para Java más simple y tiene
todo lo necesario
TE DEJO EL LINK PARA QUE PUEDAS DESCARGARLO:
https://www.eclipse.org/downloads/

_________________________________________________

Netbeans:
NetBeans es un entorno de desarrollo integrado libre, hecho
principalmente para Java aunque actualmente ofrece también
soporte para muchos otros lenguajes. Netbeans posibilita la
instalación de plugins que permiten aumentar las características
ofrecidas por éste y realizar tareas más complejas. NetBeans IDE es
libre y gratuito sin restricciones de uso.

NetBeans es un proyecto de código abierto muy popular que posee

una gran base de usuarios, una comunidad en constante
crecimiento y por ende gran facilidad al momento de solicitar
ayuda. Sun MicroSystems fundó el proyecto de código abierto
NetBeans en junio de 2000.
Nota: En el enlace que daré a continuación tendrás varias opciones
para descargar (Java SE, Java EE, C/C++, PHP y All). Como podrás
suponer cualquiera de estas (excepto las de C/C++ y PHP) nos son
útiles, así que eres libre de descargar la que desees, sin embargo
como apenas estamos comenzando la versión Java SE, será más que
suficiente para nuestros proyectos.
TE DEJO EL LINK PARA QUE LO INSTALES:
https://netbeans.apache.org/download/index.html

OJO te dejo estos dos ya que son los más sencillos y buenos para
utilizar, a mi parecer ya tu puedes escoger el que desees.
 EJEMPLOS Y CONCEPTOS DE JAVA
Principios de OOP
Si usted viene de un ambiente de programación estructurada, la
proposición de valores de OOP puede que no sea clara todavía.
Después de todo, los atributos de una persona y cualquier lógica
para recuperar (y convertir) sus valores pueden escribirse en C o
COBOL. Esta sección clarifica los beneficios del paradigma OOP al
explicar sus principios distintivos: encapsulamiento, herencia y
polimorfismo.
____________________________________________________
Encapsulamiento
En la plataforma Java, puede usar especificadores de acceso (los
que presentaré más adelante en el tutorial) para variar la
naturaleza de las relaciones de los objetos desde lo público a lo
privado. El acceso público tiene una gran apertura, mientras que el
acceso privado significa que los atributos del objeto son accesibles
solo dentro del objeto mismo.
_______________________________________________________
Herencia
En la programación estructurada, es común copiar una estructura,
darle un nombre nuevo y agregar o modificar los atributos que
hacen que la nueva identidad (por ejemplo, un registro de Cuenta)
sea diferente de su fuente original. Con el tiempo, este abordaje
genera una gran cantidad de códigos duplicados, que pueden crear
problemas de mantenimiento.
 Polimorfismo
El polimorfismo es un concepto más difícil de entender que el
encapsulamiento o la herencia. Básicamente, significa que los
objetos que pertenecen a la misma ramificación de una jerarquía,
cuando se envía el mismo mensaje (es decir, cuando se le indica
que realice lo mismo), pueden manifestar ese comportamiento de
modo diferente.
El polimorfismo es uno de los conceptos más complejos con los que
se encontrará en OOP en la plataforma Java y no dentro del ámbito
de un tutorial introductorio.
 CAPACITACIÓN
|ESTRUCTURA BASICA.
-CONVENCIONES DE LA PROGRAMACIÓN.
-MODIFICADORES

➢ ESTRUCTURA BASICA.
La estructura básica de un programa desarrollado usando Java es
la siguiente:

Estructura de un objeto Java

Recuerde que un objeto es una entidad diferenciada que contiene
atributos y comportamiento. Eso significa que tiene un límite nítido
y un estado y puede realizar actividades cuando se lo piden
correctamente. Cada lenguaje de orientación a objetos tiene reglas
sobre cómo definir un objeto.

En el lenguaje Java, los objetos se definen como se demuestra en el

Listado 1
Listado 1. Definición de objeto

package packageName;
import ClassNameToImport;
accessSpecifier class ClassName {
accessSpecifier dataType variableName [= initialValue];
accessSpecifier ClassName([argumentList]) {
constructorStatement(s)
}
accessSpecifier returnType methodName([argumentList]) {
methodStatement(s)
}
// This is a comment
/* This is a comment too */
/* This is a
multiline
comment */
}
El Listado 1 contiene diversos tipos de construcciones, que he
diferenciado con formato de fuente. Las construcciones que se
muestran en negrita (que encontrará en la lista de palabras
reservadas) son literales. En cualquier definición de objeto, deben
ser exactamente lo que son aquí. Los nombres que le he dado a las
otras construcciones describen los conceptos que representan.
Explicaré todas las construcciones en detalle en el resto de esta
sección.

Nota: En el Listado 1 y algunos otros ejemplos de códigos en esta

sección, los corchetes indican que las construcciones dentro de
ellos no se requieren. Los corchetes en sí (a diferencia de { y }) no
son parte de la sintaxis Java.

CONVENCIONES DE LA PROGRAMACIÓN

Clases- Los nombres de las clases deberían ser sustantivos

utilizando mayúsculas para la primera letra y minúsculas para las
restantes y se pueden mezclar varios sustantivos.
*Class cuentaBancaria*

Interfaces- Los nombres de las interfaces deberían tener la primera

letra mayúscula como en los nombres de clase.
*Intergace Cuenta*

Métodos- Los nombres de los métodos deberían ser verbos del

verbo en minúscula. Se pueden agregar sustantivos con la primera
letra en mayúscula evitar el uso de subrayados.
*Void revisarCuenta( )*
Constantes- Las constantes de tipos de datos primitivos deberían
escribirse completamente en mayúsculas y separadas las palabras
por subraya los constantes de objeto pueden combinar mayúsculas
y minúsculas.
*Final int MX_CREDITO*

Variables- Todaslas variables deberían ser en minúsculas y se

agregan palabras se separaran con una letra mayúscula evitar el
signo $.
*Primer usuario*
las variables deben tener significado de indicar su uso las variables
de una letra deberían evitarse excepto las que suelen usarse en
ciclos para controlarlo.

Otras convenciones de la programación incluyen el uso de llaves *({

})* alrededor de un bloque de instrucciones incluso cuando se trata
de una sola instrucción ya que esto ayuda en el mantenimiento del
programa.
*If (condición)
{
Bloque
}*
El espacio ayuda en la comprensión del programa. Se sugiere
escribir una instrucción por línea y usar identacion de uno o dos
espacios.
Los comentarios también ayudan en la compresión y
mantenimiento del programa al dar descripción clara de lo que
hace cada función y el uso de variables.
EJEMPLO
*// primero programa Java
Public class helloworld
{
Public static Void main(string argv()}
{System.out.println("Hello world");
}
}*
En detalle:
*//Primer programa en Java*
La primera línea es un comentario.
las siguientes dos líneas son la declaración de la clase Que al
momento de ser compilado el programa, se genera un
archivo.class.
Es importante que el nombre de la clase sea el mismo que el
nombre del archivo si la clase se va a llamar hello world el archivo
se se debe llamar helloworld.Java.
en las siguientes líneas se declara el inicio del programa para que el
intérprete de Java puede ejecutar el programa debe tener la misma
sintaxis (excepto para el nombre del parámetro de main)
Se declara público para que lo pueda accesar el intérprete de Java.
Se declara static porque no se ha creado algún objeto y no se crea
una instancia.
Se declara voy porque no se regresa valor alguno.
En este ejemplo no se va a esperar para metro de la línea de
comandos. Finalmente se termina el bloque del método Main y la
declaración de la clase.
Una ves que se tiene el código fuente del archivo helloworld.java se
usa el compilador de Java y de la siguiente manera.
*Javac helloworld.java*
El compilador no regresa mensajes de error se habrá creado un
nuevo archivo hello world.class en el mismo directorio que el
código fuente.

Después de la compilación,se puede ejecutar el programa y ver el

resultado usar el intérprete de Java:
*Java HelloWorld*
Modifica el programa anterior para dejar errores y ver lo que
presenta el compilador.
NOTA: Recuerda que los parámetros que son recibidos en la línea
de comando se guardan en el arreglo de tipo string del método
Main.
Trata reutilizar la propiedad "lenght" el ya mencionado arreglo para
controlar el número de parámetros recibidos.

➢ MODIFICADORES
Los modificadores de acceso nos introducen al concepto de
encapsulamiento. El encapsulamiento busca de alguna forma
controlar el acceso a los datos que conforman un objeto o
instancia, de este modo podríamos decir que una clase y por ende
sus objetos que hacen uso de modificadores de acceso
(especialmente privados) son objetos encapsulados.
Los modificadores de acceso permiten dar un nivel de seguridad
mayor a nuestras aplicaciones restringiendo el acceso a diferentes
atributos, métodos, constructores asegurándonos que el usuario
deba seguir una "ruta" especificada por nosotros para acceder a la
información.

Veamos poco de los modificadores de acceso

______________________________________________________
Modificador de acceso private
El modificador private en Java es el más restrictivo de todos,
básicamente cualquier elemento de una clase que sea privado
puede ser accedido únicamente por la misma clase por nada más.
Es decir, si por ejemplo, un atributo es privado solo puede ser
accedido por lo métodos o constructores de la misma clase.
Ninguna otra clase sin importar la relación que tengan podrá tener
acceso a ellos.
EJEMPLO
package aap.ejemplo1;
public class Ejemplo1
{
private int atributo1;//Este atributo es privado
private int contador = 0; //Contador de registro

//Si un atributo es privado podemos crear método get y set ...

//... para éste y permitir el acceso a él desde otras instancias

public void setAtributo1(int valor)

{
contador++;//Contador que lleva el registro de ediciones del
atributo1
atributo1 = valor;//Establecemos el valor del atributo
}
_______________________________________________________
______
El modificador por defecto (default)
Java nos da la opción de no usar un modificador de acceso y al no
hacerlo, el elemento tendrá un acceso conocido como defaulto
acceso por defecto que permite que tanto la propia clase como las
clases del mismo paquete accedan a dichos componentes (de aquí
la importancia de declararle siempre un paquete a nuestras clases).
EJEMPLO
package aap.ejemplo2;
public class Ejemplo2
{
private static int atributo1;//Este atributo es privado
static int contador = 0; //Contador con acceso por defecto

public static void setAtributo1(int valor)

{
contador++;//Contador que lleva el registro de ediciones del
atributo1
atributo1 = valor;//Establecemos el valor del atributo
}

public static int getAtributo1()

{
return atributo1;//Retornamos el valor actual del atributo
}
}
package aap.ejemplo2;
public class Ejemplo2_1
{
public static int getContador()
{
return Ejemplo2.contador;//Accedemos directamente al contador
desde otra clase
}
}

_______________________________________________________
__
Modificador de acceso protected
El modificador de acceso protected nos permite acceso a los
componentes con dicho modificador desde la misma clase, clases
del mismo paquete y clases que hereden de ella (incluso en
diferentes paquetes). Veamos:

package aap.ejemplo3;

public class Ejemplo3

{
protected static int atributo1;//Atributo protected
private static int atributo2; //Atributo privado
int atributo3;//Atributo por default

public static int getAtributo2()

{
return atributo2;
}
}
_______________________________________________________

A continuación y ya para finalizar, pondré una pequeña tabla que

resume el funcionamiento de los modificadores de acceso en Java.

MODIFICADOR MISMO SUBCLASE OTRO LA MISMA

PAQUETE PAQUETE CLASE
PRIVATE SI NO NO NO
DEFAULT SI SI NO NO
PROTECTED SI SI/NO SI NO
PUBLIC SI SI SI SI
 LENGUAJE
|Inicialización de Variables
|Expresiones Lógicas.

➢ Inicialización de Variables
Inicializar variables en java, significa asignarlas algún valor, ya sea
de tipo númerico, lógico o de otro tipo. Hay que tener en cuenta
donde estan posicionadas dichas variables en el código del
programa, es decir si son miembros de la clase (Están situadas
dentro de una clase, pero fuera de cualquier método que tenga la
clase) ó son variables locales a un método (Están dentro de un
método declaradas).
Podemos inicializar cualquier variable con independencia de donde
este situada, pero para las variables miembros de una clase, nos
podemos ahorrar su inicialización ya que el compilador de java las
inicializa de la siguiente manera:

Las variables númericas las inicializa a 0 .

Las variables de caracteres, las inicializa con \0
Las variables tipo boolean java las inicializa como false.
Las referencias a cadenas de caracteres y a objetos las inicializa con
null.

La siguiente clase «DeclarVariables» declara una serie de variables

unas son miembro de la clase y otras son locales al método que
tiene esa clase llamado «datosPersonales()«.
class DeclarVariables
{
int dia, mes, año;
boolean dato;
byte edad;

public void datosPersonales(){

boolean texto="false";
 String Nombre="", Apellidos="";

/*
*
* Resto del código del método.
*
*/
}
}
Como se puede apreciar, tenemos cinco variables de clase. Las
variables «dia», «mes» , «año» son de tipo int y la variable «edad»
es de tipo byte.
Al ser variables numéricas y tal como hemos dicho antes, serán
inicializadas a «0» de forma automática por el compilador de Java.
La variable «dato» al ser de tipo lógico o boolean, será inicializada
con «false».

Dentro del método datosPersonales() tenemos tres variables

locales, que están obligatoriamente inicializadas, ya que de lo
contrario el compilador nos lo señalaría. La variable de tipo boolean
«texto» esta inicializada como «false» y tenemos dos variables
de tipo String (Este tipo de dato se considera como una clase en
Java.) «nombre» y «apellidos», inicializadas con un espacio en
blanco (» «).
EXPRESIONES LOGICAS:
Los operadores relacionales y logicos regresan a un valor boolean.
en Java no existe conversión automática de int a boolea como en
C++.

Int i = 1:
If (i) // error en tiempo de computación
If ( i ! = 0) // correcto.

ARREGLOS
|Creación e Inicialización
|Ejemplos de Arreglos
➢ CREACIÓN E INICIALIZACIÓN
Creación de Arreglos:
Para crear un arreglo se usa el operador new, el cual reserva un
espacio en memoria. ? nombreArreglo = new tipoDato[tamaño] ?
Ejm: notas = new int[4]; ? Indica que el arreglo estará compuesto
de 4 valores enteros. ? Tanto la declaración y creación de un
arreglo se puede hacer en una sola línea: int notas[] = new int[4];
int[] notas = new int[4]; ? Los elementos se inicializan a cero, false o
null dependiendo del tipo de dato en el momento de su creación
___________________________________________________
Inicialización de Arreglos:
Los valores del arreglo se inicializan utilizando el índice del mismo
entre corchetes: ? Ejm: notas[2]=8; ? Los arreglos se pueden
inicializar con los valores entre llaves {...} se parados por comas, en
la propia declaración. Ejm: ? int notas[]= {8,7,9}; ó también ? int
notas[]= new int[] {8,7,9}; ? Esto significa que el arreglo se
inicializará con los siguientes valores: notas[0]=8, notas[1]=7,
notas[2]=9
_______________________________________________________

EJEMPLOS DE ARREGLOS:
public class vector {
public static void main(String[] args) {
int[] n; //declaracion del tipo de arreglo, en este caso es un
vector.
n = new int[5];//declaración del numero de posiciones que
tendrá el vector.
for (int i = 0; i < 4; i++) { //ciclo para recorrer el vector, desde la
posicion 0 del vector hasta la 4(si cuentas, hay 5 posiciones).
n[i] = i; //asignamos el contenido de la variable i al vector.
System.out.println(n[i]); //se imprime el contenido del
vector.
}
}
}

2do Ejemplo
/* * DESCRIPCIÓN: Programa que al ingresar los numero indica cual
es el mayor, el menor y da la suma de los dos. */

public class vector {

public static void main(String[] args) {

int mayor,menor,suma;
int [] nums={3,4,8,2};//asignamos directamente los valores del
vector
suma=0;
menor=nums[0];
mayor=nums[0];

for(int i=0;i<nums.length;i++){
if (nums[i]>mayor){
mayor=nums[i];
}

if (nums[i]<menor){
 menor=nums[i];
}

suma+=nums[i];
}

System.out.println("El mayor es"+mayor);

System.out.println("El menor es"+menor);
System.out.println("La suma es"+suma);
}
}

3er Ejemplo
/* * DESCRIPCIÓN: Programa que captura las notas de un
estudiante y las promedia */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Notas {

private long codigo;
private String nombre;
double[] notas = new double[3];
private double defi;

Notas(long codigo, String nombre, double[] arreglo) {

this.codigo = codigo;
this.nombre = nombre;
this.notas = arreglo;
this.defi = defi;
}

public long getcodigo() {

return codigo;
}

public double[] getNotas() {

return notas;
}

public String toString() {

 return " Codigo: " + codigo + " Nombre: " + nombre;
}
}

class OperaNotas {

BufferedReader entrada = new BufferedReader(new

InputStreamReader(System.in));
long codigo;
String nombre;
double[] notas = new double[3];
Notas objeto;
int def;
private int total;

public void setEntrarDatos() throws IOException {

System.out.println("Ingrese Codigo: ");

codigo = Integer.parseInt(entrada.readLine());
System.out.println("Ingrese Nombre: ");
nombre = entrada.readLine();
for (int j = 0; j < notas.length; j++) {
 System.out.println("Ingrese la Nota: " + (j + 1) + " ");
notas[j] = Double.parseDouble(entrada.readLine());
}
for (int i = 0; i <= 1; i++) {
for (int j = i + 1; j < 2; j++) {
def = (int) (notas[i]/3);
total = def/3 ;
}
}
objeto = new Notas(codigo, nombre, notas);
}

public void imprimir() {

System.out.println(objeto.toString());
for (int i = 0; i < notas.length; i++) {
System.out.println("Nota " + (i + 1) + " " +
objeto.getNotas()[i]);
}
System.out.println("La Definitiva es:"+total);
}
}

class Test {

public static void main(String[] arg) throws IOException {

OperaNotas n = new OperaNotas();
n.setEntrarDatos();
n.imprimir();

}
}
 CICLOS O BUCLES
Acerca de los bucles o ciclos en Java. Cómo y porqué se usan los
bucles o ciclos en Java.
Los ciclos o también conocidos como bucles, son una estructura de
control de total importancia para el proceso de creación de un
programa. Java y prácticamente todos los lenguajes más populares
de la actualidad nos permiten hacer uso de estas estructuras y
muchas más. Un ciclo en Java o bucle en Java (como prefieras
llamarlo) permite repetir una o varias instrucciones cuantas veces
lo necesitemos o sea necesario, por ejemplo, si quisiéramos escribir
los números del uno al cien no tendría sentido escribir cien líneas
de código mostrando un número en cada una de estas, para eso y
para varias cosas más (que veremos enseguida), es útil un ciclo. Un
ciclo nos ayuda a llevar a cabo una tarea repetitíva en una cantidad
de líneas muy pequeña y de forma prácticamente automática.
Existen diferentes tipos de ciclos o bucles en Java, cada uno tiene
una utilidad para casos específicos y depende de nuestra habilidad
y conocimientos poder determinar en qué momento es bueno usar
alguno de ellos.
_______________________________________________________

CICLO FOR
¿Cómo funciona un Ciclo For?
Para comprender mejor el funcionamiento del ciclo for,
solucionemos un pequeño ejercicio práctico, supongamos que
queremos mostrar los números pares (múltiplos de dos :P) entre el
500 y el 1000. Con esta información inmediatamente podemos
determinar que por medio de un ciclo debemos mostrar una serie
de números como la siguiente: 500 502 504 506 ... 600 ... 852 ...
906 ... 980 .. 1000. Tenemos entonces todo lo necesario para
nuestro ciclo. Tenemos un valor inicial que sería el 500, un valor
final (1000) y tenemos un tamaño de paso que es 2 (los números
pares). Estamos ahora en capacidad de determinar los
componentes esenciales para un ciclo for.
_______________________________________________________
Sintaxis del Ciclo For en Java:
La sintaxis de un ciclo for es simple en Java, en realidad en la
mayoría de los lenguajes de alto nivel es incluso muy similar, de
hecho, con tan solo tener bien claros los 3 componentes del ciclo
for (inicio, final y tamaño de paso) tenemos prácticamente todo
hecho
for(int i = valor inicial; i <= valor final; i = i + paso)
{
....
....
Bloque de Instrucciones....
....
....
}

____________________________________-
Línea 1:
En esta línea está prácticamente todo lo esencial de un ciclo for. La
sintaxis es simple, tenemos una variable de control llamada i que es
tipo entero (int), cabe notar que la variable se puede llamar como
nosotros lo deseemos y puede ser del tipo de queramos también,
sin embargo en la mayoría de los casos se usa la "i" como nombre y
el entero como tipo, pero somos libres de modificar esto a nuestro
gusto. Esta variable "i" se le asigna un valor inicial que puede ser
cualquier número correspondiente al tipo de dato asignado.
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como
seguramente ya sabrás indica que allí comienza el bloque de
instrucciones que se ejecutaran cada vez que el ciclo de un "giro".
Esta llave no es del todo obligatoria, sin embargo si no la ponemos
solo se ejecutara dentro de nuestro ciclo la primera línea
inmediatamente posterior a la declaración del ciclo, de modo que si
deseamos que se ejecuten varias líneas dentro de nuestro ciclo,
debemos usar las llaves

Línea 3 a 7:
En estas líneas es donde estarán todas las operaciones que
queramos llevar a cabo de manera iterativa durante la ejecución
del ciclo, este bloque podrá tener la cantidad de líneas necesarias
incluso, como veremos más adelante dentro de estas podría haber
uno o más ciclos, así que podrías tener todo un programa dentro de
un ciclo.
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}", una vez
más como seguramente ya sabrás esta nos indica que allí termina el
bloque del ciclo for y se dará por terminada la ejecución de este
para continuar ejecutando el resto del algoritmo.

No te preocupes si no comprendiste muy bien lo que acabo de

escribir, estoy seguro que con un par de ejemplos que veremos a
continuación, te va a quedar todo claro.
_________________________________________________

Ejemplos de Ciclo For en Java

Ejemplo 1: Mostrar en pantalla los números pares
Vamos a retomar el ejemplo anterior, donde deseábamos sacar los
números pares entre el numero 500 y el 1000, es un ejemplo
sencillo con el que nos aseguraremos de haber comprendido bien
lo anterior:

Solución Ejemplo 1:

for(int i=500;i<=1000;i+=2)
{//Notemos que escribir i+=2 es similar a escribir i = i + 2
System.out.println(i);
}
El código funcional completo sería el siguiente:
public class CicloFor
{
public static void main(String args[])
{
for(int i=500;i<=1000;i+=2)
{
System.out.println(i);
}
}
}
_______________________________________
Ejemplo 2: Cuenta regresiva en un ciclo for
Ahora veremos otro ejemplo sencillo en cual haremos que el ciclo
for también haga sus iteraciones en sentido inverso, es decir
disminuyendo el valor de la variable de controlvamos a imprimir
por pantalla una cuenta regresiva desde el número 100 hasta el 0,
veamos:

Solución Ejemplo 2:
Para este caso, debido a que queremos ir de un número mayor a
uno más pequeño, por lo tanto para este ejemplo el valor inicial
será 100 y el valor final será 0. Adicional, el tamaño de paso será de
1 negativo, es decir, -1, así:
for(int i = 100; i > 0; i--)
{//Notemos que escribir i-- es lo mismo a escribir i = i - 1
System.out.println(i);
}

El código funcional completo sería el siguiente:

public class CicloInverso
{
public static void main(String args[])
{
for(int i = 100; i > 0; i--)
{
System.out.println(i);
}
}
}
___________________________________________________
 OBJETOS Y CLASES
|CONCEPTOS Y EJEMPLOS

¿Qué son las clases en Java?

Una clase en Java se puede entender como un prototipo que define
las variables y los métodos comunes a un cierto tipo de instancias,
una clase define todo lo que caracteriza y pueden hacer una o
varias instancias.

En nuestro ejemplo de la fábrica de galletas, la clase sería uno de

los moldes para galletas, junto con los métodos para colorearlas y
la receta (método para prepararlas). Quiere decir que en nuestro
programa de Java tendremos una manera de especificar las
características de la galleta dado que hay diferentes moldes de
galletas.

En java las clases son las matrices de las que luego se pueden crear
múltiples instancias del mismo tipo. La clase define las variables y
los métodos comunes a las instancias de ese tipo (el tipo de la clase
creada), pero luego, cada instancia de esta clase tendrá sus propios
valores (su propio molde, color y receta) y compartirán las mismas
funciones.
En java, primero deberemos crear una clase antes de poder crear
instancias o ejemplares de esa clase. Evidentemente primero
necesitamos los moldes y demás para poder hacer las galletas.

¿Qué son los objetos en Java?

En Java, un objeto es básicamente una instancia de una clase (las
instancias de las que hablábamos hace un momento). Para el
ejemplo de la fábrica de galletas, los objetos vendrían siendo cada
una de las diferentes galletas obtenidas de los moldes definidos
(clases), creados por medio de un proceso o "constructor" de
galletas.

Muy bien, ya hemos hecho un repaso sobre el concepto de clase y

objeto en Java, sin embargo aún no sabemos cómo crearlos ni
usarlos, así que vamos a ello.

¿Cómo crear una clase en Java?

Como dije anteriormente la clase es la que nos dice los
componentes del ejemplar que vamos a crear, es decir, una clase
contiene los atributos y los métodos que conformarán al ejemplar o
instancias, de este modo al momento de crear una clase en Java,
debemos especificar el tipo y el nombre (como mínimo) de los
atributos y adicionalmente debemos especificar (si existen) los
métodos o funciones, el tipo de dato que retornan, el nombre y los
parámetros que reciben dichos métodos.
Veamos la estructura básica de una clase en Java y luego veamos
unos ejemplos de clases en java un poco más complejos e
ilustrativos.

Estructura básica de una clase en Java

//Le damos un nombre "MiClase" a la clase

public class MiClase
{
//Atributos de la clase
private String atributo1;
private int atributo 2;
private float atributo 3;

//Constructor con el mismo nombre de la clase

public MiClase(){}

//Métodos de la clase
public void metodo1()
{
//Método vacio
}
 public String metodo2()
{
return "metodo2";
}
}

En el ejemplo anterior hemos creado una clase en Java llamada

"MiClase" la cual posee un total de tres atributos (todos ellos
privados) y son de tipo String, int y float respectivamente.
Adicionalmente esta clase tiene un constructor (que siempre por
norma, debe tener el mismo nombre de la clase) el cual no recibe
ningún parámetro, aunque pueden recibir todos los parámetros
que nosotros deseemos, también tiene un método llamado
"metodo1" que no retorna valor alguno (es de tipo void) y otro
método llamado "metodo2" que retorna una cadena de caracteres
(es de tipo String) con el valor "metodo2". Cabe resaltar que una
clase en Java puede tener o no métodos y atributos, sin embargo lo
más normal en la mayoría de los casos es que tenga tanto métodos
como atributos que la caractericen.

Veamos ahora un ejemplo un poco más completo e ilustrativo.

Ejemplo de clases en Java

package misClases; //Se le declara un paquete

public class Animal
{
private String raza;
private String nombre;
private int edad;

public Animal(String nuevoNombre)

{
nombre = nuevoNombre; //Se le da un nombre al animal
}

//Método para obtener la edad del animal

public int getEdad()
{
return edad;
}

//Método para establecer la edad del animal

public void setEdad(int nuevaEdad)
{
edad = nuevaEdad;
 }

//Método para obtener el nombre del animal

public String getNombre()
{
return nombre;
}
}

La clase Java que hemos creado para este ejemplo tiene como
nombre "Animal", pertenece al paquete "misClases" y posee los
atributos raza, nombre y edad, adicionalmente tenemos un
constructor que recibe un nombre y se lo asigna al animal y tres
métodos encargados de obtener y establecer la edad del animal y
el restante para obtener el nombre.

Objetos en Java
Muy bien, ya hemos aprendido a la perfección cómo crear clases en
java, y cuáles son sus componentes esenciales, ahora vamos a
aprender a crear objetos en Java, cómo se hace, veremos
brevemente la utilidad y funcionamiento de los constructores y
como usar los métodos

¿Cómo crear objetos en Java?

Al momento de crear objetos en Java, debemos tener claras dos
cosas indispensables, la primera es el nombre de la clase para la
cual vamos a crear el objeto y segundo el constructor que dicha
clase posee, es decir, si el constructor recibe o no parámetros.

Para crear objetos en Java, el lenguaje nos proporciona el comando

new, con este comando le decimos a Java que vamos a crear un
nuevo objeto de una clase en especifico y le enviamos los
parámetros (en caso de ser necesario) según el constructor,
veamos un ejemplo.

Ejemplo de objetos en java

Vamos a crear un objeto o instancia en Java para la clase que
hemos creado al comienzo llamada MiClase. Esta clase tiene un
constructor que no recibe parámetros, por lo cual no es necesario
enviar algún tipo de valor al momento de crear el objeto, veamos
entonces la sintaxis para crear un objeto del tipo MiClase en java.

MiClase miObjeto; //Declaramos una variable del tipo de la clase

miObjeto = new MiClase(); //Aquí ya hemos creado un objeto de
MiClase

Otra forma de hacer y que también es válida es la siguiente:

MiClase miObjeto = new MiClase(); //Declaramos y creamos el

objeto en una línea
Ejemplo 2 de objetos en Java
Vamos ahora a crear un objeto o instancia para la clase Animal (la
del ejemplo dos), en esta ocasión tenemos un constructor que
recibe un parámetro (el nombre del animal) y que posee tres
métodos de los cuales haremos uso para este ejemplo.

import misClases.Animal; //Importamos la clase Animal para poder

usarla

public class Ejemplo

{
public static void main(String[] args)
{
//Creamos un animal cuyo nombré será Falco
Animal miAnimal = new Animal("Falco");
//Le establecemos 3 años de edad a Falco.
miAnimal.setEdad(3);
//Mostraremos el nombre del animal por pantalla
System.out.println("El nombre es: " + miAnimal.getNombre());
//Mostramos la edad del animal por pantalla
System.out.println(" y tiene " + miAnimal.getEdad() + " años");
//Este código deberia imprimir "El nombre es: Falco y tiene 3
años"
 }
}
Nota: Es importante notar que es similar hacer uso de método set
para establecer atributos y usar el constructor enviandole
parámetros, es decir, el resultado es el mismo al usar un
constructor vacío y luego establecer los valores de los atributos por
medio de una función set o usar un constructor que reciba una
serie de parámetros que usará para establecer valores a los
atributos. La diferencia radica esencialmente en la agilidad y
número de líneas, al usar el constructor y enviar los parámetros, el
constructor hace todas las asignaciones por nosotros y usamos una
sola línea de código (normalmente) mientras que al usar métodos
set debemos usar un método set por cada atributo y si tenemos
cinco o más atributos ya se vuelve un poco molesto hacerlo además
de tener que usar un constructor de todas formas. Veamos un
corto ejemplo para estar más claros.
 OPERADORES EN JAVA
Operadores Aritméticos: Los habituales

Suma + .
Resta - .
Multiplicación * .
División / .
Resto de la División % .

Operadores de Asignación: El principal es '=' pero hay más

operadores de asignación con distintas funciones que explicamos
brevemente ahora.
'+=' : op1 += op2 à op1 = op1 + op2
'-=' : op1 -= op2 à op1 = op1 - op2
'*=' : op1 *= op2 à op1 = op1 * op2
'/=' : op1 /= op2 à op1 = op1 / op2
'%=' : op1 %= op2 à op1 = op1 % op2

Operadores Unarios: El mas (+) y el menos (-). Para cambiar el

signo del operando.
Operador Instanceof: Nos permite saber si un objeto pertenece a
una clase o no.
NombreObjeto instanceof NombreClase

Operadores Incrementales: Son los operadores que nos permiten

incrementar las variables en una unidad. Se pueden usar delante y
detrás de la variable dependiendo de lo que queramos, es decir, si
queremos que incremente o viceversa antes de utilizar o lo
contrario.
'++'
'--'
Operadores Relacionales: Permiten comparar variables según
relación de igualdad/desigualdad o relacción mayor/menor.
Devuelven siempre un valor boolean.
'>': Mayor que
'<': Menor que
'==': Iguales
'¡=': Distintos
'>=': Mayor o igual que
'<=': Menor o igual que

Operadores Lógicos: Nos permiten construir expresiones lógicas.

'&&' : devuelve true si ambos operandos son true.
'||' : devuelve true si alguno de los operandos son true.
'!' : Niega el operando que se le pasa.
'&' : devuelve true si ambos operandos son true, evaluándolos
ambos.
'|' : devuelve true uno de los operandos es true, evaluándolos
ambos.

Operador de concatenación con cadena de caracteres '+':

Por Ejemplo: System.out.println("El total es"+ result +"unidades");

Operadores que actúan a nivel de bits: Son mucho menos

utilizados por eso los explicamos mas por encima.
'>>': desplazamiento a la derecha de los bits del operando
'<<': desplazamiento a la izquierda de los bits de operando
'&': operador and a nivel de bit.
'|': operador or a nivel de bit.
 FLUJOS DE ENTRADA Y SALIDA

¿QUÉ ES UN FLUJO O STREAM?

La entrada (input) y salida (output) en java se implementa en el
paquete java.io
En términos de programación se denomina entrada a la posibilidad
de introducir datos hacia un programa; salida sería la capacidad de
un programa de mostrar información al usuario.
La E/S en java se basa en el concepto de flujo o denominado
STREAM.
El flujo es una secuencia ordenada de datos que tiene una fuente
(flujos de entrada) o un destino (flujos de salida).

Los streams soportan varios tipos de datos:

Bytes simples, tipos de datos primitivos, caracteres localizados, y
objetos

Los Streams se caracterizan por se unidireccionales, es decir que

unStream se utilizara solo para leer, solo para escribir, pero no
ambas acciones al mismo tiempo.
En Java se accede a la E/S estándar a través de campos estáticos de
la clase java.lang.System
System.in implementa la entrada estándar
System.out implementa la salida estándar
System.erry implementa la salida de erry

TIPOS DE STREAMS

La API de Java diferencia entre los streams de caracteres y streams

de bytes.
Streams de bytes (InputStream y OutputStream)
Los Streams de Bytes como su nombre lo indica trabaja con bytes.
Los bytes a leer se leeran en forma unitaria(es decir 8 bits por byte).
Son utilizados para leer y escribir información que esta almacenada
en forma binaria, como por ejemplo archivos.

La Superclase utilizada para leer streams orientados a byte es la

clase InputStream. A partir de esta clase - la cual es abstracta –
heredan todas las clases concretas que se utilizan para leer
información en forma binaria.

La superclase utilizada para escribir streams orientados a bytes es

la clase OutputStream. A partir de esta clase - la cual es abstracta –
heredan todas las clases concretas que se utilizan para escribir
información en forma binaria.

_______________________________________________________
Streams de caracteres (Reader y Writer):
Los Streams de caracteres operan con caracteres como unidad de
trabajo. Los caracteres a leer están formados por 2 bytes(es decir
16 bits por carácter).

Son utilizados para leer y escribir información que esta almacenada

en forma de texto, como por ejemplo archivos.

La Superclase utilizada para leer streams orientados a carácter es la

clase Reader. A partir de esta clase - la cual es abstracta – heredan
todas las clases concretas que se utilizan para leer información en
forma textual.
La Superclase utilizada para escribir streams orientados a carácter
es la clase Writer. A partir de esta clase - la cual es abstracta –
heredan todas las clases concretas que se utilizan para escribir
información en forma textual.
 LECTURA DE DATOS EN JAVA

Lectura de datos por teclado en Java. Scanner y BufferedReader

La entrada o lectura de datos en Java es uno de los conceptos más
importantes y fundamentales al momento de interactuar con el
usuario de nuestro programa. La entrada de datos en Java, a
diferencia de otros lenguajes es un poco complicada (no
demasiado) y existen diferentes formas de hacerlo, unas más
complejas que otras. En esta sección veremos dos maneras
sencillas de leer datos para nuestro programa en Java, veremos
entonces dos formas de leer datos del usuario por teclado. La
primera usando las clases BufferedReader y InputStreamReader
ambas de la librería java.io y la segunda con la clase Scanner de la
librería java.util.

Comencemos entonces nuestros ejemplos para la lectura por

teclado en Java usando la clase BufferedReader y
InputStreamReader.
La entrada de datos con estas dos clases se puede hacer un menos
de tres líneas según lo que necesitemos hacer, veremos cómo leer
números y texto y las particularidades de ambos casos al usar estas
clases.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class EntradaJava

{
public static void main(String[] args) throws IOException
{
//Notar que readLine() nos obliga a declarar IOException
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in)); //Ya tenemos el "lector"

System.out.println("Por favor ingrese su nombre");//Se pide un

dato al usuario

String nombre = br.readLine(); //Se lee el nombre con

readLine() que retorna un String con el dato

System.out.println("Bienvenido " + nombre + ". Por favor

ingrese su edad");//Se pide otro dato al usuario

String entrada = br.readLine(); //Se guarda la entrada (edad) en

una variable

//Nótese que readLine siempre retorna String y la clase

BufferedReader...
 //no tiene un método para leer enteros, así que debemos
convertirlo.

int edad = Integer.parseInt(entrada);//Se transforma la entrada

anterior en un entero
//Si el usuario ingresó solo números funcionará bien, de lo
contrario generará una excepción

System.out.println("Gracias " + nombre + " en 10 años usted

tendrá " + (edad + 10) + " años."); //Operacion numerica con la
edad
}
}
Como pudimos ver en el código anterior, ha sido bastante sencillo
obtener la entrada del usuario y almacenar ese valor en una
variable. El único "problema" es que BufferedReader únicamente
posee el método readLine() para leer la entrada y este siempre
retorna String, de modo que para obtener un número debemos leer
primero como String y luego enviarle dicho String al método
parseInt() de la clase Integer. Hay que ser muy cuidadosos con
Integer.parseInt() pues si el usuario no ingreso un número sino
letras, se disparará una excepción que debemos controlar (más
adelante veremos esto con detalle).

Lectura de entrada por teclado usando la clase Scanner

La clase Scanner de la librería java.util es también muy sencilla para
obtener datos de entrada del usuario, a diferencia de
BufferedReader, Scanner si posee un método para la lectura de
números y para la lectura de texto que nos ayudarán a facilitar un
poco las cosas, veamos:

import java.util.Scanner;

public class EntradaJava2

{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in); //Se crea el lector

System.out.println("Por favor ingrese su nombre");//Se pide un

dato al usuario

String nombre = sc.nextLine(); //Se lee el nombre con

nextLine() que retorna un String con el dato

System.out.println("Bienvenido " + nombre + ". Por favor

ingrese su edad");//Se pide otro dato al usuario
 int edad = sc.nextInt(); //Se guarda la edad directamente con
nextInt()

//Nótese que ya no hubo necesidad de usar parseInt() pues

nextInt nos retorna un entero derectamente

System.out.println("Gracias " + nombre + " en 10 años usted

tendrá " + (edad + 10) + " años."); //Operacion numerica con la
edad
}
}
Con este código hemos podido realizar la lectura de datos del
usuario muy fácil, pues ya no nos tuvimos que preocupar por el tipo
de dato, solo debemos usar el método adecuado según sea entero,
String, float, etc.
 PROGRAMA YA
Nuestro primer programa será sencillo y mostrará el saludo "Hola
Mundo" en la pantalla. Para crear el programa necesitaremos
realizar los siguientes pasos:

Crear el código fuente. Un archivo de código fuente contiene texto

escrito en el lenguaje de programación Java. Se puede utilizar un
simple editor de texto para crear y editar el código.
Compilar el código fuente. El compilador translada el código fuente
en instrucciones que la máquina virtual de Java pueda entender. El
compilador crea esas instrucciones en un archivo bytecode.
Ejecutar el programa. El intérprete Java, instalado en el sistema
operativo, implementa la máquina virtual de Java. Este intérprete
transforma el bytecode en instrucciones que pueda entender el
sistema operativo.
Escribir el código
Para crear el código fuente abrimos un editor, por ejemplo el Bloc
de Notas de Windows o el 'vim' en cualquier Unix, y escribimos:

/*
El programa Hola Mundo muestra un saludo en la pantalla
*/
public class HolaMundo {
public static void main(String[] args){
 //Muestra "Hola Mundo!"
System.out.println("Hola Mundo!");
}
}
Hay que tener cuidado de copiar el código tal cual se muestra
aquí. El lenguaje Java es sensible a las mayúsculas y minúsculas,
entonces HolaMundo no es lo mismo que holamundo. Una vez
terminado lo guardamos en un archivo con el nombre de
"HolaMundo.java". Esto es así porque el nombre del archivo con
extensión java tiene que ser el mismo nombre que la clase
principal. (La clase principal es la que contiene el método main).
Ampliando más, todo archivo que contenga una clase declarada
como " public " tiene que tener una coincidencia entre el
nombredelarchivo.java y el nombre de esa clase pública.

Compilar el código
Una vez guardado el código fuente, abrimos el MS-DOS o Command
Prompt. Nos situamos en el directorio en donde se encuentra el
archivo y luego ejecutamos la siguiente orden:

javac HolaMundo.java

Si todo sale bien, el compilador genera un archivo bytecode ,

HolaMundo.class en el mismo directorio en donde está el
programa. De lo contrario muestra los errores que contiene el
código.
Ejecutar el Código
En el mismo directorio en donde estamos trabajando escribir la
siguiente orden:

java HolaMundo

Esta vez escribimos el nombre del programa, pero sin la extensión.

Si hemos realizado bien los pasos y tenemos instalado
correctamente el JDK , tendremos en la pantalla el saludo:

Hola Mundo!

Bueno ese sería tu primer programa la verdad es algo SUPER

SENCILLO, pero no olvides que puedes modificar el código con lo
que ya te enseñé.
Bueno les voy a dejar un código de un Programa para realizar
Multiplicaciones y Divisiones. Ustedes a ese código lo pueden
modificar con lo que ya vimos pueden agregar y quitar cosas.
______________________________________________________
public class DSCMultiDiv
{

double Multiplica(double var)

{
double multi;
multi=var*5;
return multi;
}

double Divide(double var)

{
double div;
div=var/7;
return div;
}

public static void main(String[] args)

{
double j=0;
DSCMultiDiv variable = new DSCMultiDiv();

if (args.length==0)
{
System.out.println("Debe ingresar un argumento.");
}
 else
{
for(int i=0;i<args.length;i++)
{

j=Double.parseDouble(args[i]);

double multip=variable.Multiplica(j);
double divi=variable.Divide(j);
/*La siguiente porción de código solo muestra los valores
almacenados, por salida estandar*/
System.out.println(j+" / 7 = "+divi);
System.out.println(j+" x 5 = "+multip);
}
}
}
}

PRUEBAS
En esta sección pondré algunas preguntas de todos los temas que
vimos, cada pregunta tendrá valor de 1 a 5 puntos.
SALUDOS.