Download INTRODUCCIÓN A JAVA

class CAritmetica
{
/*
*Operaciones aritmeticas
*/
public static void main (string[]args)
{
int dato1,dato2, resultado;
dato1=20;
dato2=10;
//suma
resultado=dato1+dato2;
system.out.println(dato1+" + "+dato2+"="+resultado);
//resta
resultado=dato1-dato2;
system.out.pintln(dato1+" - "+dato2+"="+resultado);
//producto
resultado=dato1*dato2;
system.out.println(dato1+" * "+dato2+"="+resultado);
//cociente
resultado=dato1/dato2;
system.out.println(dato1+" / "+dato2+"="+resultado);
}
}
public class Ejer03
{
public static void main(String Argumentos[ ])
{
byte largestByte = Byte.MAX_VALUE;
short largestShort = Short.MAX_VALUE;
int largestInteger = Integer.MAX_VALUE;
long largestLong = Long.MAX_VALUE;
float largestFloat = Float.MAX_VALUE;
double largestDouble = Double.MAX_VALUE;
char aChar = 'S';
boolean aBoolean = true;
System.out.println("Maximo
System.out.println("Maximo
System.out.println("Maximo
System.out.println("Maximo
valor para Byte: "+largestByte);
valor para Shor: "+largestShort);
valor para Integer: "+largestInteger);
valor para Long: "+largestLong);
System.out.println("Maximo valor para float: "+largestFloat);
System.out.println("Maximo valor para double:
"+largestDouble);
if(Character.isUpperCase(aChar))
{
System.out.println("El caracter: "+aChar+" es mayuscula");
}
else
{
System.out.println("El caracter: "+aChar+" es minuscula");
}
System.out.println("El valor de boolean es:" +aBoolean);
}
}
Atributos. Atributos estáticos
o
de clase.
Cada atributo debe empezar con un modificador de
acceso. Estos indican la visibilidad, es decir, se puede
tener acceso sólo desde la clase (private), desde la
clase y las clases que heredan de ella (protected),
desde cualquier clase definida en el mismo paquete
(ausencia de modificador) o desde cualquier clase
(public).
EJEMPLO:
public static int cuantasInstancias() {
return numeroInstancias; } }
5
Métodos. Métodos
estáticos o de clase
Permite, acceder directamente a través del
nombre de la clase. Los métodos declarados
static tienen una restricción muy fuerte,
pueden acceder a atributos o métodos
también declarados como static.
EJEMPLO:
public static int cuantasInstancias() {
return numeroInstancias; }
6
Creación de objetos
Un objeto, desde nuestro punto de vista,
puede verse como una pieza de software que
cumple con ciertas características:
 Herencia
 Encapsulamiento
Herencia
Induce una jerarquía en forma de árbol
sobre las clases con raíz en la clase
Object. Una clase se dice que hereda o
extiende a otra clase antecesora
7
Encapsulamiento
Consiste en la ocultación del estado, de los
datos miembro de un objeto, de forma que
sólo es posible modificar los mismos,
mediante las operaciones (métodos, en
Java) definidos para dicho objeto.
Sobrescritura de constructores
los constructores, son métodos invocados en
el momento de la creación de instancias.
Como cualquier otro método se pueden
sobrescribir en el momento de la extensión.
8
Clases abstractas.
Un método se puede declarar como
abstract. El método así declarado
puede no implementar nada.
Qué es una excepción.
Es una situación anómala, que llega
la ejecución de un programa.
9
Tipos de excepciones:
existen dos :Los Errores
Excepciones propiamente dichas
Los Errores: son situaciones irrecuperables, por
ejemplo: fallos de la máquina virtual
Las excepciones : Cuando una excepción se
produce, se acompaña de toda la información
relevante para que podamos gestionarla
Creación de excepciones propias
La excepción más adecuada, y en el constructor
de la clase, llamar a la clase padre con el
mensaje que se desee mostrar cuando se
produzca la excepción.
10
public class Ejer05
{
public static void main(String Argumentos[])
{
int i = 37;
int j = 42;
int k = 42;
System.out.println("Valores de variables...");
System.out.println(" i = "+i);
System.out.println(" j = "+j);
System.out.println(" k = "+k);
System.out.println("Mayor que...");
System.out.println(" i > j is "+(i>j));//FALSO
System.out.println(" j > i is "+(j>i));//VERDADERO
System.out.println(" k > j is "+(k>j));//VERDADERO
System.out.println("Menor o igual que...");
System.out.println(" i >= j is "+(i>=j));//FALSO
System.out.println(" j >= i is "+(j>=i));//VERDADERO
System.out.println(" k >= j is "+(k>=j));//VERDADERO
System.out.println("Mayor que...");
System.out.println(" i < j is "+(i<j));//FALSO
System.out.println(" j < i is "+(j<i));//VERDADERO
System.out.println(" k < j is "+(k<j));//VERDADERO
System.out.println("Menor igual que...");
System.out.println(" i <= j is "+(i<=j));//FALSO
System.out.println(" j <= i is "+(j<=i));//VERDADERO
System.out.println(" k <= j is "+(k<=j));//VERDADERO
System.out.println("Igual que...");
System.out.println(" i == j is "+(i==j));//FALSO
System.out.println(" j == i is "+(j==i));//VERDADERO
System.out.println(" k == j is "+(k==j));//VERDADERO
System.out.println("Diferente que...");
System.out.println(" i != j is "+(i!=j));//FALSO
System.out.println(" k != i is "+(k!=i));//VERDADERO
}
}
CFechaHora.java
import java.util.*;
public class CFechaHora
{
public static void main(String[] args)
{
GregorianCalendar fh1 = new GregorianCalendar();
System.out.println("Año: " + fh1.get(Calendar.YEAR) +
" Hora: " + fh1.get(Calendar.HOUR_OF_DAY));
GregorianCalendar fh2 = new GregorianCalendar(2001, 1, 21);
System.out.println("Año: " + fh2.get(Calendar.YEAR) +
" Hora: " + fh2.get(Calendar.HOUR_OF_DAY));
GregorianCalendar fh3 = new GregorianCalendar(2001, 1, 21, 12, 30, 15);
System.out.println("Año: " + fh3.get(Calendar.YEAR) +
" Hora: " + fh3.get(Calendar.HOUR_OF_DAY));
GregorianCalendar fh = new GregorianCalendar();
fh.set(Calendar.DAY_OF_MONTH, 21);
fh.set(Calendar.MONTH, 1);
fh.set(Calendar.YEAR, 2001);
System.out.println("Año: " + fh.get(Calendar.YEAR));
Date dfh = new Date();
System.out.println(dfh);
}
}
CAjedrez.java
// Leer.class debe estar en la carpeta especificada por CLASSPATH
public class CAjedrez
{
// Imprimir un tablero de ajedrez.
public static void main(String[] args)
{
int falfil, calfil; // posición inicial del alfil
int fila, columna; // posición actual del alfil
System.out.println("Posición del alfil:");
System.out.print(" fila "); falfil = Leer.datoInt();
System.out.print(" columna "); calfil = Leer.datoInt();
System.out.println(); // dejar una línea en blanco
// Pintar el tablero de ajedrez
for (fila = 1; fila <= 8; fila++)
{
for (columna = 1; columna <= 8; columna++)
{
if ((fila + columna == falfil + calfil) ||
(fila - columna == falfil - calfil))
System.out.print("* ");
else if ((fila + columna) % 2 == 0)
System.out.print("B ");
else
System.out.print("N ");
}
System.out.println(); // cambiar de fila
}
}
}
CCalculadora.java
import java.io.*;
// Leer.class debe estar en la carpeta especificada por CLASSPATH
public class CCalculadora
{
// Simulación de una calculadora
static int menú()
{
int op;
do
{
System.out.println("\t1. sumar");
System.out.println("\t2. restar");
System.out.println("\t3. multiplicar");
System.out.println("\t4. dividir");
System.out.println("\t5. salir");
System.out.print("\nSeleccione la operación deseada: ");
op = Leer.datoInt();
}
while (op < 1 || op > 5);
return op;
}
public static void main(String[ ] args)
{
double dato1 = 0, dato2 = 0, resultado = 0;
int operación = 0;
try
{
while (true)
{
operación = menú();
if (operación != 5)
{
// Leer datos
System.out.print("Dato 1: "); dato1 = Leer.datoDouble();
System.out.print("Dato 2: "); dato2 = Leer.datoDouble();
// Limpiar el buffer del flujo de entrada
System.in.skip(System.in.available());
// Realizar la operación
switch (operación)
{
case 1:
resultado = dato1 + dato2;
break;
case 2:
resultado = dato1 - dato2;
break;
case 3:
resultado = dato1 * dato2;
break;
case 4:
resultado = dato1 / dato2;
break;
}
// Escribir el resultado
System.out.println("Resultado = " + resultado);
// Hacer una pausa
System.out.println("Pulse [Entrar] para continuar");
System.in.read();
// Limpiar el buffer del flujo de entrada
System.in.skip(System.in.available());
}
else
break;
}
}
catch(IOException ignorada) {}
}
}