TAREA DEL CATCH

EXCEPCIONES EN JAVA
Se pueden definir excepciones propias, no hay por qué limitarse a las predefinidas; bastará con extender la clase Exception y proporcionar la funcionalidad extra que requiera el tratamiento de esa excepción.
También pueden producirse excepciones no de forma explícita como en el caso anterior, sino de forma implícita cuando se realiza alguna acción ilegal o no válida.
Las excepciones, pues, pueden originarse de dos modos: el programa hace algo ilegal (caso normal), o el programa explícitamente genera una excepción ejecutando la sentencia throw (caso menos normal). La sentencia throw tiene la siguiente forma:
throw ObtejoExcepction;
El objeto ObjetoException es un objeto de una clase que extiende la clase Exception.
El siguiente código de ejemplo origina una excepción de división por cero:
class melon {
public static void main( String[] a ) {
int i=0, j=0, k;

k = i/j; // Origina un error de division-by-zero
}
}
Si compilamos y ejecutamos esta aplicación Java, obtendremos la siguiente salida por pantalla:
> javac melon.java
> java melon
java.lang.ArithmeticException: / by zero
at melon.main(melon.java:5)
Las excepciones predefinidas, como ArithmeticException, se conocen como excepciones runtime. Actualmente, como todas las excepciones son eventos runtime, sería mejor llamarlas excepciones irrecuperables. Esto contrasta con las excepciones que generamos explícitamente, que suelen ser mucho menos severas y en la mayoría de los casos podemos recuperarnos de ellas. Por ejemplo, si un fichero no puede abrirse, preguntamos al usuario que nos indique otro fichero; o si una estructura de datos se encuentra completa, podremos sobreescribir algún elemento que ya no se necesite.
CAPTURAR EXCEPCIONES
Las excepciones lanzadas por un método que pueda hacerlo deben recoger en bloque try/catch o try/finally.
int valor;
try {
for( x=0,valor = 100; x <> 40 )
throw( new demasiadoCalor() );
if( dormir < i="0," j="0," k =" i/j;"> javac melon.java
> java melon
java.lang.ArithmeticException: / by zero
at melon.main(melon.java:5)

/////
Otro método que es heredado de la superclase Throwable es printStackTrace(). Invocando a este método sobre una excepción se volcará a pantalla todas las llamadas hasta el momento en donde se generó la excepción (no donde se maneje la excepción). Por ejemplo:
// Capturando una excepción en un método
class testcap {
static int slice0[] = { 0,1,2,3,4 };

public static void main( String a[] ) {
try {
uno();
} catch( Exception e ) {
System.out.println( "Captura de la excepcion en main()" );
e.printStackTrace();
}
}

static void uno() {
try {
slice0[-1] = 4;
} catch( NullPointerException e ) {
System.out.println( "Captura una excepcion diferente" );
}
}
}
//Cuando se ejecute ese código, en pantalla observaremos la siguiente salida:
> Captura de la excepcion en main()
> java.lang.ArrayIndexOutOfBoundsException: -1
at testcap.uno(test5p.java:19)
at testcap.main(test5p.java:9)

PROYECTO_FINIQUITO

integrantes:
Sandra Solis Barraza
Marisol Vargas Cortes

******MAIN*******
package proyecto_finiquito;
import javax.swing.*;
import java.util.GregorianCalendar ;
import java.util.Calendar ;
import java.util.Date;
/**
*
* @author Sandra
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int mes_egr,mes_ing,año_egr,año_ing;
String nom,puest,datosimp,imprimir_todo;
double suel_men,sdiario,mesfin,mes_cumsuel_men;
int dias_f, mess_f,añoss_f,dias_i, mess_i, añoss_i,dia_f, dia_i;
// TODO code application logic here
int j,iniaño,inimes,finaño,finmes;
double f_total=0,AGUINALDO,
FINIQUITO,PRIMAVACACIONAL;
String nombre,puesto;
// CALCULO_FINIQUITO tra[] = new CALCULO_FINIQUITO[4];
CALCULO_FINIQUITO emp[] = new CALCULO_FINIQUITO[4];


for(j = 0; j<3 nom =" JOptionPane.showInputDialog(" puest =" JOptionPane.showInputDialog(" suel_men =" Double.parseDouble(JOptionPane.showInputDialog(" mes_ing =" Integer.parseInt(JOptionPane.showInputDialog(" o_ing =" Integer.parseInt(JOptionPane.showInputDialog(" mes_egr =" Integer.parseInt(JOptionPane.showInputDialog(" o_egr =" Integer.parseInt(JOptionPane.showInputDialog(" aguinaldo =" emp[j].anual();" finiquito =" emp[j].JUBILACION();" primavacacional =" emp[j].primav();" f_total =" f_total" j =" 0;" imprimir_todo =" emp[j].agui()" imprimir_todo =" emp[j].DATOS_EMPLEADO()+" o="="0)" vacaciones =" 5;" primavac =" pagodiario">= 1 && año <=2) { vacaciones = 5; primavac = pagodiario * 5; } else if(año >= 3 && año <=5) { vacaciones = 10; primavac = pagodiario * (10); } else if(año >= 5)
{
vacaciones = 15;
primavac = pagodiario * 15;
}
return primavac;
}

public String PRIMA_VACACIONAL()
{
primav = "VACACIONES: "+ vacaciones+" Dias\n$ DE PRIMA VACACIONAL: $ "+primavac;
return primav;
}



}
********CLASE EMPLEADO ********

package proyecto_finiquito;
import javax.swing.*;
/**
*
* @author Sandra
*/
public class EMPLEADO {
int salario_dia,meses,dias,mes_ing,año_egr,año_ing,año=0;
String nombre,puesto,DATOS;
double sueldom,pagodiario,mes_egr,mesess;
public EMPLEADO()
{

}

public void SUELDO_DIARIO(String nom,String pues, double sueldo,int añoingreso, int mesingreso,int añoegreso, double mesegreso)

{

nombre = nom;
puesto = pues;
sueldom=sueldo;
año_ing=añoingreso;
mes_ing=mesingreso;
año_egr=añoegreso;
mes_egr=mesegreso;
año = año_egr - año_ing;
mesess = (12 - mes_ing) + mes_egr;
if(mesess >= 12)
{
año = año + 1 - 1;
mesess = mesess - 12;
}
pagodiario = sueldom/30;
}
public String DATOS_EMPLEADO()
{
DATOS = "NOMBRE: "+nombre+"\nPUESTO: "+puesto+"\nSUELDO MENSUAL: $ "+sueldom+"\nTIEMPO TRABAJADO "+año+" AÑOS TRABAJADOS CON "+mesess +" MESES";
return DATOS;
}

}
******CLASE CALCULO_FINIQUITO*****
package proyecto_finiquito;

/**
*
* @author Sandra
*/
public class CALCULO_FINIQUITO extends PRIMA_VACACIONAL {
String fin;
double jubilacion,fin_mensual,años_t;
public CALCULO_FINIQUITO()
{

}

public double JUBILACION()
{

años_t = año * 45;
fin_mensual = (mesess * 45) / 12;
jubilacion = (años_t + fin_mensual) * pagodiario;

return jubilacion;
}

public String FIN()
{
fin = "JUBILACION: $ "+jubilacion;
return fin;
}
}
********CALCULO_AGUINALDO****
public class CALCULO_AGUINALDO extends EMPLEADO {
String pago_anual;
double tiepo_dima,tiempo_dia,aguinaldo;

public CALCULO_AGUINALDO()
{

}
/*proporcion de aguinaldo 45 dias del año de salario.*/
public double anual()
{


if(año == 0)
{

//resta_mes = mes_fin - mes_ini;
tiepo_dima = ((mes_egr*1.0) * 45) / 12;
aguinaldo = tiempo_dia * pagodiario;
}
else if(año >= 1 )
{
tiempo_dia = (mes_egr * 45) / 12;
aguinaldo = (tiempo_dia * pagodiario);
}
return aguinaldo;
}
public String agui()
{
pago_anual = "Pago por aguinaldo: $ "+ aguinaldo;
return pago_anual;
}

}

**************PANTALLAS******************

QUE ES POLIMORFISMO
El polimorfismo se refiere a la posibilidad de definir clases diferentes que tienen métodos o atributos denominados de forma idéntica, pero que se comportan de manera distinta.
Por ejemplo, podemos crear dos clases distintas: Pez y Ave que heredan de la superclase Animal. La clase Animal tiene el método abstracto mover que se implementa de forma distinta en cada una de las subclases (peces y aves se mueven de forma distinta).
Clasificación
Se puede clasificar el polimorfismo en dos grandes clases:
• Polimorfismo dinámico (o polimorfismo paramétrico) es aquél en el que el código no incluye ningún tipo de especificación sobre el tipo de datos sobre el que se trabaja. Así, puede ser utilizado a todo tipo de datos compatible.
• Polimorfismo estático (o polimorfismo ad hoc) es aquél en el que los tipos a los que se aplica el polimorfismo deben ser explicitados y declarados uno por uno antes de poder ser utilizados.
El polimorfismo dinámico unido a la herencia es lo que en ocasiones se conoce como programación genérica.
También se clasifica en herencia por redefinición de métodos abstractos y por método sobrecargado. El segundo hace referencia al mismo método con diferentes parámetros.
Otra clasificación agrupa los polimorfismo en dos tipos: Ad-Hoc que incluye a su vez sobrecarga de operadores y coerción, Universal (inclusión o controlado por la herencia, paramétrico o genericidad).
Uso de Polimorfismo utilizando "Casting":
El termino "Casting" viene de la palabra "Cast" que significa Molde, por lo que el termino literal es Hacer un Molde, en Polimorfismo se lleva acabo este proceso de "Casting" implícitamente, una Guitarra se coloca en el molde de un Instrumento, un Triangulo en el molde de una Figura, sin embargo, en ciertas ocasiones se requiere realizar un tipo de "Casting" que no es considerado seguro en términos computacionales.
Anteriormente se mencionó que el "Casting" llevado acabo con Polimorfismo es implícito, esto se debe a que no se requiere de sintaxis especial, simplemente se convierte una Guitarra a un Instrumento, sin embargo, para llevar una transformación en sentido opuesto se requiere de sintaxis adicional para mantener la seguridad de transformación; analicemos: mientras se puede asegurar que un Triangulo es una Figura ("Up-Casting"), una Figura no necesariamente es un Triangulo, claro esta que lo puede ser, pero en Java se requiere definir explícitamente esta operación ("Down-Casting").
El uso practico de "Down-Casting" será explorado en la sección de Vectores y "Hashtables"

LIks paginas:
http://es.wikipedia.org/wiki/Polimorfismo_%28inform%C3%A1tica%29
http://javacafesv.blogspot.com/2009/05/polimorfismo-en-java.html
CLASE ABSTRACTA
Una de las características más útiles de cualquier lenguaje orientado a objetos es la posibilidad de declarar clases que definen como se utiliza solamente, sin tener que implementar método. Esto en Java se hace mediante interfaces y con clases abstractas.
Una clase abstracta es una clase de la que no se puede crear objetos. La utilidad de estas clases estriba en que otras clases hereden de ésta, por lo que con ello conseguiremos reutilizar código. Para declarar una clase como abstracta utilizamos la palabra clave abstract.
Los métodos para los que no aporte una implementación serán declarados a su vez abstractos. Si una clase tiene un método abstract es obligatorio que la clase sea abstract. Todas las subclases que hereden de una clase abstracta tendrán que redefinir los métodos abstractos dándoles una implementación. En el caso de que no implementen alguno de esos métodos la clase hija también será abstracta y tendrá que declararse como tal (tanto la clase como los métodos que siguen siendo abstractos).
En método abstract no pude ser static, ya que estos no pueden ser redifinidos por las subclases.
Reglas de uso:
• Una clase abstracta solo puede ser usada como clase base para otras clases, pero no puede ser instanciada para crear un objeto 1.
• Una clase abstracta no puede ser utilizada como argumento o como retorno de una función 2.
• Si puede declararse punteros-a-clase abstracta 3 [1].
• Se permiten referencias-a-clase abstracta, suponiendo que el objeto temporal no es necesario en la inicialización 4.
Link pagina:
http://www.zator.com/Cpp/E4_11_8c.htm

******************
DIFERENTES CLASES
La Clase Double

Cada tipo numérico tiene su propia clase de objetos. Así el tipo double tiene el objeto Double . De la misma forma que con la clase Character , se han codificado muchas funciones útiles dentro de los métodos de la clase Double .
Declaraciones
La primera sentencia creará una variable double y la segunda un objeto Double:
double d;
Double D;


* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

String s="Mary";
String s1=s.replace('a', 'a');
System.out.println(s);
System.out.println(s1);
}

}















La Clase Float

Cada tipo numérico tiene su propia clase de objetos. Así el tipo float tiene el objeto Float . De la misma forma que con la clase Character , se han codificado muchas funciones útiles dentro de los métodos de la clase Float .
Declaraciones
La primera sentencia creará una variable float y la segunda un objeto Float:
float f;
Float F;
Conversiones de Clase/Cadena
String s = Float.toString( f );
f = Float.valueOf( "3.14" );



La Clase Integer

Cada tipo numérico tiene su propia clase de objetos. Así el tipo int tiene el objeto Integer . De la misma forma que con la clase Character , se han codificado muchas funciones útiles dentro de los métodos de la clase Integer .
Declaraciones
La primera sentencia creará una variable int y la segunda un objeto Integer:
Integer.MIN_VALUE;
Integer.MAX_VALUE;
Valores de Integer
Integer.MIN_VALUE;
Integer.MAX_VALUE;



La Clase Boolean

Los valores boolean también tienen su tipo asociado Boolean , aunque en este caso hay menos métodos implementados que para el resto de las clases numéricas.
Declaraciones
La primera sentencia creará una variable boolean y la segunda un objeto Boolean:

boolean b;
Boolean B;
Valores de Boolean

Boolean.TRUE;
Boolean.FALSE;



La Clase Long

Cada tipo numérico tiene su propia clase de objetos. Así el tipo long tiene el objeto Long . De la misma forma que con la clase Character , se han codificado muchas funciones útiles dentro de los métodos de la clase Long .
Declaraciones
La primera sentencia creará una variable long y la segunda un objeto Long:
long l;
Long L;
Valores de Long
Long.MIN_VALUE;
Long.MAX_VALUE;

La Clase Character

Al trabajar con caracteres se necesitan muchas funciones de comprobación y traslación. Estas funciones están empleadas en la clase Character . De esta clase sí que se pueden crear instancias, al contrario que sucede con la clase Math .
Declaraciones
La primera sentencia creará una variable carácter y la segunda un objeto Character:

char c;
Character C;

La Clase String


Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y StringBuffer . Un objeto String representa una cadena alfanumérica de un valor constante que no puede ser cambiada después de haber sido creada. Un objeto StringBuffer representa una cadena cuyo tamaño puede variar.
Los Strings son objetos constantes y por lo tanto muy baratos para el sistema. La mayoría de las funciones relacionadas con cadenas esperan valores String como argumentos y devuelven valores String.
Hay que tener en cuenta que las funciones estáticas no consumen memoria del objeto, con lo cual es más conveniente usar Character que char. No obstante, char se usa, por ejemplo, para leer ficheros que están escritos desde otro lenguaje.
Existen muchos constructores para crear nuevas cadenas:
String();
String( String str );
String( char val[] );
String( char val[],int offset,int count );
String( byte val[],int hibyte );
String( byte val[],int hibyte,int offset,int count );
Tal como uno puede imaginarse, las cadenas pueden ser muy complejas, existiendo muchas funciones muy útiles para trabajar con ellas y, afortunadamente, la mayoría están codificadas en la clase String .

Funciones Básicas
La primera devuelve la longitud de la cadena y la segunda devuelve el carácter que se encuentra en la posición que se indica en indice :

int length();
char charAt( int indice )

MÉTODOS PRINCIPALES:
Para poder aplicar estos métodos es necesario crear un objeto String. Además de estos métodos, la clase String cuenta con otros muchos. Consultar la API para más información.
• int length(): devuelve la longitud de la String, incluyendo espacios en blanco. La longitud siempre es una unidad mayor que el índice asociado al último carácter de la String.
Ejemplo:

Por consola:
4
• int indexOf(String str, int indice): devuelve el índice en el que aparece por primera vez la String del primer argumento en la que se aplica el método, a partir del índice especificado en el segundo argumento. Recordar que una String está indexada. Si el índice a partir del que se inicia la búsqueda no existe o la String no aparece, devuelve -1. MUY USADO.
Ejemplo:

Por consola:
-1 porque la búsqueda se inicia a partir de un índice que no existe ya que el índice mayor es la longitud de la String -1.

• int indexOf(char ch): devuelve el índice en el que aparece por primera vez el carácter que se le pasa al argumento. Si no se encuentra el carácter devuelve -1. Se observa que el nombre de este método es igual al anterior aunque su número de argumentos es distinto además de su tipo. A esto, en Java, se le llama sobrecarga de métodos: mismo nombre pero distinto nº de argumentos o distinto tipo de argumentos o distinto orden. Ir a la API para comprobar que hay más con este mismo nombre. Este concepto se tratará más en profundidad en temas posteriores.
• String replace (char viejoChar, char nuevoChar): cambia el carácter asociado al primer argumento por el que se le pasa al segundo, de la String sobre la que se aplica el método generando una nueva. La String sobre la que se aplica el método no cambia, simplemente se crea otra nueva en base a la String sobre la que se aplica el método.
Ejemplo:

Por consola:
cucu
coco
• String toLowerCase(): devuelve una nueva String convirtiendo todos los caracteres de la String sobre la que se aplica el método, en minúsculas.
• String toUpperCase(): devuelve una nueva String convirtiendo todos los caracteres de la String sobre la que se aplica el método, en mayúsculas.
• boolean equals(String str): investiga si dos String tienen los mismos caracteres y en el mismo orden. Si es así devuelve true y si no false. MUY USADO
• boolean equalsIgnoreCase(String str): investiga si dos String tienen los mismos caracteres y en el mismo orden sin tener en cuenta las mayúsculas. Si es así devuelve true y si no false. MUY USADO
• boolean startsWith(String str): devuelve true si la String sobre la que se aplica comienza por la del argumento; false si esto no ocurre.
• boolean startsWith(String str, int indice): devuelve true si la String sobre la que se aplica comienza por la del argumento a partir de un determinado índice asociado al segundo argumento; false si esto no ocurre.
• boolean endsWith(String str): devuelve true si la String sobre la que se aplica acaba en la del argumento; false si esto no ocurre.
• String trim(): devuelve una String en base a la que se le pasa al argumento, pero sin espacios en blanco al principio ni al final. No elimina los espacios en blanco situados entre las palabras.
Ejemplo:

Por consola:
14
12
• String substring(int indiceIni, int indiceFin): devuelve una String obtenida a partir del índice inicial incluido y del índice final excluido; es decir, se comporta como un intervalo semiabierto [indiceIni, indiceFin). Si el índice final sobrepasa la longitud de la String, lanza una IndexOutOfBoundsException. MUY USADO.
Ejemplo:

Por consola:
rrucu
• char charAt (int indice): devuelve el carácter asociado al índice que se le pasa como argumento de la String sobre la que se aplica el método. Si el índice no existe se lanza una StringIndexOutOfBoundsException que hereda de IndexOutOfBoundsException. MUY USADO.

****programas
public class PROGRAMA1 {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

String s="Marisol Vargas Cortes";
int longitud=s.length();
System.out.println(longitud);
}

}