CLASE 2

MODELO DE DESARROLLO DE PROGRAMAS Y PROGRAMACION CONCURRENTE –

2.021 – Profesor: Ing. José Farfán
FAC.DE INGENIERIA - UNJu
JAVA
CARACTERÍSTICAS PRINCIPALES DE JAVA Código Java (archivos .java)
• Independiente del HW
JAVAC (compilador)
• Orientado a Objetos y de propósito general
Byte Code (archivos .class)
• Sintaxis parecida a C++

• Robusto JVM JVM

Windows Linux
• Solo admite herencia simple

• Seguridad desde el punto de vista del programador: Comprobación estricta de tipos de

datos, Gestión de excepciones y la No existencia de punteros

• Seguridad desde el punto de vista del usuario de aplicaciones: Los programas se ejecutan
sobre una máquina virtual (JVM), Espacio de nombre y Programación Concurrente Nativa

• Tipos de datos estandarizados

ECLIPSE
Entorno integrado de desarrollo o IDE (Integrated Development Environment) q permite
escribir código de un modo cómodo (la comodidad reside en que los entornos de desarrollo
integrados son mucho +q 1simple editor de textos). Características comunes de las IDE:

• Coloreado de sintaxis. • Conexión con sistema de seguimiento de

errores.
• Herramientas de búsqueda.
• Facilidades para la creación de tareas.
• Asistentes para la escritura de código.
• Herramientas avanzadas para el análisis de
• Ejecución de aplicaciones sin abandonar el
código.
entorno.
• Herramientas de análisis de rendimiento.
• Herramientas de depuración de código.
• Conexión a gestores de bases de datos.
• Conexión con sist.de control de versiones.
CONSIDERACIONES PARA LA INSTALACIÓN DE JAVA Y ECLIPSE
• Se debe instalar Java SE Development Kit (x64 o de 32 bits).

• Eclipse necesita que Java este instalado y correctamente configurado, es decir las
siguientes variables de entorno deben estar correctamente seteadas:

set JAVAPATH=<directorio donde hayas instalado java>

PATH=.;%JAVAPATH\bin;%PATH%

set CLASSPATH=.\;%JAVAPATH%\lib\classes.zip;%CLASSPATH%
PASOS P/CREAR UN PROGRAMA JAVA EN ECLIPSE
1ºCrear un Proyecto

2ºCrear1Clase
(incluir main si es el
único programa)

4ºCompilar y Ejecutar

3ºEscribir el programa
ERRORES SINTÁCTICOS Y LÓGICOS
import java.util.Scanner;
public class SuperficieCuadrado {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int lado;
int superficie;
System.out.print("Ingrese el valor del lado del cuadrado:");
lado=teclado.nextInt();
superficie=lado * lado;
System.out.print("La superficie del cuadrado es:");
System.out.print(Superficie); Error Sintáctico

}
}
ERRORES SINTÁCTICOS Y LÓGICOS
import java.util.Scanner;
public class SuperficieCuadrado {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int lado;
int superficie;
System.out.print("Ingrese el valor del lado del cuadrado:");
lado=teclado.nextInt();
superficie=lado * lado * lado; Error Lógico

System.out.print("La superficie del cuadrado es:");

System.out.print(superficie);
}
}
ESTRUCTURAS CONDICIONALES SIMPLES
import java.util.Scanner;
public class EstructuraCondicionalSimple1 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
float sueldo;
System.out.print("Ingrese el sueldo:");
sueldo=teclado.nextFloat();
if (sueldo>29855) { Estructura Condicional Simple
System.out.println("Esta persona debe abonar impuesto a las ganancias");
}
}
}
ESTRUCTURAS CONDICIONALES COMPUESTAS
import java.util.Scanner;
public class EstructuraCondicionalCompuesta1 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int num1,num2;
System.out.print("Ingrese primer valor:");
num1=teclado.nextInt();
System.out.print("Ingrese segundo valor:");
num2=teclado.nextInt();
if (num1>num2) { Estructura Condicional Compuesta
System.out.print(num1);
} else {
System.out.print(num2);
}
}
}
import java.util.Scanner; ESTRUCTURAS CONDICIONALES COMPUESTAS
public class EstructuraCondicionalAnidada1 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int nota1,nota2,nota3;
System.out.print("Ingrese primer nota:");
nota1=teclado.nextInt();
System.out.print("Ingrese segunda nota:");
nota2=teclado.nextInt();
System.out.print("Ingrese tercer nota:");
nota3=teclado.nextInt();
int promedio=(nota1 + nota2 + nota3) / 3;
if (promedio>=7) { Estructura Condicional Anidada
System.out.print("Promocionado");
} else {
if (promedio>=4) {
System.out.print("Regular");
} else {
System.out.print("Reprobado");
}
} } }
OPERADORES import java.util.Scanner;
Relacionales (>, <, >=, <= , ==, !=) public class CondicionesCompuestas1 {
Matemáticos (+, -, *, /, %) public static void main(String[] ar) {
Lógicos (&&, ||) Scanner teclado=new Scanner(System.in);
int num1,num2,num3;
System.out.print("Ingrese primer valor:");
num1=teclado.nextInt();
System.out.print("Ingrese segundo valor:");
num2=teclado.nextInt();
System.out.print("Ingrese tercer valor:");
num3=teclado.nextInt();
Operador relacionales y if (num1>num2 && num1>num3) {
Lógico System.out.print(num1);
} else {
if (num2>num3) {
System.out.print(num2);
}else {
System.out.print(num3);
} } } }
ESTRUCTURA REPETITIVA WHILE
import java.util.Scanner;
public class EstructuraRepetitivaWhile3 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int x,suma,valor,promedio;
x=1;
suma=0;
while (x<=10) {
System.out.print("Ingrese un valor:");
public class EstructuraRepetitivaWhile1 valor=teclado.nextInt();
{ suma=suma+valor;
public static void main(String[] ar) { x=x+1;
int x; }
x=1; promedio=suma/10;
while (x<=100) { System.out.print("La suma de los 10 valores es:");
System.out.print(x); System.out.println(suma);
System.out.print(" - "); System.out.print("El promedio es:");
x = x + 1; System.out.print(promedio);
} } } }
Estructura Repetitiva While }
 ESTRUCTURA REPETITIVA DO WHILE
import java.util.Scanner;
public class EstructuraRepetitivaDoWhile1 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int valor;
do {
System.out.print("Ingrese 1valor entre 0 y 999 (0=fin:");
valor=teclado.nextInt();
Ej: indicar si se carga 1valor mayor if (valor>=100) {
o igual a 100 q se trata de 1nro. de System.out.println("Tiene 3 dígitos.");
3cifras, si es mayor o igual a 10 se } else {
trata de 1valor de dos dígitos, en if (valor>=10) {
caso contrario se trata de un valor System.out.println("Tiene 2 dígitos.");
de un dígito. Este bloque se repite } else {
hasta q se ingresa en la variable System.out.println("Tiene 1 dígito.");
valor el nro. 0 con lo q la condición }
de la estructura do while retorna }
falso y sale del bloque repetitivo } while (valor!=0); Estructura Repetitiva Do While
finalizando el programa. } }
ESTRUCTURA REPETITIVA FOR
import java.util.Scanner;

public class EstructuraRepetitivaFor2 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int suma,f,valor,promedio;
suma=0;
for(f=1;f<=10;f++) {
public class EstructuraRepetitivaFor1 { System.out.print("Ingrese valor:");
public static void main(String[] ar) { valor=teclado.nextInt();
int f; suma=suma+valor;
for(f=1;f<=100;f++) { }
System.out.print(f); System.out.print("La suma es:");
System.out.print("-"); System.out.println(suma);
} promedio=suma/10;
} System.out.print("El promedio es:");
} System.out.print(promedio);
Estructura Repetitiva For }
}
CADENA DE CARACTERES import java.util.Scanner;
Ej: Solicitar public class CadenaDeCaracteres1 {
el ingreso public static void main(String[] ar) {
del nombre Scanner teclado=new Scanner(System.in);
y edad de String nombre1,nombre2;
dos int edad1,edad2;
personas y System.out.print("Ingrese el nombre:");
mostrar el nombre1=teclado.next();
nombre de System.out.print("Ingrese edad:");
la persona edad1=teclado.nextInt();
mayor System.out.print("Ingrese el nombre:");
edad. nombre2=teclado.next();
System.out.print("Ingrese edad:");
edad2=teclado.nextInt();
System.out.print("La persona de mayor edad es:");
if (edad1>edad2) {
System.out.print(nombre1);
} else {
System.out.print(nombre2);
} } }
 DECLARACIÓN DE UNA CLASE Y DEFINICIÓN DE OBJETOS
class [nombre de la clase] { Ej: Confeccionar 1 clase que permita cargar el nombre
[atributos o variables de la clase] y la edad de 1 persona, mostrar los datos cargados e
[métodos o funciones de la clase] imprimir un mensaje si es mayor de edad (edad>=18)
[main] public void imprimir() {
} System.out.println("Nombre:"+nombre);
import java.util.Scanner; System.out.println("Edad:"+edad); }
public class Persona { public void esMayorEdad() {
private Scanner teclado; if (edad>=18) {
private String nombre; System.out.print(nombre+" es > de edad.");
private int edad; } else {
System.out.print(nombre+" no es < de edad.");
public void inicializar() { } }
teclado=new Scanner(System.in); public static void main(String[] ar) {
System.out.print("Ingrese nombre:"); Persona persona1;
nombre=teclado.next(); persona1=new Persona();
System.out.print("Ingrese edad:"); persona1.inicializar();
edad=teclado.nextInt(); persona1.imprimir();
} persona1.esMayorEdad();
} }
 import java.util.Scanner;
DECLARACIÓN DE MÉTODOS public class TablaMultiplicar {
Métodos sin parámetros
public void [nombre del método]() { public void cargarValor() {
[algoritmo] } Scanner teclado=new Scanner(System.in);
int valor;
Métodos con parámetros do {
public void [nombre del System.out.print("Ingrese valor:");
método]([parámetros]) { valor=teclado.nextInt();
[algoritmo] } if (valor!=-1) {
calcular(valor); }
Métodos que retornan un dato } while (valor!=-1);
public [tipo de dato] [nombre del }
método]([parámetros]) { public void calcular(int v) {
[algoritmo] for(int f=v;f<=v*10;f=f+v) {
return [tipo de dato]} System.out.print(f+"-"); }
}
public static void main(String[] ar) {
Ej: Confeccionar 1 clase q permita TablaMultiplicar tabla;
ingresar valores enteros x teclado y q tabla=new TablaMultiplicar();
muestre la tabla de multiplicar de dicho tabla.cargarValor();
valor. Finalizar el programa al ingresar -1 } }
 import java.util.Scanner;
VECTOR public class PruebaVector1 {
Un vector es 1 estructura de datos private Scanner teclado;
q permite almacenar un private int[] sueldos;
CONJUNTO de datos del MISMO public void cargar()
tipo. Con 1único nombre se define {
un vector y x medio de 1 subíndice teclado=new Scanner(System.in);
se hace referencia a c/elemento sueldos=new int[5];
del mismo (componente) for(int f=0;f<5;f++) {
System.out.print("Ingrese valor del componente:");
sueldos[f]=teclado.nextInt();
} }
Ej: guardar los sueldos de 5 operarios
public void imprimir() {
for(int f=0;f<5;f++) {
System.out.println(sueldos[f]);
} }
public static void main(String[] ar) {
PruebaVector1 pv=new PruebaVector1();
pv.cargar();
pv.imprimir();
} }
VECTOR import java.util.Scanner;
public class PruebaVector8 {
private Scanner teclado; Ej: almacenar los
private int[] sueldos; sueldos de
public void cargar() operarios, se debe
{ teclado=new Scanner(System.in); pedir la cantidad de
System.out.print("Cuantos sueldos cargará:"); sueldos a ingresar y
int cant; luego crear un
cant=teclado.nextInt(); vector con dicho
sueldos=new int[cant]; tamaño.
for(int f=0;f<sueldos.length;f++) {
System.out.print("Ingrese sueldo:");
sueldos[f]=teclado.nextInt(); } }
public void imprimir() {
for(int f=0;f<sueldos.length;f++) {
System.out.println(sueldos[f]); } }
public static void main(String[] ar) {
PruebaVector8 pv=new PruebaVector8();
pv.cargar();
pv.imprimir();
} }
VECTORES PARALELOS public void cargar() {
teclado=new Scanner(System.in);
Se da cuando hay una relación entre nombres=new String[5];
las componentes de igual subíndice edades=new int[5];
(misma posición) de un vector y otro. for(int f=0;f<nombres.length;f++) {
Ej: almacenar en 1 vector los nombres System.out.print("Ingrese nombre:");
de personas y en el otro sus edades nombres[f]=teclado.next();
System.out.print("Ingrese edad:");
edades[f]=teclado.nextInt();
} }
public void mayoresEdad() {
System.out.println("Personas mayores de edad.");
for(int f=0;f<nombres.length;f++) {
import java.util.Scanner; if (edades[f]>=18) {
public class PruebaVector10 { System.out.println(nombres[f]);
private Scanner teclado; } } }
private String[] nombres; public static void main(String[] ar) {
private int[] edades; PruebaVector10 pv=new PruebaVector10();
pv.cargar();
pv.mayoresEdad();
} }
MATRIZ public void cargar() {
teclado=new Scanner(System.in);
Es 1estruct.de datos q permite mat=new int[3][5];
almacenar 1CONJ.de datos del MISMO for(int f=0;f<3;f++) {
tipo. Con 1único nombre se define la for(int c=0;c<5;c++) {
matriz y x medio de DOS subíndices se System.out.print("Ingrese componente:");
hace referencia a c/elemento de la mat[f][c]=teclado.nextInt();
misma (componente) } } }
public void imprimir() {
Ej:Crear 1matriz de 3 filas x 5 columnas
for(int f=0;f<3;f++) {
con elementos de tipo int, cargar sus
for(int c=0;c<5;c++) {
componentes y luego imprimirlas.
System.out.print(mat[f][c]+" ");
}
System.out.println();
}
}
public static void main(String[] ar) {
import java.util.Scanner; Matriz1 ma=new Matriz1();
public class Matriz1 { ma.cargar();
private Scanner teclado; ma.imprimir();
private int[][] mat; } }
CONSTRUCTOR DE LA CLASE public Operarios()
Es 1método q se ejecute inicialmente y {
en forma automática. Características: teclado=new Scanner(System.in);
• Tiene el mismo nombre de la clase. sueldos=new int[5];
• Es el primer método que se ejecuta. for(int f=0;f<5;f++) {
• Se ejecuta en forma automática. System.out.print("Ingrese el valor:");
• No puede retornar datos. sueldos[f]=teclado.nextInt();
• Se ejecuta una única vez. }
• Tiene por objetivo inicializar atributos. }
public void imprimir() {
Ej: Guardar los sueldos de 5 operarios for(int f=0;f<5;f++) {
en un vector. Realizar la creación y System.out.println(sueldos[f]);
carga del vector en el constructor. }
}
import java.util.Scanner;
public static void main(String[] ar) {
public class Operarios {
Operarios op=new Operarios();
private Scanner teclado;
op.imprimir();
private int[] sueldos;
}
}
HERENCIACrea nuevas clases partiendo de clases existentes, q tiene todos los atrib.y métodos
de su 'superclase' o 'clase padre' y se le podrán añadir otros atrib.y métodos propios.
import java.util.Scanner; public class Resta extends Operacion {
public class Operacion { public void operar(){
protected Scanner teclado; resultado=valor1-valor2;
protected int valor1; }}
protected int valor2; public class Prueba {
protected int resultado; public static void main(String[] ar) {
public Operacion() { Suma suma1=new Suma();
teclado=new Scanner(System.in); } suma1.cargar1();
public void cargar1() { suma1.cargar2();
System.out.print("Ingrese el 1er.valor:"); suma1.operar();
valor1=teclado.nextInt(); } System.out.print("El result.de la suma es:");
public void cargar2() { suma1.mostrarResultado();
System.out.print("Ingrese el 2do.valor:"); Resta resta1=new Resta();
valor2=teclado.nextInt(); } resta1.cargar1();
public void mostrarResultado() { resta1.cargar2();
System.out.println(resultado); } } resta1.operar();
public class Suma extends Operacion{ System.out.print("El result.de la resta es:");
void operar() { resta1.mostrarResultado(); } }
resultado=valor1+valor2; } }
BIBLIOGRAFÍA RECOMENDADA

• Tutorial: http://www.tutorialesprogramacionya.com/javaya/
• Tutorial: https://desarrolloweb.com/manuales/57/
• Java2 incluye Swing, Threads, programación en red, JavaBeans, JDBC y
JSP / Servlets. 2004. De Jorge Sánchez
• Aprenda Java como si estuviera en primero. 2000. De García de Jalón,
Mingo, Imaz, Brazalez, Larzabal, Calleja y García.
• Desarrollo de Proyectos Informáticos con Tecnología Java. 2000. De
Fernandez, Canut y Navarro.