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);
}

}

TAREA1 DE ARREGLOS EN JAVA

CREACION DE UN ARREGLO

Los arreglos en Java son objetos, demostrando el compromiso de Java con la orientación a objetos. Un arreglo es una colección de objetos numerados del mismo tipo, en donde cada variable o celda en el arreglo tiene un índice. Las celdas están numeradas del 0 al N-1, donde N es el número de celdas del arreglo es decir su capacidad.
Los índices de un arreglo en Java deben estar dentro de los límites, 0 – N-1, de lo contrario se generará un error durante la ejecución.

Java implementa los arreglos como objetos que pueden ser tratados como cualquier otro objeto.

Para utilizar un arreglo en Java:
1. Declare una variable para que contenga el arreglo
2. Cree un nuevo arreglo de objeto y asígnelo a la variable de arreglo
3. Almacene información en ese arreglo
4. Realice operaciones de almacenamiento y recuperación con los elementos del arreglo
package arreglo1;
import javax.swing.*;

/**
*
* @author MARY
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int arreglo[]; // declarar la referencia a un arreglo
arreglo = new int[ 10 ]; // crear el arreglo
String salida = "Índice\tValor\n";
// anexar el valor de cada elemento del arreglo al String salida
for ( int contador = 0; contador < areasalida =" new" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiB8ioY6-LBBdamZhKT_hFys0uKllSREm27laM7vABLMyaQS0LgG17ok_XG1ND17-tYg8HpN1LMdTTx6hRRBuD_Ox0nsOBKFDdAzLoOuUdl58wlvNPsaJPeGQQaVqr9vKcLKebN4JurB4OA/s1600/Presentaci%C3%B3n1.jpg">

CREACION DE ARREGLOS CON OBJETOS

Después de haber declarado la variable arreglo, el siguiente paso es crear un arreglo de objetos y asignarlo a esa variable. Las formas de hacerlo son:
• a través del operador new
• inicializando directamente el contenido del arreglo


package arreglo1obj;

/**
*
* @author MARY
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
ArregloNombres a = new ArregloNombres();
a.imprime();
System.out.println("-----");
a.apellidos[0] = "Ritchie";
a.apellidos[1] = "Hopper";
a.apellidos[2] = "Stroustrup";
a.apellidos[3] = "Gosling";
a.imprime();

}

}
*****CLASE
package arreglo1obj;

/**
*
* @author MARY
*/
public class ArregloNombres {
String[] nombres = { "Dennis", "Grace", "Bjarne", "James"};
String[] apellidos = new String[nombres.length];

void imprime()
{
int i = 0;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
}

}


BIBLIOGRAFIA
http://delfosis.uam.mx/~sgb/Java/Arreglos.html

¿QUE ES HERENCIA?
Existen dos tipos de herencia sencilla y múltiple. Sencilla significa que sólo heredamos de una clase base, mientras que múltiple indica que tenemos varias clases base (por ejemplo un hidroavión hereda de barco y de avión). Java sólo soporta herencia simple.

SUPE Y THIS
this representa al objeto completo, en cambio super, sólo representa la parte heredada de la clase base.
Los constructores no son heredados, pero sí llamados. Es decir, cuando se construye un objeto de la clase derivada se llama al constructor de la clase derivada, pero antes de comenzar a ejecutarse se llama al constructor de la clase base, que tras ejecutarse continua la ejecución del constructor de la clase derivada.

/**
*
* @author MARY
*/
public class Main {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
// TODO code application logic here
// crear el objeto Cilindro
Punto punto;
circulo circulo1, circulo2;
punto = new Punto( 11, 22 );
System.out.println();

circulo1 = new circulo( 72, 29, 4.5 );
System.out.println();
circulo2 = new circulo( 5, 7, 10.67 );

punto = null; // se marca para la recolección de basura
circulo1 = null; // se marca para la recolección de basura

circulo2 = null; // se marca para la recolección de basura
System.out.println();
System.gc(); // llamar al recolector de basura


}
}

***********
package pruebaconstructorfinalizador;
import javax.swing.*;

/**
*
* @author MARY
*/
public class Punto {


private int x; // parte x del par de coordenadas

private int y; // parte y del par de coordenadas


// constructor sin argumentos

public Punto()

{

// la llamada implícita al constructor de Object ocurre aquí

System.out.println( "Constructor sin argumentos de Punto: " + this );

}


// constructor

public Punto( int valorX, int valorY )
{
// la llamada implícita al constructor de Object ocurre aquí

x = valorX; // no hay necesidad de validación
y = valorY; // no hay necesidad de validación
System.out.println( "Constructor de Punto: " + this );

}



// finalizador

protected void finalize()

{

System.out.println( "Finalizador de Punto: " + this );


}



// establecer x en el par de coordenadas

public void establecerX( int valorX )

{

x = valorX; // no hay necesidad de validación
}


// devolver x del par de coordenadas

public int obtenerX()

{

return x;
}
// establecer y en el par de coordenadas
public void establecerY( int valorY )

{

y = valorY; // no hay necesidad de validación
}


// devolver y del par de coordenadas

public int obtenerY()

{

return y;

}
// devolver la representación String del objeto Punto

public String toString()

{
return "[" + obtenerX() + ", " + obtenerY() + "]";
}
} // fin de la clase Punto

********
package pruebaconstructorfinalizador;

/**
*
* @author MARY
*/
public class circulo extends Punto {



private double radio; // el radio del Circulo


// constructor sin argumentos

/* public circulo()
{

// la llamada implícita al constructor de Punto ocurre aquí

System.out.println( "Constructor sin argumentos de Circulo: " + this );
}*/

// constructor
public circulo( int valorX, int valorY, double valorRadio )

{

super( valorX, valorY ); // llamar al constructor de Punto

establecerRadio( valorRadio );
System.out.println( "Constructor de Circulo: " + this );
}
// finalizador
protected void finalize()
{
System.out.println( "Finalizador de Circulo: " + this );

super.finalize(); // llamar al método finalize de la superclase

}
// establecer el radio

public void establecerRadio( double valorRadio )

{

radio = ( valorRadio < 0.0 ? 0.0 : valorRadio );

}

// devolver el radio
public double obtenerRadio()
{

return radio;

}
// calcular y devolver el diámetro
public double obtenerDiametro()

{
return 2 * obtenerRadio();
}

// calcular y devolver la circunferencia

public double obtenerCircunferencia()

{
return Math.PI * obtenerDiametro();
}

// calcular y devolver el área

public double obtenerArea()
{

return Math.PI * obtenerRadio() * obtenerRadio();
}

// devolver la representación String del objeto Circulo

public String toString()

{

return "Centro = " + super.toString() + "; Radio = " + obtenerRadio();

}

} // fin de la clase Circulo

***
package pruebaconstructorfinalizador;

/**
*
* @author MARY
*/
public class circulo4 extends punto3 {


private double radio; // El radio de Circulo4



// constructor sin argumentos
/*public Circulo4()

{

// La llamada implícita al constructor de Punto3 ocurre aquí
} */



// constructor

public circulo4( int valorX, int valorY, double valorRadio )

{

super( valorX, valorY ); // llamar explícitamente al constructor de Punto3

establecerRadio( valorRadio );

}



// establecer el radio

public void establecerRadio( double valorRadio )

{

radio = ( valorRadio < 0.0 ? 0.0 : valorRadio );

}



// devolver el radio

public double obtenerRadio()

{

return radio;

}



// calcular y devolver el diámetro

public double obtenerDiametro()

{

return 2 * obtenerRadio();

}



// calcular y devolver la circunferencia
public double obtenerCircunferencia()
{

return Math.PI * obtenerDiametro();

}



// calcular y devolver el área

public double obtenerArea()

{

return Math.PI * obtenerRadio() * obtenerRadio();
}



// devolver la representación String del objeto Circulo4
public String toString()

{

return "Centro = " + super.toString() + "; Radio = " + obtenerRadio();

}



} // fin de la clase Circulo4

*******
package pruebaconstructorfinalizador;

/**
*
* @author MARY
*/
public class punto3 {
private int x; // parte x de un par de coordenadas

private int y; // parte y de un par de coordenadas


// constructor sin argumentos

/* public Punto3()

{

// la llamada implícita al constructor de Object ocurre aquí
} */


// constructor


public punto3( int valorX, int valorY )

{

// la llamada implícita al constructor de Object ocurre aquí

x = valorX; // no hay necesidad de validación

y = valorY; // no hay necesidad de validación

}




// establecer x en el par de coordenadas

public void establecerX( int valorX )

{

x = valorX; // no hay necesidad de validación

}



// devolver x del par de coordenadas

public int obtenerX()

{

return x;

}



// establecer y en el par de coordenadas

public void establecerY( int valorY )

{

y = valorY; // no hay necesidad de validación

}



// devolver y del par de coordenadas

public int obtenerY()

{

return y;

}



// devolver la representación String del objeto Punto3

public String toString()
{

return "[" + obtenerX() + ", " + obtenerY() + "]";

}


} // fin de la clase Punto3
//

package pruebaconstructorfinalizador;
import java.text.DecimalFormat;
import javax.swing.JOptionPane;

TAREA4(ESTUDIANTES)

package estudiantes;
import javax.swing.JOptionPane;
/**
*
* @author Alumnos
*/
public class estudiante {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
String nombre,matricula,carrera,materia;
// TODO code application logic here
nombre=JOptionPane.showInputDialog ("Dame el nombre del alumno");
matricula=JOptionPane.showInputDialog("Dame el numero de matriucla");
carrera=JOptionPane.showInputDialog("Dime carrera");
materia=JOptionPane.showInputDialog ("Dame el nombre de la materia");

calificaciones C1 =new calificaciones();
/*C1.promedio();
JOptionPane.showInputDialog("EL PROMEDIO ES:"+promedio());*/


C1.datos();
JOptionPane.showMessageDialog(null,"EL PROMEDIO ES:"+"\n"+nombre+"\n"+matricula+"\n"+carrera+"\n"+materia+C1.datos());

C1.funcion();


}



}

*************************
package estudiantes;
import javax.swing.JOptionPane;
/**
*
* @author Alumnos
*/
public class calificaciones {
double cal1,cal2,cal3,promedio;
//,nombre,matricula,materia
//promedio
public calificaciones()
{

//System.out.println("LA LLAMADA AL CONSTRUCTOR");
/*nombre=Double.parseDouble(JOptionPane.showInputDialog ("Dame el nombre del alumno"));
matricula=Double.parseDouble(JOptionPane.showInputDialog("Dame el numero de matriucla"));
materia=Double.parseDouble(JOptionPane.showInputDialog ("Dame el nombre de la materia"));*/
cal1=Double.parseDouble(JOptionPane.showInputDialog("calificacion1:"));
cal2=Double.parseDouble(JOptionPane.showInputDialog("calificacion2:"));
cal3=Double.parseDouble(JOptionPane.showInputDialog("calificacion3:"));
}



public double promedio()
{
promedio=(cal1*.3+cal2*.3+cal3*.4);
return promedio;
}
public String datos()
{

String x;
x="\n calificacion1:"+cal1+"\n calificacion2:"+cal2+"\n calificacion3:"+cal3+"\nEl promedio es:"+promedio();
return x;

}
public void funcion(){
// promedio=(cal1*.3+cal2*.3+cal3*.4);
if(promedio<7)>=7)
{
JOptionPane.showMessageDialog(null,"MUY BIEN APROBADO"+promedio());
}
}


}

TAREA3(SUMA)

package ejemplosclase;
import javax.swing.JOptionPane;
/**
*
* @author Alumnos
*/
public class resultados {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
suma s1=new suma();
s1.datosenteros(8,4);
JOptionPane.showMessageDialog(null,"el valor de la suma es"+s1.sumenteros());


s1.datosdec ();
JOptionPane.showMessageDialog(null,"La suma es"+s1.sumdec());



}


}
***************************************************************


package ejemplosclase;
import javax.swing.JOptionPane;
/**
*
* @author Alumnos
*/
public class suma {
int a,b;
double x,y,suma;
public suma()

{

//sin codigo
}
public void datosenteros (int f, int z)

{
a=f;
b=z;
}
public void datosdec ()
{
double w,t;
w=Double.parseDouble(JOptionPane.showInputDialog("Dame un numero"));
t=Double.parseDouble(JOptionPane.showInputDialog("Dame un numero"));
x=w;
y=t;
}
public int sumenteros()
{
return a+b;

}
public double sumdec()
{
return x+y;
}
}

TAREA1

DEFINICION DE POO
Programación orientada a objetos (POO) .
La programación orientada a objetos es una técnica que permite optimizar los recursos usados en el desarrollo de un software, que satisface una necesidad, utilizando en el modelamiento de los problemas una herramienta de diseño llamadas clases, haciendo énfasis en el problema en general para resolverlo de manera particular para una mejor eficiencia y mantenimiento futuro.
CARACTERÍSTICAS DE POO
Abstracción:
Cada vez que pronunciamos una palabra, realmente lo que hacemos es asociar ese sonido (o ese conjunto de garabatos al escribir) con una serie de cosas. Decimos que una ave es tal cosa, que una silla es tal otra, etc.
Cuando vamos a aplicar la POO, lo primero que debemos hacer es cumplir con una vieja máxima de guerra: Divide y Vencerás. Es decir, lo que hacemos es seccionar nuestro código en grupos de código más pequeño que, al unirlos, hacen el trabajo. Un buen ejemplo de abstracción es el cuerpo humano, aunque el cuerpo es una unidad, está dividido en lo que conocemos por sistemas (el sistema respiratorio, el sistema linfático, cardiovascular, etc., etc.). Estos sistemas, a su vez están compuestos por otros más pequeños: los órganos, y así sucesivamente. La abstracción nos permite dividir nuestro programa en distintos objetos que se agrupan para formar cosas más complejas.
Encapsulación:
También conocida como ocultamiento. La encapsulación se encarga de mantener ocultos los procesos internos que necesita para hacer lo que sea que haga, dándole al programador acceso sólo a lo que necesita. Esto da dos ventajas iniciales: Lo que hace el usuario puede ser controlado internamente (incluso sus errores).
Herencia:
Uno de los elementos (a mi modo de ver) más interesantes de la P.O.O. La herencia es la capacidad que tiene una clase de derivar las propiedades y métodos de otra .
La herencia nos permite, entre otras cosas, evitar tener que escribir el mismo código una y otra vez, puesto que al definir que una categoría (que en programación llamaremos clase) pertenece a otra, automáticamente estamos atribuyéndoles las características generales de la primera, sin tener que definirlas de nuevo.
CARACTERÍSTICAS DE JAVA:
Potente
a.) Orientación a objetos
En este aspecto Java fue diseñado partiendo de cero, no siendo derivado de otro lenguaje anterior y no tiene compatibilidad con ninguno de ellos.
En Java el concepto de objeto resulta sencillo y fácil de ampliar. Además se conservan elementos "no objetos", como números, caracteres y otros tipos de datos simples.

b.) Riqueza semántica
Pese a su simpleza se ha conseguido un considerable potencial, y aunque cada tarea se puede realizar de un número reducido de formas, se ha conseguido un gran potencial de expresión e innovación desde el punto de vista del programador.

c.) Robusto
Java verifica su código al mismo tiempo que lo escribe, y una vez más antes de ejecutarse, de manera que se consigue un alto margen de codificación sin errores. Se realiza un descubrimiento de la mayor parte de los errores durante el tiempo de compilación, ya que Java es estricto en cuanto a tipos y declaraciones, y así lo que es rigidez y falta de flexibilidad se convierte en eficacia. Respecto a la gestión de memoria, Java libera al programador del compromiso de tener que controlar especialmente la asignación que de ésta hace a sus necesidades específicas. Este lenguaje posee una gestión avanzada de memoria llamada gestión de basura, y un manejo de excepciones orientado a objetos integrados. Estos elementos realizarán muchas tareas antes tediosas a la vez que obligadas para el programador.

d.) Modelo de objeto rico
Existen varias clases que contienen las abstracciones básicas para facilitar a los programas una gran capacidad de representación. Para ello se contará con un conjunto de clases comunes que pueden crecer para admitir todas las necesidades del programador.
Además la biblioteca de clases de Java proporciona un conjunto único de protocolos de Internet.
El conjunto de clases más complicado de Java son sus paquetes gráficos AWT (Abstract Window Toolkit) y Swing. Estos paquetes implementan componentes de una interfaz de usuario gráfica básica común a todos los ordenadores personales modernos.
C. Simple
a.) Fácil aprendizaje

El único requerimiento para aprender Java es tener una comprensión de los conceptos básicos de la programación orientada a objetos. Así se ha creado un lenguaje simple (aunque eficaz y expresivo) pudiendo mostrarse cualquier planteamiento por parte del programador sin que las interioridades del sistema subyacente sean desveladas.
Java es más complejo que un lenguaje simple, pero más sencillo que cualquier otro entorno de programación. El único obstáculo que se puede presentar es conseguir comprender la programación orientada a objetos, aspecto que, al ser independiente del lenguaje, se presenta como insalvable.

b.) Completado con utilidades
El paquete de utilidades de Java viene con un conjunto completo de estructuras de datos complejas y sus métodos asociados, que serán de inestimable ayuda para implementar applets y otras aplicaciones más complejas. Se dispone también de estructuras de datos habituales, como pilas y tablas hash, como clases ya implementadas.
Existirá una interfaz Observer/Observable que permitirá la implementación simple de objetos dinámicos cuyo estado se visualiza en pantalla.
El JDK (Java Development Kit) suministrado por Sun Microsystems incluye un compilador, un intérprete de aplicaciones, un depurador en línea de comandos, y un visualizador de applets entre otros elementos.
D. Interactivo y orientado a red
a.) Interactivo y animado
Uno de los requisitos de Java desde sus inicios fue la posibilidad de crear programas en red interactivos, por lo que es capaz de hacer varias cosas a la vez sin perder rastro de lo que debería suceder y cuándo. Para se da soporte a la utilización de múltiples hilos de programación (multithread).
Las aplicaciones de Java permiten situar figuras animadas en las páginas Web, y éstas pueden concebirse con logotipos animados o con texto que se desplace por la pantalla. También pueden tratarse gráficos generados por algún proceso. Estas animaciones pueden ser interactivas, permitiendo al usuario un control sobre su apariencia.

b.) Arquitectura neutral
Java está diseñado para que un programa escrito en este lenguaje sea ejecutado correctamente independientemente de la plataforma en la que se esté actuando (Macintosh, PC, UNIX…). Para conseguir esto utiliza una compilación en una representación intermedia que recibe el nombre de códigos de byte, que pueden interpretarse en cualquier sistema operativo con un intérprete de Java. La desventaja de un sistema de este tipo es el rendimiento; sin embargo, el hecho de que Java fuese diseñado para funcionar razonablemente bien en microprocesadores de escasa potencia, unido a la sencillez de traducción a código máquina hacen que Java supere esa desventaja sin problemas.

c.) Trabajo en red
Java anima las páginas Web y hace posible la incorporación de aplicaciones interactivas y especializadas. Aporta la posibilidad de distribuir contenidos ejecutables, de manera que los suministradores de información de la Web pueden crear una página de hipertexto (página Web) con una interacción continuada y compleja en tiempo real; el contenido ejecutable es transferido literalmente al ordenador del usuario.
Los protocolos básicos para trabajar en Internet están encapsulados en unas cuantas clases simples. Se incluyen implementaciones ampliables de los protocolos FTP, HTTP, NNTP y SMTP junto con conectores de red de bajo nivel e interfaces de nombrado. Esto le permite interactuar con esos servicios de red poderosos sin tener que comprender realmente los detalles de bajo nivel de esos protocolos. Este lenguaje está diseñado para cumplir los requisitos de entrega de contenidos interactivos mediante el uso de applets insertados en sus páginas HTML. Además, las clases de Java admiten muy bien estos protocolos y formatos. El envío de las clases de Java a través de Internet se realiza con gran facilidad, ya que existe una interfaz unificada, resolviendo así los típicos problemas de diferencia de versiones.
Java proporciona un conjunto de clases para tratar con una abstracción de los conectores de red (sockets) originales de la versión UNIX de Berckley, encapsular la noción de una dirección de Internet o conectar sockets con flujos de datos de Entrada/Salida.
Con todas estas posibilidades aumenta el dinamismo y competitividad de la Web, puesto que es capaz de captar el interés del usuario durante largo tiempo y permite a los programadores convertir la Web en un sistema de entrega de software.

d.) Applets
Una applet (miniaplicación) es un pequeño programa en Java transferido dinámicamente a través de Internet. Presentan un comportamiento inteligente, pudiendo reaccionar a la entrada de un usuario y cambiar de forma dinámica. Sin embargo, la verdadera novedad es el gran potencial que Java proporciona en este aspecto, haciendo posible que los programadores ejerzan un control sobre los programas ejecutables de Java que no es posible encontrar en otros lenguajes.


La Máquina Virtual Java
La Máquina Virtual Java (JVM) es el entorno en el que se ejecutan los programas Java, su misión principal es la de garantizar la portabilidad de las aplicaciones Java. Define esencialmente un ordenador abstracto y especifica las instrucciones (bytecodes) que este ordenador puede ejecutar. El intérprete Java específico ejecuta las instrucciones que se guardan en los archivos cuya extensión es .class.
Las tareas principales de la JVM son las siguientes:
• Reservar espacio en memoria para los objetos creados
• Liberar la memoria no usada (garbage collection).
• Asignar variables a registros y pilas
• Llamar al sistema huésped para ciertas funciones, como los accesos a los dispositivos
• Vigilar el cumplimiento de las normas de seguridad de las aplicaciones Java
Esta última tarea, es una de las más importantes que realiza la JVM. Además, las propias especificaciones del lenguaje Java contribuyen extraordinariamente a este objetivo:
• Las referencias a arrays son verificadas en el momento de la ejecución del programa
• No hay manera de manipular de forma directa los punteros
• La JVM gestiona automáticamente el uso de la memoria, de modo que no queden huecos.
• No se permiten realizar ciertas conversiones (casting) entre distintos tipos de datos.
Por ejemplo, cuando el navegador encuentra una página web con un applet, pone en marcha la JVM y proporciona la información que aparece en la etiqueta
... . El cargador de clases dentro de la JVM ve que clases necesita el applet. Dentro del proceso de carga, las clases se examinan mediante un verificador que asegura que las clases contienen código válido y no malicioso. Finalmente, se ejecuta el applet.


EL APRENDIZ
http://thefricky.wordpress.com/2007/12/28/programacion-orientada-a-objetos-caracteristicas-de-la-poo/
AUTORES
DIRECTOR DEL PROYECTO COORDINADOR TÉCNICO
Miguel Ángel Manzanedo del Campo Francisco José García Peñalvo
Área de Organización de Empresas Área de Ciencias de la Computación e Inteligencia Artificial
Dpto. de Ingeniería Civil Dpto. de Informática y Automática
Universidad de Burgos Universidad de Salamanca

http://zarza.usal.es/~fgarcia/doc/tuto2/I_3.htm
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/introduccion/virtual.htm

TAREA2(tipos de datos en java)

TIPOS DE DATOS EN JAVA
Tipos de datos enteros
Se usan para representar números enteros con signo. Hay cuatro tipos: byte, short, int y Long.

Tipos de datos en coma flotante
Se usan para representar números con partes fraccionarias. Hay dos tipos de coma flotante: float y double. El primero reserva almacenamiento para un número de precisión simple de 4 bytes y el segundo lo hace para un numero de precisión doble de 8 bytes.

Conversión de tipos de datos
En Java es posible transformar el tipo de una variable u objeto en otro diferente al original con el que fue declarado. Este proceso se denomina "conversión", "moldeado" o "tipado". La conversión se lleva a cabo colocando el tipo destino entre paréntesis, a la izquierda del valor que queremos convertir de la forma siguiente:
char c = (char)System.in.read();
La función read devuelve un valor int, que se convierte en un char debido a la conversión (char), y el valor resultante se almacena en la variable de tipo carácter c.
El tamaño de los tipos que queremos convertir es muy importante. No todos los tipos se convertirán de forma segura. Por ejemplo, al convertir un long en un int, el compilador corta los 32 bits superiores del long (de 64 bits), de forma que encajen en los 32 bits del int, con lo que si contienen información útil, esta se perderá.
Por ello se establece la norma de que "en las conversiones el tipo destino siempre debe ser igual o mayor que el tipo fuente":



AUTORES

DIRECTOR DEL PROYECTO
COORDINADOR TÉCNICO

Miguel Ángel Manzanedo del Campo
Francisco José García Peñalvo

Área de Organización de Empresas
Área de Ciencias de la Computación e Inteligencia Artificial

Dpto. de Ingeniería Civil
Dpto. de Informática y Automática

Universidad de Burgos
Universidad de Salamanca

NOMBRE DEL ARTICULO: Guía de Iniciación al Lenguaje JAVA
VERSIÓN 2.0 - Octubre de 1999
http://zarza.usal.es/~fgarcia/doc/tuto2/Index.htm

Blog Marisol