Java Antonio Regalado José Francisco Méndez García Rodolfo Salazar Carmona José Antonio Contenido



Descargar 63,35 Kb.
Fecha de conversión31.05.2017
Tamaño63,35 Kb.

Java

  • Antonio Regalado José Francisco
  • Méndez García Rodolfo
  • Salazar Carmona José Antonio

Contenido

Historia

  • Java fue diseñado en 1990 por James Gosling, de Sun Microsystems
    • fue diseñado antes de que diese comienzo la era World Wide Web,
    • software para dispositivos electrónicos de consumo.
    • fue diseñado para dispositivos electrónicos como calculadoras,
    • microondas y la televisión interactiva
    • Lenguaje que independiente de la plataforma
  • El lenguaje Java evolucionó de un lenguaje llamado Oak.
  • (A Oak se le cambio el nombre a Java)
  • Historia (..cont)
    • software para dispositivos electrónicos de consumo.
    • Diseñado para calculadoras, celulares, microondas,
    • la televisión interactiva, etc.
  • El objetivo fue recoger las idear un nuevo lenguaje de
  • programación lo más sencillo posible, con el objeto de que se
  • pudiese adaptar con facilidad a cualquier entorno de ejecución.
  • Se conjuntaron las características esenciales que debía tener un
  • lenguaje de programación moderno y potente.
  • Historia (..cont)
  • El proyecto Green fue el primero en el que se aplicó Java (OAK)
    • sistema de control completo de los aparatos electrónicos y el entorno de un hogar.
    • Se construyó un computadora denominada *7 (Star Seven).
    • El control se llevaba a cabo mediante una pantalla sensible al tacto.
    • En el sistema aparecía ya Duke, la actual mascota de Java.
  • Historia (..cont)
  • Java se aplicó a otro proyecto denominado VOD (Video On Demand)
    • como interfaz para la televisión interactiva
    • nunca se convirtió en un sistema comercial
    • cuando se dieron cuenta de que la televisión interactiva no iba a ser negocio, se enfocaron a la aplicación de Java a Internet.
  • Historia (..cont)
  • RESUMEN:
    • 1990: Sun Microsystems diseña un lenguaje diseñado para sistemas embebidos,(set-top-boxes), electrodomésticos.
    • Lenguaje sencillo, pequeño, neutro.
    • Ninguna empresa muestra interés por el lenguaje
    • 1995: Java se introduce en Internet, lenguaje muy apropiado
    • Netscape 2.0 introduce la primera JVM en un navegador WWW (Máquina virtual Java)
    • Filosofía Java: “Write once, run everywhere”
  • Historia (..cont)
  • RESUMEN:
    • 1997: Aparece Java 1.1. Muchas mejoras respecto a 1.0
    • 1998: Java 1.2 (Java 2). Plataforma muy madura
    • Apoyado por grandes empresas: IBM, Oracle, Inprise, Hewtlett-Packard, Netscape, Sun
    • 1999: Java Enterprise Edition. Java comienza a ser una plataforma de desarrollo profesional.
  • Historia (..cont)

Contenido

  • Historia.
  • Aspectos de diseño
  • Aspectos de traducción
  • Tipos y objetos
  • Encapsulación
  • Herencia
  • Control de Secuencia
  • Control en Subprogramas
  • Administración de almacenamiento
  • Procesamiento distribuido

Aspectos de diseño

  • Directrices en el diseño de Java:
  • Crear un L.P. orientado a objetos
    • Datos “strongly typed”
    • Con el poder de C++, sin sus debilidades:
    • apuntadores y su aritmética
    • herencia multiple.
    • Variables globales.
  • Seguridad en el código y facilidad de desarrollo.
  • Aspectos de diseño (cont.)
  • 3. Independencia de la arquitectura (creación de la JVM)
  • Código fuente
  • Compilador Java
  • Byte-codes
  • Win32 JVM
  • Código máquina
  • Win32
  • Macintosh JVM
  • UNIX JVM
  • Código máquina
  • Macintosh
  • Código máquina
  • UNIX

Aspectos de diseño

  • 4. Seguridad para el usuario
  • 5. Permitir que en los programas existieran mas de un flujo de ejecución (Threads)
  • 6. Garbage collection
  • La JVM
  • Es una máquina imaginaria que se implementa por software
  • Su lenguaje máquina se denomina byte codes.
  • Sun publicó las especificaciones para la máquina virtual de Java
  • para asegurar la portabilidad de las aplicaciones.
  • La JVM (cont.)
  • Las especificaciones para la JVM abarcan:
    • El set de instrucciones (como los de un microprocesador)
    • El conjunto de registros
    • Formato de los archivos .class
    • La pila
    • El área de Garbage-collected heap.
    • El área de memoria

La traducción y momentos de ligado.

  • Por ser “strongly typed”, casi todo el chequeo y enlaces de tipos se hacen en tiempo de compilación.
  • La “compilación” se refiere a la conversión del programa
  • hecho por el programador a byte-codes.
  • Sin embargo por ser un lenguaje interpretado, los enlaces se
  • calculan en tiempo de ejecución.
  • En alguno sistemas, una parte del código se compila realmente
  • en código maquina, pero después que la JVM hizo chequeos de
  • integridad.

La traducción y momentos de ligado.

  • Byte-Codes Verifier
  • Class Loader
  • Interpreter
  • JIT Compiler
  • Runtime
  • HARWDARE

Paradigma

  • Java esta diseñado para el paradigma de orientación a objetos.
  • class Circle {
  • private double radius; static double pi = 3.1416;
  • public double getCircumference( ) { } public static double getCircumference(double radius) { } public void setRadius(double radius) { } public double getRadius( ) { }
  • // constructors public Circle( ) { } public Circle(double radius) { }
  • // main( ) method
  • }

Contenido

  • Historia.
  • Aspectos de diseño
  • Aspectos de traducción
  • Tipos y objetos
  • Encapsulación
  • Herencia
  • Control de Secuencia
  • Control en Subprogramas
  • Administración de almacenamiento
  • Procesamiento distribuido
  • COMENTARIOS
  • // comentario Los caracteres desde // hasta el final de la línea son ignorados
  • /* comentario */ Los caracteres entre /* y */ son ignorados
  • /** comentario */ Los caracteres entre /** y */son ignorados y se incluyen en la generación autómatica de la documentación.
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • IDENTIFICADORES
  • Nombre dado a una variable, un método o una clase
  • Comienzan con una letra Unicode (incluyendo _ and $) y seguido de letras y digitos
  • Pueden ser de cualquier longitud
  • Ejemplos:
    • Apellido
    • Hora
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • El Bloque
  • {
  • }
  • public class MyClass {
  • int a; static int b;
  • public void myMethod( ) { int c; if (condition) { int d; } fuera del alcance de d } fuera del alcance de c
  • } fuera del alcance de a
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Variables
  • Una variable es un dato con nombre.
  • Precedencia de las variables
  • Variables locales declaradas en un bloque
  • Como parámetros de un método
  • Instancias y variables de una clase.
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Constantes
  • Una vez inicializada, ya no pueden cambiar
  • Se usa la palabra reservada final
    • class Circle {
    • static final double  = 3.1416;
    • }
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Arreglos
  • int[ ] x; (Es equivalente a int x[ ])
  • X
  • 10
  • 20
  • 30
  • x[1] = 20;
  • x[2] = 30;
  • x[0] = 10;
  • x = new int[3];
    • x.length da la longitud del arreglo.
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Operadores
  • Asignación
  • = -= /=
  • += *= %=
  • Aritméticos
  • + Suma
  • - Resta
  • * Multiplicación
  • / Division
  • % Modulo
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Operadores
  • Incremento
  • ++ i++
  • -- i--
  • Relacionales
  • > mayor que >= mayor o igual que
  • < menor que <= menor o igual que
  • == igual que != diferente que
  • Lógicos
  • && and || or !not
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Operadores
  • De bits
  • & and << corrimiento izq.
  • | or >> corrimiento der.
  • ^ xor >>> corrimiento der. con
  • ˜ complemento llenado con ceros
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Sentencias de control de flujo
  • if / else
  • if ( country.equals("USA") ) {
  • export = false;
  • } else {
  • export = true;
  • }
  • switch
  • switch ( ) {
  • case : . . . break;
  • case : . . . break;
  • default: . . .
  • }
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Sentencias de control de flujo
  • for
  • for ( x=0; x<10; x++ ) {
  • // Se ejecuta el bloque mientras x sea menor a 10
  • }
  • while (Ejecución cero o más veces)
    • while ( boolean_expression )
    • { block }
  • do / while (Ejecución al menos una vez)
  • do
    • { block }
    • while ( boolean_expression );
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Sentencias de control de flujo
  • break (termina la ejecución del loop y la ejecución continua en la siguiente instrucción después del loop)
  • int ix;
    • for (ix=0; ix < ArraySize; ix++) {
    • if Array[ix]<0 {
    • System.out.println(“Error: negative number encountered, index = “ +ix);
    • break;
    • }
    • ProcessArray(Array[ix]);
    • } // end for
  • Aspectos de traducción
  • Elementos sintácticos del lenguaje
  • Sentencias de control de flujo
  • Labeled Loops (versión extendida de break, útil en loops anidados, termina la ejecución de loops anidados)
    • err:
    • for (ix=0; ix < ArraySize; ix++ ){
    • for(j=0; j
    • System.out.println(“Error: negative number encountered, index = “ +ix “,” + j);
    • break err;
    • }
    • ProcessArray(Array[ix][j]);
    • }

Contenido

  • Historia.
  • Aspectos de diseño
  • Aspectos de traducción
  • Tipos y objetos
  • Encapsulación
  • Herencia
  • Control de Secuencia
  • Control en Subprogramas
  • Administración de almacenamiento
  • Procesamiento distribuido
  • Tipos y objetos
  • TIPOS DE DATOS
    • boolean true or false
    • char 16-bit Unicode character
    • byte 8-bit integer (signed)
    • short 16-bit integer (signed)
    • int 32-bit integer (signed)
    • long 64-bit integer (signed)
    • float 32-bit floating-point number
    • double 64-bit floating-point number

Contenido

  • Historia.
  • Aspectos de diseño
  • Aspectos de traducción
  • Tipos y objetos
  • Encapsulación
  • Herencia
  • Control de Secuencia
  • Control en Subprogramas
  • Administración de almacenamiento
  • Procesamiento distribuido
  • Encapsulación
  • La abstracción en java se maneja utilizando clases abstractas.
  • Una clase abstract se usa como clase base para la herencia.
  • Ejemplo
  • public abstract class Geometria{
    • public abstract double perimetro();
    • public abstract double area();
  • }
  • Encapsulación
  • Las subrutinas se manejan definiendo metodos en las clases que serán llamados desde otras clases.
  • public class Circulo extends Geometria{
    • static int numCirculos = 0;
    • private static final double PI = 3.1416
    • private double x,y,r;
    • public double perimetro() {
    • return 2.0 * PI * r;
    • }
  • }
  • Encapsulación
  • Los métodos (funciones) pueden regresar cualquier tipo de “objeto dato” primitivo o estructura de datos.
  • public static Circulo elMayor(Circulo c, Circulo d) {
    • if c.getRadio() >= d.getRadio()
    • return c;
    • else
    • return d;
  • }
  • Encapsulación
  • La encapsulación se puede lograr creando métodos para establecer y obtener valores a los atributos.
  • Public double getRadio( ) {
    • return r;
  • }
  • Public void setRadio(double unRadio) {
    • r=unRadio;
  • }
  • Encapsulación
  • El ocultamiento de la información en java se logra con la clausula private.
  • Las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de la clase.
  • ...
  • private Vector v;
  • private void dibuja (Vector vect ) {
    • Enumeration e;
    • v=vect;
    • e=v.elements();
    • while(e,hasMoreElements()){
    • ...
    • }
  • }
  • ...
  • Encapsulación
  • La especificación de un subprograma en java es de la siguiente manera
  • import java.awt;//sección de importaciones
  • public class nombreDeClase extends ClasePadre {
    • Definición de variables...
    • Definición de métodos...
  • }
  • Encapsulación
  • La invocación de métodos desde una clase se realiza creando una instancia de la clase a invocar y después llamando a cualquier método.
  • import ...
  • public class Figuras extends Applet
  • {
  • ...
  • public void paint (Graphics g)
  • {
  • int x=10, y=10, anchura=80, altura=50;
  • //llamada al método drawRect de la clase Graphics
  • g.drawRect(x,y,anchura,altura);
  • }
  • }

Contenido

  • Historia.
  • Aspectos de diseño
  • Aspectos de traducción
  • Tipos y objetos
  • Encapsulación
  • Herencia
  • Control de Secuencia
  • Control en Subprogramas
  • Administración de almacenamiento
  • Procesamiento distribuido
  • Herencia
  • Mecanismo por el que se crean nuevos objetos definidos en términos de objetos ya existentes.
  • public class Articulo { // clase padre
  • public float precio=0;
  • ...
  • public void setPrecio(float elPrecio) {
  • precio = elPrecio;
  • }
  • ...
  • public float getPrecio() {
  • return precio;
  • }
  • }
  • //los métodos y atributos de Articulo son heredados a Pelicula
  • public class Pelicula extends Articulo {// clase hijo
  • public void setDescripcion(String descrip) {
  • descripcion = descrip;
  • }
  • ...
  • public String getDescripcion() {
  • return descripcion;
  • }
  • }
  • Herencia
  • Tipos de Clases en Java
  • abstract
  • Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia.
  • final
  • Una clase final se declara como la clase que termina una cadena de herencia.
  • public
  • Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Para acceder desde otros paquetes, primero tienen que ser importadas.
  • Herencia
  • Nivel de acceso a métodos y atributos
  • public
  • Cualquier clase desde cualquier lugar puede acceder a las variables y métodos.
  • protected o friendly
  • Sólo las subclases de la clase y nadie más puede acceder a las variables y métodos.
  • private
  • Las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de la clase.
  • Herencia
  • Paquetes
  • Se usan para encapsular los datos de manera automática.
  • Los paquetes de clases se cargan con la palabra clave import.
  • Ejemplos:
  • import java.Date;
  • import java.awt.*;
  • import miPaquete.miClase;
  • Herencia
  • Paquetes de java
  • java.applet
  • Contiene clases para usar applets en páginas web.
  • java.awt (Abstract Windowing Toolkit)
  • Contiene clases para diseñar interfases de usuario. Incluye las clases Button, Checkbox, Choice, Component, Graphics, Menu, Panel, TextArea y TextField.
  • java.io
  • Contiene las clases de acceso a archivos.
  • Herencia
  • Herencia Simple
  • Java no pueda utilizar herencia multiple, en lugar de ello utiliza interfases.
  • La interfase proporciona un mecanismo de encapsulación de los protocolos de los métodos.
  • Una interfaz es como un molde donde se declaran nombres de métodos, listas de argumentos, tipos de retorno y miembros datos.
  • Herencia
  • Implementación de una interfaz
  • public interface VideoClip {
  • void play( ); // Comienza la reproducción del video.
  • void loop( ); // Reproduce el video en un ciclo.
  • void stop( ); // Detiene la reproducción.
  • }
  • Herencia
  • Implementación de una interfaz
  • class MiClase implements VideoClip {
  • void play( ) {
  • }
  • void loop( ) {
  • }
  • void stop( ) {
  • }
  • }
  • Herencia
  • Polimorfismo
  • Es utilizado para implementar comportamientos diferentes.
  • abstract class Vehiculo
  • {
  • abstract String Sonido( );
  • }
  • class VehiculoTierra extends Vehiculo
  • {
  • String Sonido( )
  • {
  • return "ruuuuuuun";
  • }
  • }
  • class VehiculoAire extends Vehiculo
  • {
  • String Sonido( )
  • {
  • return "buzzzzzzzz";
  • }
  • }
  • Herencia
  • public class Polimorfismo
  • {
  • public static void main(String[] args)
  • {
  • //declaramos un objeto abstracto llamado mi_vehiculo
  • Vehiculo mi_vehiculo;
  • VehiculoTierra mi_coche;
  • VehiculoAire mi_avion;
  • mi_coche = new VehiculoTierra();
  • mi_avion = new VehiculoAire();
  • System.out.println(mi_coche.Sonido());
  • System.out.println(mi_avion.Sonido());
  • //asignamos mi_coche a un objeto abstracto
  • mi_vehiculo = mi_coche;
  • System.out.println(mi_vehiculo.Sonido());
  • //Asignamos mi_avion a un objeto abstracto
  • mi_vehiculo = mi_avion;
  • System.out.println(mi_vehiculo.Sonido());
  • }
  • }
  • Herencia
  • Polimorfismo utilizando sobrecarga de métodos
  • public class Sumar {
  • public float suma(float a, float b) {
  • return a + b;
  • }
  • public int suma(int a, int b) {
  • return a + b;
  • }
  • public String suma(String a, String b) {
  • String espacioBlanco = “ “;
  • return a + espacioBlanco + b;
  • }
  • public static void main(String[] args) {
  • System.out.println(suma(5,2));
  • System.out.println(suma(5.5,2.2));
  • System.out.println(suma(“Hola”,”Mundo”));
  • }
  • }

Contenido

  • Historia.
  • Aspectos de diseño
  • Aspectos de traducción
  • Tipos y objetos
  • Encapsulación
  • Herencia
  • Control de Secuencia
  • Control en Subprogramas
  • Administración de almacenamiento
  • Procesamiento distribuido
  • Control de secuencia
  • Orden de precedencia implicita de operadores
  • . [] ()
  • ++ --
  • ! ~ instanceof
  • + -
  • << >> >>>
  • < > <= >= == !=
  • & ^ |
  • && ||
  • ? :
  • = op= (*= /= %= += -= etc.)
  • Control de secuencia
  • Operadores a nivel de bits
  • Operando >> desplazamiento (Desplaza bits hacía la derecha con signo)
  • Operado << Desplazamiento (Desplaza bitd hacía la izquierda)
  • Operando >>> Desplazamiento (Desplaza bits hacía la derecha, sin signo)
  • Operando & Operando (Realiza una operación AND lógica)
  • Operando | Operando (Realiza una operación OR lógica)
  • Operando ^ Operando (Realiza una operación OR exclusiva)
  • ~Operando (Complemento del operando)
  • Control de secuencia
  • Alternancia (secuencia implicita)
  • if () {
  • ... //código bloque 1}
  • else if () {
  • ... //código bloque 2
  • }
  • else {
  • ... //código bloque 3
  • }
  • switch (){
  • case : < código bloque 1 >;
  • break;
  • case : < código bloque 2 >;
  • break;
  • default : < código bloque 3 >;
  • }
  • Control de secuencia
  • Iteraciones (secuencia implicita)
  • for ( ; ; ) {
  • }
  • while ( ) {
  • }
  • do{
  • }
  • while ();
  • Control de secuencia
  • Control de secuencia explicita
  • break Se utiliza en una sentencia swicth o en una iteración
  • int x = 0;
  • while (x < 10){
  • System.out.println("dentro de la iteración");
  • x++;
  • if (x == 5)
  • break;
  • else
  • ... //instrucciones a ejecutar si x es menor que 5
  • }
  • Control de secuencia
  • Control de secuencia explicita
  • continue Se utiliza en iteraciones. Sirve para terminar la iteración en la que se encuentre el ciclo y se inicia la siguiente.
  • for ( int x = 0 ; x < 10 ; x++){
  • if(x == 5)
  • continue; //regresa al principio del ciclo con x=6
  • System.out.println("dentro de la iteración");
  • }
  • Control de secuencia
  • Control de secuencia explicita
  • return Se utiliza para terminar un método o función y opcionalmente devolver un valor al método de llamada.
  • int func (){
  • if(a == 0)
  • return 1;
  • return 0 ;
  • }
  • Control de secuencia
  • Control de secuencia explicita
  • En caso de que nos encontremos con ciclos anidados, se permite el uso de etiquetas para poder salirse de ellos.
  • uno: for( )
  • {
  • dos: for( )
  • {
  • continue; // seguiría en el bucle interno
  • continue uno; // seguiría en el bucle principal
  • break uno; // se saldría del bucle principal
  • }
  • }

Contenido

  • Historia.
  • Aspectos de diseño
  • Aspectos de traducción
  • Tipos y objetos
  • Encapsulación
  • Herencia
  • Control de Secuencia
  • Control en Subprogramas
  • Administración de almacenamiento
  • Procesamiento distribuido

Métodos

  • Es una función definida en una clase
  • Son necesarios para la manipulación de datos contenidos en una clase.
  • Encapsulan funciones de un programa en bloques separados
    • Se hace más fácil la revisión de programas
    • Se hace más fácil el mantenimiento de los programas.
  • Son bloques separados de código.
  • Envían “mensajes” a otros métodos.
  • Tienen variables locales
  • Pueden regresar valores

Flujo de control de un método

  • Si el método llamado esta dentro de la misma clase, solo el nombre del método es necesario.
  • miMetodo();
  • miMetodo
  • computo

Flujo de control de un método

  • Si el método forma parte de otra clase u objeto.
  • calVec
  • impVec
  • impVec();
  • obj.calVec();
  • main

Agregando métodos

  • Los métodos son declarados dentro del cuerpo de la clase, inmediatamente después de la declaración de variables instanciadas.
  • La forma general de una declaración de método es:
    • tipo nombreDelMetodo (listaParametros)
    • {
    • cuerpoMetodo;
    • }
  • La declaración de un método tiene cuatro partes básicas:
    • El nombre del método (nombreDelMetodo)
    • El tipo del valor de regreso del método (tipo).
    • Una lista de parámetros (listaParametros).
    • El cuerpo del método (cuerpoMetodo).

Parámetros

  • Las variables en la lista de parámetros son separadas por comas
  • La lista de los parámetros en la especificación del método, son llamados parámetros formales.
  • Cuando un método es llamado, estos parámetros formales son reemplazados por los parámetros actuales.
  • Los actuales parámetros deben ser equivalentes en tipo, orden y número.

Parámetros

  • char calc (int num1, int num2, String mensaje)
  • {
  • int sum = num1 + num2;
  • char result = mensaje.charAt (sum);
  • return result;
  • }
  • count = 3
  • ch = obj.calc (2, count, “Hola Mundo");

Paso por valor

  • Cuando es invocado un método con un parámetro de tipo primitivo, tal como “int”, el valor del actual parámetro es pasado al método.
  • Esta es una llamada por valor
  • El valor actual fuera del método no es afectado, independientemente de los cambios hechos al parámetro formal dentro del método.

Ejemplo de paso por valor

  • class PruebaPasoPorValor
  • {
  • public static void main(String[] args)
  • {
  • int times = 3;
  • System.out.println(“Antes del llamado, la variable times es”+times);
  • nPrintln(“Bienvenido a Java!”,times);
  • System.out.println(“Despues del llamado, la variable times es” + times);
  • }
  • static void nPrintln(String mensaje, int n)
  • {
  • while (n > 0)
  • {
  • System.out.println(“n = “+n);
  • System.out.println(mensaje);
  • n--;
  • }
  • }
  • }

Paso por referencia

  • Se pueden pasar objetos a métodos como parámetros actuales
  • Cuando se pasa un objeto al método la referencia del objeto es pasado al parámetro formal
  • Cualquier cambio al objeto local que ocurra dentro del cuerpo afectara el objeto original que fue pasado como argumento.

Ejemplo de paso por referencia

  • class PruebaPasoPorReferencia
  • {
  • public static void main(String[] args)
  • {
  • Circulo miCirculo = new Circulo(5.0, “blanco”);
  • imprimeCirculo(miCirculo);
  • colorCirculo(miCirculo, “negro”);
  • imprimeCirculo(miCirculo);
  • }
  • public static void colorCirculo( Circle c, String color)
  • {
  • c.color = color;
  • }
  • public static void imprimeCirculo(Circle c)
  • {
  • System.out.println(“El área del circulo de radio ”+c.getRadio( ) + “ es “+c.Area());
  • System.out.println(“El color del Circulo es “ +c.color);
  • }

Continuación…

  • class Circulo
  • {
  • private double radio;
  • String color;
  • public Circulo(double r, String c)
  • {
  • radio = r;
  • color = c;
  • }
  • public double getRadio( )
  • { return radio; }
  • public double Area( )
  • { return radio*radio*Math.PI;}
  • }

Llamado de métodos

  • Son llamados a través del nombre del método seguido de paréntisis izquierdo, después los argumentos separados por coma, por ultimo paréntisis derecho.
  • Int masGrande = max(3,4)
    • Llama al método max(3,4) y asigna el resultado del método a la variable masGrande.
    • Argumentos pueden ser constantes, variables o expresiones.
  • Normalmente los métodos es Java son invocados a través de una referencia a un objeto.
  • g.drawString(“Bienvenido”,10,10);
    • Invoca al método drawString a través de la referencia del objeto g.

Cuando el método se termina

  • Hay dos formas de regresar el control al punto en el cual un método fue invocado.
    • Si el método no regresa nada, el control se tiene cuando el método finaliza , ya sea cuando se encuentra el “}” asociado con el método o con el “return”.
  • Si el método regresa un resultado, la expresión:
    • return expresión
      • Regresa el valor de la expresión.

Reglas de alcance

  • Alcance de clase
    • Los métodos y variables instanciadas de una clase tienen un alcance de clase.
    • El alcance de la clase empieza con “{“ después de la definición de la clase y termina con “}” asociado a la definición de la clase.
    • El alcance de la clase habilita todos los métodos de una clase definidos en la misma clase o clases heredadas dentro de la clase.

Reglas de alcance

  • Alcance de bloque
    • Los identificadores declarados dentro de un bloque tienen alcance de bloque.
    • El alcance de bloque de un identificador empieza con su declaración y termina con el parentesis “}” asociado al bloque.
    • Cualquier bloque puede contener variables o referencia a declaraciones.
    • Cuando existen bloques anidados en el cuerpo de un método y un identificador en un bloque externo tiene el mismo nombre que un identificador que se encuentra en un bloque interno, el compilador genera un error.

Métodos 1 :Código Local

  • método fnx()
    • Es ‘public’
    • Nombre fnx
    • Realiza una impresión
    • No pasa mensajes
    • Tipo ‘void’
    • No tiene un valor de regreso
    • Tiene una variable local ‘d’
  • Class myClass {
  • int a, b = 12;
  • public static void main (String args[])
  • {
  • int c=12;
  • a = b + c;
  • fnx();
  • System.out.println(a);
  • }
  • public static void fnx()
  • {
  • int d=2;
  • System.out.println(“ d “ +d);
  • }

Métodos 2: Enviando un mensaje

  • fnx(int) ahora recibe un mensaje
  • El valor es copiado dentro de la variable local ‘c’
  • La variable local ‘c’ es puesta a 0
  • cmain permane con 12
  • Salida:
    • d+c = 14
    • 12
  • Class myClass {
  • int a, b = 12;
  • public static void main (String args[])
  • {
  • int c=12;
  • a = b + c;
  • fnx(c);
  • System.out.println(c);
  • }
  • public static void fnx(int c)
  • {
  • int d=2;
  • System.out.println(“d+c=“+(d+c));
  • c=0;
  • }

Métodos 3: Múltiples parámetros

  • Los métodos pueden ser llamados con múltiples parámetros
  • Los parámetros en la llamada pueden ser:
    • Identificadores (var/const)
    • Literales
    • Expresiones.
    • Lista de parámetros
      • ([tipo nombre][,tipo nombre])
  • Class myClass {
  • int a, b = 12;
  • public static void main (String args[])
  • {
  • int c=12;
  • a = b + c;
  • fnx(c,1);
  • System.out.println(c);
  • }
  • public static void fnx(int c, byte by)
  • {
  • int d;
  • d = (int) by;
  • System.out.println(“d+c=“+(d+c));
  • c=0;
  • }

Métodos 4: Regresando valores

  • Llamada por valor
  • Usa ‘return’ para enviar valores de regreso
  • Los métodos toman un valor de regreso y tipo.
  • Se pueden asignar valores del método() a variables.
  • Class myClass {
  • int a, b = 12;
  • public static void main (String args[])
  • {
  • int c=12;
  • a = b + c;
  • fnx(c,1);
  • System.out.println(c);
  • }
  • public static void fnx(int c, byte by)
  • {
  • int d;
  • d = (int) by;
  • System.out.println(“d+c=“+(d+c));
  • c=0;
  • }

Contenido

  • Historia.
  • Aspectos de diseño
  • Aspectos de traducción
  • Tipos y objetos
  • Encapsulación
  • Herencia
  • Control de Secuencia
  • Control en Subprogramas
  • Administración de almacenamiento
  • Procesamiento distribuido

Administración de memoria

  • Java utiliza un modelo de memoria conocido como "administración automática del almacenamiento” (automatic storage management), en el cual el sistema en tiempo de ejecución mantiene un seguimiento de los objetos.

Arquitectura interna de la JVM

  • Areas de datos en tiempo de ejecución
  • registros
  • pc
  • Stack
  • Java
  • Area de
  • métodos
  • Stack
  • métodos
  • nativos
  • Subsistema
  • cargador de
  • clases
  • Motor de ejecucion
  • Interface de
  • métodos nativos
  • Librerias de
  • métodos nativos
  • Archivos class
  • heap

Arquitectura interna de la JVM

  • Subsistema cargador de clases:
    • Un mecanismo para cargas clases o interfaces.
  • Motor de ejecución:
    • Un mecanismo para la ejecución de las instrucciones contenidas en los métodos de las clases cargadas.
  • Area de datos en tiempo de ejecución:
    • Una área de memoria para guardar bytescodes(área de métodos), objetos (heap), parámetros, valores de retorno, variables locales, (stack) resultados o cálculos intermedios (stack).
    • La especf. de JVM es abstracta, por lo tanto los diseñadores tienen libertad para implementar la JVM.
    • Algunas áreas de datos son compartidas por threads de las aplicaciones y otras áreas son únicas para ciertos threads.

Arquitectura interna de la JVM

  • Area de métodos y heap:
    • Cada instancia de la JVM posee un área de métodos y un área de heap.
    • El área de métodos y heap es compartida por threads que se ejecutan dentro la maquina virtual.
    • Cuando la JVM carga un archivo class, esta analiza la información contenida en el archivo binario y luego la coloca en el área de métodos.
    • Cuando un programa se ejecuta, la JVM coloca todos los objetos del programa instanciados dentro del área de heap.

Area de métodos y área de heap

  • datos
  • de la
  • clase
  • datos
  • de la
  • clase
  • datos
  • de la
  • clase
  • datos
  • de la
  • clase
  • Area de métodos
  • Objeto
  • Objeto
  • Objeto
  • Objeto
  • Objeto
  • Objeto
  • Objeto
  • Objeto
  • Objeto
  • Area de heap
  • Cargador
  • de
  • clases
  • datos
  • de la
  • clase
  • Archivos class

Arquitectura interna de la JVM

  • Registros PC:
    • Un apuntador a la próxima instrucción a ser ejecutada
  • Stack de Java:
    • Es donde son colocados parámetros, valores de regreso, variables locales, resultados o cálculos intermedios.
    • El Stack de Java esta compuesto por frames.
    • Un frame de stack contiene el estado de un método de Java que ha sido llamado.
    • Cuando un thread hace un llamado a un método, la JVM guarda un nuevo frame dentro del stack de Java del thread correspondiente.
    • Cuando un método se termina, la JVM hace un pop y descarta el frame del método.

Threads

  • Thread:
    • Es un flujo de secuencia de ejecución que ocurre al mismo tiempo que otra secuencia de ejecución esta ejecutando alguna expresión del mismo programa.
    • En la JVM cada thread tiene su propia registro pc y su Stack java.
  • Java soporta aplicaciones multi-threads.
  • Multi-thread:
    • Un proceso puede ser dividido en varios threads de control los cuales se ejecutan al mismo tiempo.

Area de datos de threads en tiempo de ejecución

  • thread 1
  • thread 2
  • thread 3
  • pc registers
  • stack
  • frame
  • stack
  • frame
  • stack
  • frame
  • stack
  • frame
  • thread 1
  • stack
  • frame
  • stack
  • frame
  • stack
  • frame
  • thread 2
  • java stacks
  • stack
  • frame
  • stack
  • frame
  • thread 3
  • thread 3
  • native
  • method
  • stacks

Arquitectura interna de la JVM

  • Stacks de Java:
    • Guardan el estado de invoación de un método en Java.
  • Stack de métodos nativos:
    • Guardan el estado de un llamado de un método nativo.

Recolector de basura (GC)

  • La función primaria de un GC es reclamar automáticamente la memoria usada por los objetos que no tienen referencia en la aplicación que se ejecutando actualmente.
  • Esta también puede mover objetos de la aplicación que se esta ejecutando para evitar la fragmentación del heap.
  • El GC no es requerido en la especificación de la JVM.
  • La especificación solo requiere que una implementación maneje el heap de alguna forma.
  • La especificación de la JVM no dice cuanta memoria debe dejar una implementación para poder ejecutar programas.
  • La JVM no menciona como una implementación debe manejar su heap.

Recolector de basura (GC)

  • La especificación de la JVM solo menciona a los diseñadores de la implementación solo que el programa deberá reservar memoria del heap, pero no la liberación de esta.
  • Deja a los diseñadores el resolver esta característica.
  • Los diseñadores pueden usar cualquier técnica y que sea la mas apropiada dado sus objetivos, restricciones y talento.
  • El hecho de que las referencias a los objetos pueden existir en varios lugares (Stack Java, el heap, el área de métodos, stack de métodos nativos), la elección de la técnica de recolección de basura tiene una influencia mayor en el diseño de una implementación.

Recolector de basura (GC)

  • Como en el área de métodos y en el área del heap la memoria no necesita ser continua y puede ser expandida y contraida como el programa avanza en tiempo de ejecución.
  • Una implementación del área de métodos deberia ser implementada en la parte superior de su heap.
  • Cuando una JVM necesita memoria para una clase que va a ser cargada, esta puede tomar memoria del mismo heap en los cuales los objetos residen.
  • El mismo GC que libera memoria ocupada por objetos sin referencia, podria hacer la busqueda y liberación de clases que no tienen referencia.
  • Las implementaciones pueden permitir a los usuarios especificar un tamaño inicial para el heap, asi como un tamaño minimo y maximo.

Recolección de basura

  • Java usa mark-and-sweep.
  • Altamente confiable, pero puede causar inexplicables bajas de velocidad.
  • Java realiza la recolección de basura cuando el programa tiene algún tiempo de reserva
  • Se puede invocar al recolector usando el método gc de la clase System.

Contenido

  • Historia.
  • Aspectos de diseño
  • Aspectos de traducción
  • Tipos y objetos
  • Encapsulación
  • Herencia
  • Control de Secuencia
  • Control en Subprogramas
  • Administración de almacenamiento
  • Procesamiento distribuido

Remote Method Invocation (RMI)

  • Las aplicaciones RMI son compuestas de dos programas separados
    • Un servidor y un cliente
  • RMI provee un mecanismo en el cual el servidor y el cliente se comunican y pasan información.
  • Tales aplicaciones son también llamadas aplicaciones de objetos distribuidas.

Aplicaciones de objetos distribuidos

  • Las aplicaciones de objetos distribuidos necesitan:
    • Localizar objetos remotos
    • Comunicarse con objetos remotos
    • Cargar bytecodes de clases para clases que son pasados alrededor.

Aplicaciones de objetos distribuidos

  • Localizar objetos remotos.
    • Una aplicación puede registrar sus objetos remotos con facilidad , utilizando rmiregistry.
    • La aplicación puede pasar y regresar una referencia a un objeto remoto como parte de su operación normal.

Aplicaciones de objetos distribuidos

  • Los detalles de comunicación entre objetos remotos son manejados por RMI
  • Para el programador, la comunicación remota se ve como una invocación de un método de Java.

Aplicaciones de objetos distribuidas

  • La carga de bytecodes para objetos que son pasados alrededor
    • RMI permite a un llamador pasar objetos a objetos remotos.
    • RMI provee los mecanismos necesarios para la carga de código de un objeto, también de su transmisión de sus datos.

Creando aplicaciones distribuidas

  • Diseñar e implementar los componentes de la aplicación distribuida.
    • Compilar los fuentes y generar stubs.
    • Hacer que las clases estén accesibles a través de la red.
    • Comenzar la aplicación.

Creando aplicaciones distribuidas

  • Compilar los fuentes y generar los stubs
    • Use javac para compilar los archivos fuentes, los cuales contienen la implementación de las interfaces remotas, las clases del servidor y las clases clientes.
    • use rmic para crear stubs para los objetos remotos.
    • RMI usa una clase stub de objeto remoto como un proxy en clientes, así los clientes pueden comunicarse con un objeto remoto en particular.

Creando aplicaciones distribuidas

  • Hacer que las clases estén disponibles en la red.
    • Hacer que los archivos de las clases asociados con las interfaces remotas, stubs, y otras clases que necesiten ser bajadas sean accesibles vía un servidor Web
  • Comenzar la aplicación
    • Comenzar la aplicación incluye correr el programa de registro de objetos remotos de RMI.

Ejemplo de RMI

  • Del lado del cliente
    • MyObject.java
    • RemoteClient1.java
    • RemoteClient2.java
  • Del lado del servidor
    • RemoteServer.java
    • RemoteInterface.java
    • MyObject.java

Escribiendo un servidor RMI

  • Nuestro servidor RMI acepta tareas de clientes, ejecuta las tareas, y regresa cualquier valor.
  • El servidor esta compuesto de una interface y una clase.
  • La interface provee la definición de los métodos que pueden ser llamados desde el cliente.
    • Esencialmente la interface define la vista del cliente del objeto remoto.

Diseñando una interface Remota

  • La interface provee la definición de los métodos que pueden ser llamados desde el cliente.
  • El cliente manda un tarea al servidor remoto.
  • El resultado de la tarea es enviado de regreso al cliente.
  • Cada una de las interfaces contiene un solo método.

Interface remota

  • La interface RemoteInterface solo define un método, msgsnd, el cual pasa en un objeto Myobjeto y regresa el objeto Myobjeto y puede realizar una excepción.
  • /* RemoteInterface.java */
  • public interface RemoteInterface extends java.rmi.Remote {
  • MyObject msgsend (MyObject message) throws
  • java.rmi.RemoteException;
  • }

Myobject.java

  • public class MyObject implements java.io.Serializable {
  • private int x;
  • private String msg;
  • public MyObject (String s) {
  • msg = s;
  • x = msg.length();
  • }
  • public int lenMsg() { //Longitud de msg
  • return x;
  • }
  • public String getMsg() { // obtiene un msg
  • return msg;
  • }
  • public void setMsg(String s) { // coloca un msg
  • msg = s;
  • }
  • }

Implementando una interface remota

  • import java.rmi.*;
  • import java.rmi.server.UnicastRemoteObject;
  • public class RemoteServer extends UnicastRemoteObject
  • implements RemoteInterface{
  • String name;
  • public RemoteServer(String name)
  • throws RemoteException{
  • super();
  • this.name = name;
  • }
  • public MyObject msgsend(MyObject message)
  • throws RemoteException{
  • System.out.println("mensaje obtenido:" + message.getMsg() +
  • ", Longitud del mensaje:" + message.lenMsg());
  • message.setMsg("Mi nombre es:" + name +
  • ",Gracias por tu mensaje:"+ message.getMsg());
  • return message;
  • }

Continuación...

  • public static void main (String args[]){
  • System.out.println(”Ejecutando servidor ...");
  • System.setSecurityManager
  • (new RMISecurityManager());
  • try{
  • String myName = "ObjectServer Test";
  • RemoteServer theServer =
  • new RemoteServer(myName);
  • Naming.rebind(myName,theServer);
  • } catch (Exception e){
  • System.out.println(”Una Excepción ha ocurrido...");
  • }
  • }
  • }

Creando un programa cliente

  • import java.rmi.*;
  • public class RemoteClient1 {
  • public static void main(String args[]) {
  • System.out.println(”Ejecutando cliente 1...");
  • System.setSecurityManager(new RMISecurityManager());
  • try {
  • RemoteInterface server = (RemoteInterface)
  • Naming.lookup("rmi://" + args[0] + "/" + ”Prueba de ObjectServer ");
  • MyObject msgObj = new MyObject("Hola desde Cliente 1");
  • System.out.println(”Enviando MyObject al Servidor ...");
  • MyObject retObj = server.msgsend(msgObj);
  • System.out.println(”El servidor contesta :" + retObj.retMsg());
  • } catch (Exception e){
  • System.out.println("Error mientras se ejecuta RMI");
  • }
  • }
  • }

Compilando el programa ejemplo

  • Construyendo la interface
    • javac RemoteInterface.java
    • javac MyObject.java
  • Construyendo programas del lado del servidor.
    • javac RemoteServer.java
    • rmic RemoteServer
      • Se genera RemoteServer_Stub.class
      • Se genera RemoteServer_Skel.class
  • Construyendo los programas clientes
    • javac RemoteClient1.java
    • javac RemoteClient2.java

Ejecutando el programa ejemplo

  • Iniciar el servidor
    • $rmiregistry (UNIX) c:>start rmiregistry (WIN)
    • Por default el puerto es el 1099
  • $java RemoteServer
  • $java RemoteClient1 dirección-IP
  • Bibliografía
  • Java 2 Manual de usuario y tutorial
  • Agustín Froufe Quintas
  • Segunda Edición
  • Alfaomega Grupo Editor
  • Año 2000
  • Guide to Java Programming
  • Peter Norton
  • Ed Premier
  • INSIDE the JAVA Virtual Machine
  • Bill Venners
  • MacGraw-Hill 1998
  • Bibliografía
  • Como programar en Java
  • Deitel y Deitel
  • Pearson Educación 1998
  • Referencias de internet
  • http://java.sun.com/
  • http://java.programacion.net/cursos.htm#new2java
  • http://www.javahispano.com/


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal