Java Desde Cero

Curso de programación JAVA desde cero
1.- Introducción e instalación de JDK

2.- Indentado, Compilado y Ejecución
Indentar: Significa hacer espacios hacia la derecha para mover una línea de código, para
tener orden y legibilidad de nuestro código.
Compilación: El compilador hace la traducción de nuestro código fuente a código máquina.
Ejecución: Para ejecutar nuestro código fuente es necesario contar con un programa que
nos permita hacerlo, Neatbeans, Eclipce o lo podemos realizar directamente desde el
símbolo del sistema:
C: \users\AquintanillaMX\Desktop\Carpeta\Archivo\javac Archivo.java
C: \users\AquintanillaMX\Desktop\Carpeta\Archivo\java Archivo
Hola Mundo
3.- Errores
4.- Variables & tipos de datos en JAVA
Primitivos
Enteros:
Byte (-128 hasta 127)
Short ( -32,768 hasta 32,767)
Int (-2,147,483,648 hasta 2,147,483,647)
Long (muy grandes)
Decimales:
Float
Double
Otros:
Char (un solo carácter)
Boolean (true | false)
Tipos de objetos
String: (Cadena de texto)
Ejemplo:
“Hola mundo”
Variables
Tipo: int
Nombre: num_uno, numUno
public class Suma{

public static void main(String args[]){
int num_uno = 5;
int num_dos = 2;
int resultado = 0;
resultado = num_uno + num_dos;

System.out.println("El resultado es: " + resultado);
}
5.- Operadores aritméticos & prioridad de los signos
}
Signo Nombre signo Tipo operación Código ASCII

+ Más Más ALT + 43
- Menos Menos ALT + 45
* Asterisco Multiplicación ALT + 42
/ Diagonal o Slash División ALT + 47
^ Acento circunflejo Potencia ALT + 94
( Paréntesis apertura Prioridad entre operadores ALT + 40
) Paréntesis cierre Prioridad entre operadores ALT + 41
Prioridades entre operadores:

6.- Estructuras condicionales If-else
Condicional: if-else
public class If_Else{
/* Estructura: If . . . else */
int mate = 7;
int biolo = 7;
int quimi = 7;
int promedio = 0;
promedio = ( mate + biolo + quimi ) / 3;
if( promedio >= 6){

System.out.println("Aprobado " +promedio);
}else{
System.out.println("No Aprobado " +promedio);
}
}
}
7.- Estructuras condicionales anidadas
Condicional: if-else
public class Anidadas{
/* Condicionales Anidadas */
int operacion = 3;
int numUno = 8;
int numDos = 4;
int res = 0;
/* Operación */
if (operacion == 1) {
res = numUno + numDos;
System.out.println("La suma es: " + res);
} else if (operacion == 2) {
res = numUno - numDos;
System.out.println("La resta es: " + res);
res = numUno * numDos;
System.out.println("La multiplicacion es: " + res);
res = numUno / numDos;
System.out.println("La división es: " + res);
}else{
System.out.println("Lo sentimos, no hay resultado");
}
}
}
8.- Como introducir datos desde teclado con biblioteca Scanner

Libreria: Scanner
/*Librerias*/
import java.util.Scanner;
/* Ingresar datos por teclado */

public class Ingresar{
public static void main(String[] args){
/*New Scanner*/
Scanner sc = new Scanner(System.in);
String nombre = "";
int num_Uno = 0;
int num_Dos = 0;
int res = 0;
/****/
System.out.println("Ingresa tu nombre: ");
nombre = sc.nextLine();
System.out.println("Hola : " +nombre);
/****/
System.out.println("Ingresa un numero: ");
num_Uno = sc.nextInt();
/****/
System.out.println("Ingresa otro numero: ");
num_Dos = sc.nextInt();
/*****/
res = num_Uno + num_Dos;
System.out.println("La suma es: " +res);
}
}
9.- Condiciones compuestas con operadores lógicos & relacionales
Operadores racionales:
Operador Nombre Ejemplo Significado

< Menor que 5<4 5 es menor que 4
> Mayor que A>B A es mayor que B
== Igual a 5 == 5 5 es igual a 5
!= Diferente Perro != Gato Perro es diferente a Gato
<= Menor o igual a A <= B A Menor o igual a B
>= Mayor o igual a A >= B A mayor o igual a B
Operadores lógicos
Operador Nombre Ejemplo Significado ASCII
&& AND Haz la tarea $$ lava la ropa Has la tarea y lava la ropa Alt + 38
|| OR Haz la tarea || lava la ropa Haz la tarea o lava la ropa Alt + 124
10.- Sistema de control vacacional
Ejercicio: Sistema vacacional
// Operadores Lógicos: && (AND), || (OR)
public class OpLogicos{

String nombre = "";
int anos = 0;
int clave = 0;
/* */
System.out.println("");
System.out.println("**************************************");
System.out.println(" Bienvenidos al Sistema de vacaciones ");
System.out.println("**************************************");
/* */
System.out.print("Ingrese el nombre del trabajador: ");
nombre = sc.nextLine();
System.out.print("Ingrese los anos de servicio del trabajador: ");
anos = sc.nextInt();
System.out.print("Ingrese la clave del trabajador: ");
clave = sc.nextInt();
/* */
/* */
if( clave == 1 ){
if( anos == 1){
System.out.println("El trabajador: " + nombre + " , tiene derecho a 6 dias de
vacaciones.");
}else if( anos >= 2 && anos <= 6){
System.out.println("El trabajador: " + nombre + " , tiene derecho a 14 dias de
11.- Estructuras de control (Switch – Case)
Estructura de control utilizada para agilizar la toma de decisiones múltiples similar a la de un menú de
opciones.
Ejercicio: Realizar un programa que seleccione el tipo de operación: Suma, Resta, Multiplicación y
División.
12.- Ciclos o Bucles (Estructura repetitiva for)
El bucle for permite controlar el número de iteraciones mediante una variable contador. La sintaxis
de la estructura for es:
for ( iniciación; condición; increento ){

bloque de instrucciones
. . .
}
System.out.println("Error: la clave no existe");
}
}
}
Donde iniciación es una o más asignaciones de variable, condición es una expresión boolean
que controla las interaciones del bucle e incremento es el aumento a ampliar a las variables que
controlan la condición.
Formas de incremento:
i++; Incrementa de uno en uno

i--; Decrementa de uno en uno
i+=5; Incrementa de 5 en 5 o según e valor que deseemos
incrementar.
public class Ciclos{

for ( int i = 1; i <= 5; i++){

System.out.println("La i vale " + i);
}
}
}
13.- Ciclos While (Estructura repetitiva while)
El bucle while depende de la evaluación de una condición. El bucle while Solamente decide si
realizar una nueva interación basándose en el valor de la condición:
while ( condición ){
bloque de instrucciones
. . .
}
System.out.println("Error: la clave no existe");
}
}
}
Se evalúa la condición, Si resulta false: Termina la ejecución del bucle. Si, por el contrario, la
condición es true: Se ejecuta el bloque de instrucciones. Tras ejecutarse el bloque de instrucciones,
se vuelve al primer punto.
public class CicloWhile{

int i = 1;
while( i < 10 ){
System.out.println(i + " , ");
i+=2;
}
}
}
14.- Ciclos Do . . .While (Estructura repetitiva do…while)
El bucle do. . .while es muy similar al bucle while con la diferencia que primero se ejecuta el
bloque de instrucciones y después se evalúa la condición para decidir si se realiza una interación.
int i = 1;
do{
System.out.println(i + " , ");
i+=2;
1.- Se ejecuta el bloque de instrucciones } while( i < 10 );
2.- Se evalúa la condición
3.- Según el valor obtenido, se termina el bucle o comenzamos en el primer punto.
15.- Ejercicios para desarrollar Bucles: for, while, Do…while.
16.- Sucesión Fibonacci con los bucles: for, while, Do…while.
/* Serie numérica con For, While y Do ... While

* 0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34
*/
public class Ejer3{
/* Sucesión Fibonacci */
int a = 0;
int b = 1;
int c = 0;
int i = 0;
System.out.println("Ciclo Fobonacci con ciclo For:");
// Ciclo for:
for( i = 0; i < 10; i++){
if( i < 9){
System.out.print( a + " , ");
c = a + b;
a = b;
b = c;
}else{
System.out.print(a);
}
}
// Serie Fibonacci con ciclo while
System.out.print("");
int i1 = 0;
int b1 = 1;
int a1 = 0;
int c1 = 0;
//
System.out.println("Serie numerica Fibonacci con ciclo While:");
while( i1 < 10){
if( i1 < 9 ){
System.out.print(a1 + " , ");
c1 = a1 + b1;
a1 = b1;
b1 = c1;
}else{
System.out.print(a1);
}
i1++;
}
}
// Serie Fibonacci con ciclo do . . while
System.out.print("");
int i2 = 0;
int b2 = 1;
int a2 = 0;
int c2 = 0;
//
System.out.println("Serie numerica Fibonacci con ciclo Do..While:");
do{
if( i2 < 9 ){
System.out.print(a2 + " , ");
c2 = a2 + b2;
a2 = b2;
b2 = c2;
}else{
System.out.print(a2);
}
i2++;
}while( i2 < 10 );
}
}
17.- Cadenas de caracteres con l método equals.
El método equals se utiliza para comparar dos objetos, no confundir con ( == igualdad), equals
compara si dos objetos apuntan al mismo objeto. Equals se utiliza para saber si dos objetos son del
mismo tipo y tienen los mismos datos. Nos da true y false.
//Cadenas de caracteres
public class Cadenas{
String nombreA = "";
String nombreB = "";
System.out.print("Ingresa el primer nombre: ");

nombreA = sc.nextLine();
System.out.print("Ingresa el segundo nombre: ");
nombreB = sc.nextLine();
if( nombreA.equalsIgnoreCase(nombreB) ){
System.out.println("Los nombres son iguales.");
}else{
System.out.println("Los nombres son diferentes.");
}
}
}
18.- Manipulación de cadenas con los métodos length() & substring().
- Método length -> Indica cuantos caracteres pose una cadena de caracteres.
- Método substring -> Permite obtener una parte en especifico de la cadena de caracteres.
Substring(desde, hasta).
public class Cadenas1{
//
String cadena_org = "";
String cadena_sub = "";
int num_cadena = 0;
int desde = 0;
int hasta = 0;
//
System.out.print("Ingrese una cadena de texto: ");
cadena_org = sc.nextLine();
//
num_cadena = cadena_org.length();
//
System.out.println("La cadena de texto " + cadena_org + " tiene " + num_cadena + "
caracteres.");
//
System.out.print("Desde donde deseas obtener la nueva cadena de texto: ");
desde = sc.nextInt();
System.out.print("Hsta donde deseas obtener la nueva cadena de texto: ");
hasta = sc.nextInt();
//
cadena_sub = cadena_org.substring(desde, hasta);
//
System.out.print("La nueva cadena de texto es: " + cadena_sub);
}
}
19.- Arreglos Unidimensionales (Vector)
Un Arreglo es una estructura de datos que almacena bajo el mismo nombre a una colección de datos.
Lista de alumnos = Nombre de la colección de datos.
 Tipos de arreglos
1.- Arreglos unidimensionales mejor conocidos como “Vectores”, listas de una sola dimensión y solo
almacena datos de forma lineal, ya sea hacia adelante o atrás.
Posición 0 Posición 1 Posición 2 Posición 3
Juan Guillermo Ana Luis
Esta división en 5 secciones y a cada sección se le conoce como posición.
Índice:
Sintaxis:
int arreglo[] = new int[5];

5 220 8 458
Como imprimir en pantalla:
System.out.println(numeros[2]);
Salida en pantalla: 8
Ejercicio:
//Arreglos Unidimensionales (Vectores)

public class Arreglos1{
int numeros[] = new int[5];
numeros[0] = 5;
numeros[1] = 220;
numeros[2] = 8;
numeros[3] = 458;
numeros[4] = 22;
System.out.print("[" + numeros[0] + "]");

}
}
2.- Arreglos bidimensionales mejor conocidos como “Matrices”
int numeros[]= new int[5];

for(int i = 0; i < números.length; i++){
vector[i] = i + 10;
}
null null null null

 Tipos de arreglos
1.- Arreglos unidimensionales mejor conocidos como “Vectores”

2.- Arreglos bidimensionales mejor conocidos como “Matrices”
20.- Arreglos Dinámicos int arreglo[] = new int[5];
//Arreglos o Vectores Dinamicos ArreDinamicos.java

// [5][54][12][65][6][54][897]
public class ArreDinamicos{
int longitud = 0;
System.out.print("¿Cuantos numeros deseas ingresar?");

longitud = sc.nextInt();
int numeros[] = new int[longitud];
for( int i = 0; i < numeros.length; i++){

System.out.println("Por favor dame el valor #: " + ( i+1 ));
numeros[i] = sc.nextInt();
}
for( int i = 0; i < numeros.length; i++ ){
System.out.print("[" + numeros[i] + "]");
}
}
}
21.- Arreglos bidimensionales (Matrices)
//Interfaces Graficas: Librerias Swing

import javax.swing.*;
public class Formulario extends JFrame{

private JLabel label1;
//Constructores
public Formulario(){
setLayout(null);// Metodo para uso de coordenadas
label1 = new JLabel("Etiqueta 1");
label1.setBounds(10,20,200,300);//Coordenadas y dimensiones del Layout
add(label1);
}
Formulario formulario1 = new Formulario();//Inicialisar
formulario1.setBounds(0,0,400,300);//Coordenadas y dimensiones
formulario1.setVisible(true);//Visibilidad del formulario
formulario1.setLocationRelativeTo(null);//Centro de la pantalla
}
24.- Interfaces gráficas (Librería swing)
La librería swing abarca componentes como botones, tablas, marcos etc. Los componentes de la
librería swing se identifican porque pertenecen al paquete javax.swing. El * indica que deseamos
importar varios componentes del paquete.
o Bien:
import javax.swing.JFrame;
import javax.swing.JLabel;
La clase JFrame: Encapsula el concepto de ventana. Luego para implementar una aplicación que
muestre una ventana debemos plantear una clase que herede de la clase JFrame.
public class Formulario extends JFrame {
Con esta sintaxis, estamos indicando que la clase Formulario hereda todos los métodos y propiedades
de la clase JFrame.
Para mostrar un texto dentro de una ventana necesitamos requerir la colaboración de la clase
JLabel(que tiene por objetivo mostrar un texto dentro de un JFrame).
Definimos pues como atributo de la clase un objeto de la clase JLabel:
private JLabel label;
En el constructor de la clase llamamos al método heredado de la clase JFrame llamado setLayout y

le colocamos un parámetro null, con esto estamos informándole a la clase JFrame que utilizaremos
posicionamiento absoluto para los controle visuales dentro del JFrame.
setLayout(null);
}
Luego tenemos que crear un objeto de la clase JLabel y pasarle como parámetro al constructor el texto
a mostrar:
label1 = new JLable(“Hola Mundo”);
Ubicamos al objeto de la clase JLabel llamando al método setBounds, este requiere como parámetros
la (columna, fila, ancho, alto) del JLabel. Finalmente llamamos al método add (método heredado de
la clase JFrame) que tiene como objetivo añadir el control JLabel al control JFrame.
setLayout(null);
label1 = new JLabel("Etiqueta 1");
label1.setBounds(10,20,200,300);
add(label1);
Finalmente debemos codificar la main donde creamos un objeto de la clase Formulario, llamamos al
método setBounds para ubicar y dar tamaño al control y mediante el método setVisible hacemos
visible el JFrame:
public static void main(Strings args[]){

Formulario formulario1 = new Formulario();
formulario1.setBounds(0,0,400,300);
formulario1.setVisible(true);
formulario1.setLocationRelativeTo(null);//Centro de la pantalla
Al ejecutar el proyecto este es el resultado:

25.- Interfaces gráficas (swing - JFrame)
El componente básico que requerimos cada vez que implementamos una interfaz visual con la librería
Swing es la clase JFrame. Esta clase encapsula una ventana clásica de cualquier sistema operativo con
un entorno gráfico de Windows, Linux o OS X.
Hemos dicho que esta clase se encuentra en el paquete javax.swing y como generalmente utilizamos
varias clases de este paquete entonces necesitamos importar todas las clases.
o Bien:
import javax.swing.JFrame;
import javax.swing.JLabel;
Podemos hacer una aplicación mínima con la clase JFrame:
Import javax.swing.*;
public class Formulario {

public static void main(String[] ar) {
JFrame f=new JFrame();
f.setBounds(10,10,300,200);
f.setVisible(true);
}
}
Como podemos ver importamos la clase JFrame del paquete javax.swing:
y luego en la main definimos y creamos un objeto de la clase JFrame (Llamando luego a los métodos
setBounds y setVisible):
Pero esta forma de trabajar con la clase JFrame es de poca utilidad ya que rara vez necesitamos
implementar una aplicación que muestre una ventana vacía.
Lo más correcto es plantear una clase que herede de la clase JFrame y extienda sus responsabilidades
agregando botones, etiquetas, editores de línea etc.
Entonces la estructura básica que implementaremos para crear una interfaz gráfica será:

public Formulario() {
setLayout(null);
}
public static void main(String args[]) {

Formulario formulario1=new Formulario();
}
}
Importamos el paquete donde se encuentra la clase JFrame:
Con el constructor indicamos que ubicaremos los controles visuales con coordenadas absolutas
mediante la desactivación del Layout heredado (más adelante veremos cómo ubicar controle visuales
dentro del JFrame).
public Formulario() {
setLayout(null);
}
En la main creamos un objeto de la clase y llamamos a los métodos setBounds y setVisible:
public static void main(String[] ar) {

Formulario formulario1=new Formulario();
}
El método setBounds ubica el JFrame (la ventana) en la columna 10, fila 20 con un ancho de 400px y un
alto de 300px. Debemos llamar al método setVisible y pasarle el valor true para que se haga visible.
Problemas Propuestos:
1.- Crear una ventana de 1024 píxeles por 800 píxeles. Luego no permitir que el operador modifique el
tamaño de la ventana. Sabiendo que hacemos visible al JFrame llamando al método setVisible pasando
el valor true, existe otro método llamado setResizable que también requiere como parámetro un valor
true o false.
import javax.swing.*; // Librería Swing

setLayout(null);
}
JFrame f = new JFrame();
f.setBounds(10,10,1024,800);
f.setVisible(true);
f.setResizable(true);
}
}
26.- Interfaces gráficas (swing - JLabel)
La clase JLabel nos permite mostrar texto en la ventana que hemos creado con JFrame:
- Primero que nada importar la clase: import javax.swing.*;

- Heredamos de la clase JFrame:
public class FormularioJButton extends JFrame{
- Definimos dos atributos de la clase JLabel, en el constructor las labels y ubicaciones llamando el
método setBounds, no olvidemos llamar el método add(), el cuál añade tanto JFrame como JLabel.
public FormularioJLabel(){//Constructor
setLayout(null);
label1 = new JLabel("Línea uno");//Nuevo Objeto
add(label1);//Metodo add para mostrar
label2 = new JLabel("Línea Dos");
add(label2);
label3 = new JLabel("Línea Tres");
label3.setBounds(50, 150,100,30);
add(label3);
label4 = new JLabel("Línea Cuatro");
add(label4);
label5 = new JLabel("Línea Cinco");
add(label5);
}
- Por último en la main creamos el objeto de la clase que acabamos de codificar, llamamos al método
setBounds para ubicar y dar tamaño al JFrame, llamamos al método setResizable con los valores
false/true dependiendo si vamos a permitirle al usuario redimensionar la ventana, y finalmente
llamamos al método setVisible para que se visualice el JFrame.

FormularioJButton forma1 = new FormularioJButton();
forma1.setBounds(0,0,500,500);
forma1.setVisible(true);
forma1.setResizable(false);
forma1.setLocationRelativeTo(null);
}
27.- Interfaces gráficas (swing - JButton)
El tercer control visual de uso muy común es el que provee la clase JButton. Este control visual muestra
un botón.
El proceso para añadir el botones a un control JFrame es similar a añadir controles de tipo JLabel.
Veremos la captura de eventos con los controles visuales. Uno de los eventos más comunes es cuando
hacemos clic en el botón. Java implementa el concepto de interfaces para poder llamar a métodos de
una clase existente a una clase desarrollada por nosotros.
Ejemplo:
1.- Iniciaremos importando la clase: import java.awt.event.*;

2.- Creamos el constructor para el botón agregando el método JFrame implements ActionListener:
La mecánica para atrapar el clic del objeto de la clase JButton se hace mediante la implementación de
una interface. Una interface es un protocolo que permite la comunicación entre dos clases. Una
interface contiene uno o más cabeceras de métodos, pero no su implementación. Por ejemplo, la
interface ActionListener tiene la siguiente estructura:
public class FormularioJButton extends JFrame implements ActionListener{

//Constructor de Botónes
JButton boton1;
//
public FormularioJButton(){
setLayout(null);
boton1 = new JButton("Finalizar");
boton1.setBounds(350,400,100,30);
add(boton1);
boton1.addActionListener(this);
}
public void actionPerformed(ActionEvent e){
if(e.getSource() == boton1){
System.exit(0);
}
}
Luego las clases que implementan la interface ActionListener deberán especificar el algoritmo del
método actionPerformed.
Mediante el concepto de interfaces podemos hacer que desde la clase JButton se puede llamar a un
método que implementamos en nuestra clase. Para indicar que una clase implementará una interface
lo hacemos en la declaración de la clase con la sintaxis:
public class FormularioJButton extends JFrame implements ActionListener{
Con esto estamos diciendo que nuestra clase implementará la interface ActionListener , para luego hay
que codificar el método actionPerformed.
Definimos un objeto de la clase JButton:

JButton boton1;
//
public FormularioJButton(){
setLayout(null);
boton1 = new JButton("Finalizar");
boton1.setBounds(350,400,100,30);
add(boton1);
boton1.addActionListener(this);
}
El método actionPerformed (este método de la interface ActionListener debe implementarse

obligatoriamente, en caso de no codificarlo o equivocarnos en su nombre aparecerá un mensaje de
error en tiempo de compilación de nuestro programa).
El método actionPerformed se ejecutará cada vez que hagamos clic sobre el objeto de la clase JButton.
La interface ActionListener y el objeto de la clase ActionEvent que llega como parámetro están
definidas en el paquete: import java.awt.event.*;
Es decir, cada vez que se presiona el botón desde la clase JButton se llama al método actionPerformed
y recibe como parámetro un objeto de la clase ActionEvent.
En el método actionPerformed mediante el acceso al método getSource( ) del objeto que llega como
parámetro podemos analizar que botón se presionó:
public void actionPerformed(ActionEvent e){

if(e.getSource() == boton1){
System.exit(0);
}
Si se presiona el botón boton1 luego el if se verifica verdadero y por lo tanto llamando al método exit
de la clase System se finaliza la ejecución del programa.
La main no varía en nada con respecto a problemas anteriores.

FormularioJButton forma1 = new FormularioJButton();
forma1.setBounds(0,0,500,500);
forma1.setVisible(true);
forma1.setResizable(false);
forma1.setLocationRelativeTo(null);
}

Java Desde Cero

Cargado por

Información del documento

Descripción:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Descripción:

Copyright:

Formatos disponibles

Java Desde Cero

Cargado por

Descripción:

Copyright:

Formatos disponibles

Curso de programación JAVA desde cero

1.- Introducción e instalación de JDK

Compilación: El compilador hace la traducción de nuestro código fuente a código máquina.

String: (Cadena de texto)

public class Suma{

resultado = num_uno + num_dos;

Signo Nombre signo Tipo operación Código ASCII

Prioridades entre operadores:

promedio = ( mate + biolo + quimi ) / 3;

if( promedio >= 6){

7.- Estructuras condicionales anidadas

8.- Como introducir datos desde teclado con biblioteca Scanner

/* Ingresar datos por teclado */

9.- Condiciones compuestas con operadores lógicos & relacionales

Operador Nombre Ejemplo Significado

!= Diferente Perro != Gato Perro es diferente a Gato

<= Menor o igual a A <= B A Menor o igual a B

>= Mayor o igual a A >= B A mayor o igual a B

10.- Sistema de control vacacional

Ejercicio: Sistema vacacional

public class OpLogicos{

12.- Ciclos o Bucles (Estructura repetitiva for)

for ( iniciación; condición; increento ){

i++; Incrementa de uno en uno

public class Ciclos{

for ( int i = 1; i <= 5; i++){

public class CicloWhile{

14.- Ciclos Do . . .While (Estructura repetitiva do…while)

15.- Ejercicios para desarrollar Bucles: for, while, Do…while.

16.- Sucesión Fibonacci con los bucles: for, while, Do…while.

/* Serie numérica con For, While y Do ... While

17.- Cadenas de caracteres con l método equals.

System.out.print("Ingresa el primer nombre: ");

Lista de alumnos = Nombre de la colección de datos.

Posición 0 Posición 1 Posición 2 Posición 3

Juan Guillermo Ana Luis

Esta división en 5 secciones y a cada sección se le conoce como posición.

int arreglo[] = new int[5];

Como imprimir en pantalla:

//Arreglos Unidimensionales (Vectores)

System.out.print("[" + numeros[0] + "]");

int numeros[]= new int[5];

Posición 0 Posición 1 Posición 2 Posición 3

null null null null

1.- Arreglos unidimensionales mejor conocidos como “Vectores”

20.- Arreglos Dinámicos int arreglo[] = new int[5];

//Arreglos o Vectores Dinamicos ArreDinamicos.java

System.out.print("¿Cuantos numeros deseas ingresar?");

int numeros[] = new int[longitud];

for( int i = 0; i < numeros.length; i++){

//Interfaces Graficas: Librerias Swing

public class Formulario extends JFrame{

24.- Interfaces gráficas (Librería swing)

public class Formulario extends JFrame {

Definimos pues como atributo de la clase un objeto de la clase JLabel:

private JLabel label;

En el constructor de la clase llamamos al método heredado de la clase JFrame llamado setLayout y

label1 = new JLable(“Hola Mundo”);

public static void main(Strings args[]){

Al ejecutar el proyecto este es el resultado:

Podemos hacer una aplicación mínima con la clase JFrame: