Programación de Sistemas de Tiempo Real - Web de ARCOS

Programación
de Sistemas
de Tiempo Real
Java
Java: repaso
http://arcos.inf.uc3m.es/~ii_pstr
Introducción
– ¿Qué?, ¿Dónde?,...
Entorno de desarrollo.
– Herramienta,pasos a dar, etc.
Sintaxis del lenguaje.
– Tipos, variables, clases, ...
Diseño: modelos y metodologías.
– UML,...,Proceso Unificado,...
1

Introducción
Historia y evolución.
Características.
Etc.
Origen de Java
Desarrollado por Sun Microsystems
Finales de los 80, James Gosling
– Desarrollo de Software portable para
electrodomésticos
Agosto 91. Leguaje OAK
– Pequeño, fiable y independiente arquitectura
Marzo 93. World Wide Web
Primavera 94. OAK se adapta a Internet
Enero 95. OAK pasa a ser JAVA
– Aparece HotJava
Agosto 95. Java en Netscape
...
2

Características de Java
Simple
– Funcionalidad de un lenguaje potente, sin
características confusas y peligrosas.
– Menos errores al eliminar:
• Punteros, registros, gestión de memoria …
– Intérprete de tamaño pequeño, muy compacto.
Orientado a Objetos
– Encapsulación, herencia y polimorfismo.
Distribuido
– Bibliotecas y herramientas para hacer programas
distribuidos.
Características de Java
Indep. Plataforma / Portable
3

Características de Java
Robusto
– Comprobación de referencias.
– Comprobación de límites de los vectores.
– Excepciones.
– Verificación de byte-codes:
• No desbordamientos de pila
• Parámetros conocidos y correctos
• No conversiones ilegales de tipos
• Accesos legales a campos/métodos de objetos
• No intentos de violar normas acceso/seguridad
Características de Java
Seguro
– Cargador de clases
• Separa el espacio de nombres local de los recursos
procedentes de la red
• No caballos de Troya. Las clases se buscan primero
entre las locales (luego en exteriores)
– Apertura de ficheros y arranque de otras
aplicaciones en máquina remota, no en local
– Permite desensamblado de byte-codes.
Solución programadores (código nativo)
4

Características de Java
Dinámico
– Si se ejecuta una aplicación Java sobre red y
encuentra una pieza que no sabe manejar, es
capaz de traer automáticamente del servidor
cualquiera de las piezas que necesita para
funcionar
Interpretado
– Más lento que C o C++
Características de Java
Multihilo (multithread)
– Mejor rendimiento.
– Más interactivo.
– Facilidad de desarrollo.
5

Entorno de desarrollo
Herramientas del SDK tradicional.
Desarrollo de la primera aplicación:
– Edición del holaMundo.java
– Compilación: javac.
– Ejecución: java.
– Depuración: jdb.
JDK: Java Development Kit
editor texto ASCII (fuente X.java)
javac (objeto X.class)
java (ejecución de la aplicación)
jdb (depuración)
6

JDK: Java Development Kit
editor texto ASCII (fuente X.java)
editor texto ASCII (fuente X.html)
javac (objeto X.class)
appletviewer (ejecución applet)
jdb (depuración)
JDK: Java Development Kit
Javadoc (archivos .html)
Jar (archivo .jar)
Javap (archivo .class desensamblado)
...
/tooldocs/tools.html
7

Primera aplicación
HolaMundo.java
public class HolaMundo
{
public static void main (String args[ ] )
{
System.out.println(“¡Hola Mundo!”);
}
}
Primera aplicación: javac
javac [opciones] archivos
– opciones:
• -classpath camino
• -d directorio
• -g
• -help
– archivos
• .java
• @lista_archivos (separados por “ “ o “\n”)
8

Primera aplicación
Ejemplos:
– javac HolaMundo.java
– javac ../../fuentes/*.java
– javac -classpath /java/clases *.java
– javac -d ../clases HolaMundo.java
– Javac –g HolaMundo.java
Primera aplicación: java
java [opciones] archivo [argumentos]
java [opciones] –jar archivo [argumentos]
– opciones:
• -help: lista de opciones.
– archivo:
• Nombre archivo sin “.class”/”.jar”.
– argumentos:
• Argumentos para el programa.
9

Primera aplicación
Ejemplos:
– java HolaMundo
– java –classpath X.jar:Y.zip:../clases
HolaMundo
Advertencia:
–En versiones antiguas del jdk, “classpath
” sobrescribe, no añade.
Primera aplicación: jdb
“;” Windows
“:” Linux
jdb [opciones] archivos argumentos
– opciones:
• -help: lista de opciones
– archivos
• Nombre archivo sin “.class”
– argumentos:
• Argumentos para el programa.
10

Primera aplicación
jdb HolaMundo
stop at HolaMundo:7
Initializing jdb ...
stop in HolaMundo.main
run
run HolaMundo
VM Started: Set deferred breakpoint HolaMundo.main
Breakpoint hit: "thread=main", HolaMundo.main(),
line=6 bci=0
main[1] _
Primera aplicación
main[1] print args
args = instance of java.lang.String[0] (id=285)
main[1] dump args
args = {
}
main[1] where
[1] HolaMundo.main (HolaMundo.java:7)
main[1] quit
11

Primera aplicación: jdb
– stop at C:22
– stop in C:M
– clear C:22
– run
– cont
– step
– help
– where
– up
– down
– threads
– thread
Sintaxis del lenguaje
Elementos de un programa.
Juego de caracteres.
Identificadores.
Comentarios.
Tipos.
Variables.
Literales.
Operadores.
Control de flujo.
Estructura de un programa.
– print
– dump
– set x=y
12

Elementos de un programa
Programa -> 1,n archivos
Archivo -> 1,n paquetes
Paquete -> 1,n (clases,interfaz,import)
Clases o interfaces -> (datos, métodos)
Método -> (variables,sentencias,bloques)
Bloque -> (variable, sentencias,bloques)
– Sentencia -> 1,n expresiones terminadas en “;”
– Expresión -> 1,n (operación,método,expresión)
Juego de caracteres
Juego de caracteres Unicode (16 bits)
Los 128 primeros caracteres equivalentes a ASCII
Pocos editores Unicode
Los entornos Java aceptan cualquier fichero ASCII
convirtiéndole sobre la marcha a Unicode
Java acepta \udddd (d es dígito hexadecimal) para
caracteres Unicode
13

Identificadores
Identificador: nombre de un elemento que se
utilizan en el lenguaje.
– Etiqueta -> identifica una posición de una sentencia.
– Nombre -> identifica una ‘entidad declarable’ que
pertenece a Java.
Declaración:
– Introducción de una ‘entidad’ en un programa Java +
– Dotar de un nombre a dicha entidad +
– Asociar un ámbito donde se puede usar.
Identificadores
Construcción de los nombres de los
elementos que se utilizan en el lenguaje:
– Debe empezar por una letra, subrayado o dólar
pero no con un dígito.
– Las letras mayúsculas y minúsculas son
consideradas como letras distintas.
– Un identificador no puede ser una de las palabras
reservadas del lenguaje, es decir, palabras que
tienen un significado especial para el lenguaje.
(this, while, volatile....)
14

Convenio para el nombrado
clase -> HolaMundo
método -> getV, setV, isV, toV, ...
dato miembro -> varMiembro
constante (final) -> LIMITE_INFERIOR
parámetro -> i, fichEntrada, ...
Comentarios
– // hasta el final de la línea
– /* comentario de bloque:
pueden ocupar varias líneas */
– /** comentario de bloque java.
Se usa para generar la documentación
automáticamente con javadoc */
/**
* Este es un comentario.
* @see java.lang.Object
*/
15

Tipos
Tipo =
– Nombre: nombre del tipo.
– Valores: conjunto de valores válidos (literales)
para una variable de dicho tipo.
– Ámbito: zona del código fuente donde se puede
usar dicho tipo.
Taxonomía:
– Tipos primitivos: asociados a un único valor.
– Tipos referencia: contiene referencia a un valor.
Tipos primitivos
Variables tienen tipo
Numéricos
– byte (entero con signo, 8 bits)
– short (entero con signo, 16 bits)
– int (entero con signo, 32 bits)
– long (entero con signo, 64 bits)
– float (coma flotante, 32 bits)
– double (coma flotante, 64 bits)
No numéricos
– boolean (true o false)
– char (carácter Unicode, 16 bits)
16

Tipos referencia
char [] ach; (array)
class x { ... }; (clase)
interface y { ... }; (interfaz)
null (referencia a objeto nulo)
Conversión de tipos
Contexto de conversión (Donde):
– Asignación:
• F_float = I_int
– Invocación a método:
• M(I_int) ; // void M ( long l );
– Promoción numérica:
• F_float * I_int
– Conversión a String:
• system .out.println(“x:” + i + “\n”);
– Cast:
• X_var = (TipoDestino) Y_var ;
• X_obj = (ClaseDestino) Y_obj ;
objetos tienen clase
17

Conversión de tipos
Tipo de conversión:
– Ancha primitiva:
• L_long = I_int
– Estrecha primitiva:
• I_int = L_long
– Generalización:
• O_base = (ClaseBase) O_derivada
– Especialización:
• O_derivada = (ClaseDerivada) O_base
– String:
• String s_obj = “” + V_var + O_objeto + null ;
Literales
Valor constante que aparecerá en la
descripción de una aplicación.
Tipos primitivos:
• Enteros (por defecto int)
– decimal, no comience por 0 (v.g., 284).
– Octal, comenzar por 0 (v.g., 023).
– Hexadecimal, comenzar por 0x (v.g., 0x2A).
– Por defecto, tienen 32 bits, si se quiere utilizar 64
bits incluir el sufijo l o L (v.g., 23L).
• Coma flotante (por defecto double, se puede
añadir sufijo f para float: 34.5f)
– Notación estándar (v.g., 3.25).
– Notación científica (v.g., 23E10).
18

Literales (II)
Tipos primitivos:
• Caracteres simples
– Comillas simples (v.g., ‘c’).
– Caracteres no imprimibles: usar secuencias de
escape:
\ddd Carácter octal
\uxxxx Carácter Unicode
\n Nueva línea
\’ Comillas simples
\” Comillas doble
\t Tabulador
\\ Barra invertida
\b Retroceso
Literales (III)
Tipos primitivos:
• Lógicos: true/false
– No tienen una representación de número entero
Tipos referencia:
• Cadenas de caracteres
– Comillas dobles (v.g., “hola”).
• null (objeto no válido o no creado)
19

Variables
Variable: dato almacenado en la computadora
que puede variar a lo largo de la ejecución de
un programa.
Consta de:
– Identificador: cadena de caracteres que se utiliza
para identificarla.
– Tipo: indica la naturaleza del valor que se va a
almacenar.
– Características: ámbito, valor por defecto,
existencia, etc. (dependientes del ‘contenedor’
subscrito)
Definición de variables
public int [] aint;
public int []aint = new int[10];
public char [] achar = { ‘a’, ‘b’ };
[=new ] ;
20

Características de las variables
m ( ...) {
}
for (int i=0; i

Operadores de los Tipos Básicos
(Numéricos)
Oper Operación Ejemplo
++ Preincrementa el valor de la
variable asociada.
++ Postincrementa el valor de
la variable asociada.
-- Predecrementa el valor de la
variable asociada.
-- Postdecrementa el valor de
la variable asociada.
p=5; j=2+(++p); j(8) p(6)
p=5; j=2+(p++);j(7) p(6)
p=5; j=2+(--p); j(6) p(4)
p=5; j=2+(p--);j(7) p(4)
Operadores de los Tipos Básicos (bits)
Operador Operación Ejemplo
& 1 en las posiciones en las que
haya dos unos
| 1 en las posiciones en las que
haya al menos un 1
^ 1 en las posiciones en las que
haya un 0 en un operando y un 1 en
el otro
~ Cambiar el valor de los bits de 0 a
1 y de 1 a 0
0004&00040004
0002&00060002
0004|00060006
0002|00050007
0002^00030001
0004^00070003
~00000777
~07030074
>>n Desplaza n bits a la derecha. 0004>>20001
0004>>30000

Operadores de los Tipos Básicos
(Comparación)
Ope Operación Ejemplo
== true si son iguales x=5;y=5; ¿x==y? True
x=5;y=6; ¿x==y? False
!= true si son distintos y false en caso x=5;y=5; ¿x!=y? False
contrario.
x=5;y=6; ¿x!=y? True
< true si el primero es menor que el x=5; y=5; x=y True
segundo y false en caso contrario. x=7; y=5; x>=y True
Operadores de los Tipos Básicos
(Lógicos)
Operad Operación Ejemplo
&& Equivalente al
AND lógico.
|| Equivalente al OR
lógico
x= false; y=true (x&&y)
false
x= false; y=true (x||y)
true
! Negación lógica x= true; (!x) false
23

Operadores de los Tipos Básicos
(Ternario)
Sintaxis
(expresion booleana) ? expr1 : expr2
El operador ? Evalua una expresión booleana y si el valor de
es verdadero devuelve como resultado la expr1, sino devuelve
el valor de la expr2
Ejem:
x=2;
y= (x>3) ? 5: x+5;
como x no es mayor de 3 la y tomará el valor 7 (x+2)
Precedencia de operadores (I)
– Asociatividad ( )
– Oper. Postfijos: [], ., (params), expr++, expr--
– Oper. Monarios: ++expr, –-expr, +expr, -expr,
– Creación/Conversión new (tipo)expr
– Multiplicación *, /, %
– Suma +, -
– Desplazamiento
– Relacional , =, intanceof
– Igualdad ==, !=
24

Precedencia de operadores (II)
– Y a nivel de bits &
– O exclusiva a nivel de bits ^
– O inclusiva a nivel de bits |
– Y lógica &&
– O lógica ||
– Condicional ?:
– Asignación =, +=, -=, *=, %=,
>>=, >=,
&=, ^=, !=
Control fujo / alternativas / if-else
Sintaxis:
o
if ( expresión_lógica ) sentencia1;
[ else sentencia2 ; ]
if ( expresión_lógica ) {bloque1}
[ else {bloque2} ]
– Si la expresión_lógica es verdadera se ejecuta la
sentencia1 o el bloque1
si es falsa se ejecuta la sentencia 2 o el bloque 2
25

Control fujo / alternativas / switch
Sintaxis:
switch (expresión_de_tipo_simple) {
case valor1: [sentencia_1_1;]
[sentencia:1_2;]
...
[break;]
case valor2: [sentencia_2_1;]
...
[break;]
. . .
case valorN: [sentencia_N_1;]
...
[break;]
[default: [sentencia_D_1;]
... ]
}
switch
El tipo de la expresión debe ser uno de los tipos simples (int, long,
short, byte, char). No puede ser un valor lógico porque los valores
true y false no tienen su correspondiente numérico.
Los valores de la selección múltiple (valor1, valor2,…) tienen que
ser constantes, se evalúan en tiempo de compilación.
Si la expresión de tipo toma el valor1 se ejecutan las sentencias
1_X,
Si toma el valor2 se ejecutan las sentencias_2_X, etc.
Si no toma ninguno de los valores indicados y se pone el bloque
default (que es opcional) se ejecutarán las instrucciones del
mismo.
Si alguna de las opciones no contiene el break correspondiente, la
ejecución prosigue con las sentencias del siguiente case
(conviene indicar con un comentario que los case vacíos continúan
en el que les sucede).
26

Control fujo / iterativas / while
Sintaxis:
while (expresion-boolean)
sentencia
– Se evalúa la expresión y si es verdadera, se
ejecuta la sentencia/s mientras la expresión siga
siendo verdadera.
– Se utiliza cuando la sentencia tiene que
ejecutarse 0 o varias veces
– Si hay varias sentencias irán entre llaves { }
Control fujo / iterativas / do-while
Sintaxis:
do
sentencia
while (expresion-boolean);
– Se ejecuta la sentencia/s y después se evalúa la
expresión, mientras esta sea verdadera se
seguirán ejecutando la sentencia/s
– Se utiliza cuando la sentencia tiene que ser
ejecutada al menos 1 vez
– Si hay varias sentencias irán entre llaves { }
27

Control fujo / iterativas / for
Sintaxis:
for ([expr-inic]; [expr-booleana]; [expr-incr])
sentencia;
– expr-inic: expresiones de inicialización, se ejecuta sólo 1 vez
antes de comenzar el bucle.
– expr-incr: expresión de incremento, se ejecuta una vez después
de cada iteración y antes de comprobar la expr-booleana.
– expr-booleana: condición de finalización del bucle cuando toma
valor falso, Si se omite expr-booleana, se supone true, Se evalua,
después de la inicialización y antes de comenzar la siguiente
iteración.
– expr-inic y expr-incr pueden ser compuestos (separados por
coma).
Control fujo / incondicional / break
Sintaxis:
Break [etiqueta];
...
etiqueta: sentencia
– Para salir de cualquier bloque de sentencias.
– Un break sin etiqueta termina el switch, for, while o
do-while más interno.
– Un break etiqueta, lleva el control hasta la sentencia
externa etiquetada (similar al “goto” de otros
lenguajes de programación).
28

Control fujo / incondicional / continue
Sintaxis:
{
continue [etiqueta];
...
etiqueta: sentencia
}
– Para continuar la ejecución en otra parte del bucle.
– Un continue sin etiqueta vuelve a evaluar la condición de
fin del bucle.
– Un continue etiqueta, lleva el control hasta la sentencia
interna al bucle indicada por la etiqueta.
Control fujo / incondicional / ...
Sintaxis:
return [expresion];
– Termina la ejecución de un método, devolviendo el
control al invocador
– Si se indica una expresión, además devuelve el
valor resultante de la evaluación de dicha
expresión.
29

Control fujo / sincronización
Sintaxis:
syncronize ( ) {
}
sentencia
– Adquiere el cerrojo asociado al objeto (o clase) indicada
como ‘parámetro’ antes de ejecutar las sentencias del
bloque.
Control fujo / Excepciones
Sintaxis:
try {
...
F();
} catch (Exception e) {
...
} finally {
}
...
public void F ()
throws Xexception {
...
throw new Xexception;
...
}
30

Estructura de un programa
Paquete
– Clases
– Interfaces
• Métodos
• Atributos
Paquete
Estructura básica para definir un paquete:
package base.deriva1.deriva2;
import java.lang.*;
class class1 { ... } ;
class class2 { ... } ;
class class3 { ... } ;
Definición de paquete:
Identificadores separados por ‘.’
Describen la finalidad del paquete, de más
a menos.
Convención: usar dirección Internet, al
revés y en mayúsculas.
Existe un paquete anónimo: todo archivo
java no definido como paquete pertenece al
un paquete sin nombre, que se importa
automáticamente.
31

Paquete
Paquetes predefinidos:
– java.lang Clases básicas, importación automática.
– java.io E/S
– java.net Clases para aplicaciones en red
– java.awt Interfaces gráficos.
– java.util Fechas, grandes cantidades de texto, etc.
– ...
Ver /api/index.html
Clases
Estructura básica para definir una clase:
{
abstract
public
final
class nombre [extends cbase]
[final,static,public,...] tipo variable_miembro;
[implements interfaz [,interfaz] ]
[public,abstract,...] tipo funcion_miembro (parametros) (; | {...})
}
1
3
2
atributos
métodos
32

Interfaces
Estructura básica para definir una interfaz:
[public]
{
}
interface nombre [extends Super1 [, Super2]]
[final,static,public] tipo variable_miembro = valor;
[public,abstract] tipo funcion_miembro (parametros) ;
Clases (1)
Modificadores de clase:
– Abstract
• Parecido a virtual pura de C++
• Necesario si:
– Public
atributos
– Heredo y no implemento métodos abstract
– Tengo 1 ó más métodos abstract
• Accesible desde cualquier paquete.
– Final
• No existen subclases.
métodos
33

Clases (2)
Herencia:
– No existe herencia múltiple de clases, si de interfaces
– Existe una única jerarquía. La raíz es java.lang.Object
Class A {
};
Uno (int );
Uno(char, int);
Dos(char);
Abstract Tres();
Static Cuatro();
Clases (3)
sobrecarga
Datos miembro:
static
final
volatile
trasient
Modificador
sobrescribe
implementa
oculta
Class B extends A {
};
modificación
No puede cambiar su valor
Dos(char);
Tres();
Cuatro();
Compartida por todas las instancias
Accesible donde sea accesible la clase
Modificación es atómica (si existen varios
threads)
No pertenece a la parte persistente de la
clase
34

Clases (3)
Métodos miembro:
static
final
abstract
native
Modificador
syncronize
Clases (3)
public
private
protect
Sólo puede acceder a variables static
No sobrescribe
modificación
Similar a virtual en C++
Control de acceso:
package
Implementado en otro lenguaje
Sólo un thread ejecuta el método al mismo
tiempo
Clase Subclases Paquetes Mundo
*
*
* *
* * *
35

Clases (3)
NOTAS:
– Private -> final
– Native -> ! Abstract
– Abstract -> ! Final, ! Static
– Los modificadores no pertenecen a las señas
de un método -> dos métodos con igual señas
es un error aun siendo uno abstract ó ...
Utilización de Métodos
Sintáxis de invocación de un método
[nombredelobjeto.]nombredelmetodo(parametros)
Donde:
– nombredelobjeto debe ser un identificador válido
de un objeto creado. Puede omitirse cuando se
invoca al método dentro de otro método de la
misma clase y para referenciar el mismo objeto que
se estaba tratando.
– Nombredelmetodo: es el nombre del método.
– parametros: deben aparecer tantos como existan
en la declaración del método separados por comas.
No se modifica el valor de los parámetros pasados
(si el param. es una referencia a un obj. se puede
cambiar el contenido del mismo pero no la
referencia).
36

Ejem 1
Uso de Métodos
class PasarPorValor {
public static void mitadValor(double d){
d = d / 2.0;
System.out.println(“mitad:d =“+d);
}
}
Ejem 2 :
public static void main (String arg[]) {
double uno = 45.0;
System.out.println(“antes:uno=“+uno);
mitadValor(uno);
System.out.println(“después: uno=“+uno);
}
Uso de Métodos
Resultado
antes:uno=45.0
mitad:d=22.5
Desp.:uno=45.0
class PasarPorReferencia {
double valor=45;
void mitadValor(PasarPorReferencia pr){
pr.valor = pr.valor / 2.0; Resultado
antes:45.0
System.out.println("mitad:"+pr.valor); mitad:22.5
}
desp:22.5
}
class Ejecución {
public static void main (String []args){
PasarPorReferencia pr=new PasarPorReferencia();
System.out.println("antes:"+ pr.valor );
pr.mitadValor(pr);
System.out.println("desp:"+pr.valor);
}
}
37

Método main: Aplicaciones
public static void main (String[]args){
...
...
}
– Debe ser public, static y void (no devuelve nada)
– Acepta un argumento de tipo String[ ] que contiene
los parámetros que se pasaron a la aplicación
cuando se invocó desde el Sistema Operativo
– Las aplicaciones pueden tener muchos main(uno por
clase). Al ejecutar un programa Java, se ejecuta el
main de la clase que se invoca
Ejemplo Método main
class Clase {
public static void main (String arg[]) {
System.out.println(arg.length);
System.out.println(arg[0]);
System.out.println(arg[1]);
}
}
Si la ejecución se invoca con:
java Clase uno dos
el resultado de la ejecución es:
2
uno
dos
38

Constructor: Creación de objetos
El constructor es una función miembro de la
clase que tiene el mismo nombre que la clase.
Admite public o protect.
No se indica tipo de retorno.
Admiten parámetros.
Puede haber varios constructores usando
sobrecarga.(1,n).
– Si no se define ninguno, Java define el constructor por
defecto (();).
Constructor: Creación de objetos
Se ejecuta:
– Al invocarlo con newpara crear un nuevo objeto.
En este caso, se devuelve una referencia al objeto
creado.
– En conversiones.
– Como resultados temporales de expresiones.
Esta función miembro no se puede invocar
desde los demás métodos.
39

Constructor: Creación de objetos
No es heredable.
No es método de la clase.
No es recursivo.
Puede llamar a otros constructores si no
forman ciclos.
Primero invoca al constructor de la superclase:
– Explícitamente: super(3,4,...);
– Implícitamente: super(); // si no se pone una
llamada explícita al principio del constructor.
Constructor: Creación de objetos
Para crear objetos hay que:
Ejem:
– Crear una referencia al objeto: Mesa m;
– Crear el objeto (invocar constructor) m=new Mesa();
class Mesa{
Mesa(){ }
}
class otraClase{
Mesa creaUnaMesa(){
Mesa m;
m=new Mesa();
return m;
}
}
40

this
this sirve para referenciar al objeto que esta siendo
utilizado dentro de un método. Se puede utilizar:
– Cuando puede existir ambigüedad en la utilización de un
atributo (por que su nombre coincide con el de un parámetro
por ejemplo) :
this.radio = 2*PI* radio;
– Para invocar a otro método pasándole el objeto como
argumento:
numero.sumar(this)
– Para invocar a otro constructor dentro un constructor:
Clase (int n){ //Constructor que recibe un entero
this ( );//invocación a un constructor sin parámetros
atributo=n;
}
Super
Super sirve para acceder a los miembros de la clase
base del objeto. Se puede utilizar:
– Cuando puede existir ambigüedad en la utilización de un
atributo (por que su nombre coincide con el de la clase base) :
return super.oculto();
– Para invocar a un constructor de la clase base dentro un
constructor de la clase derivada:
ClaseA (int n){ //Constructor que recibe un entero
}
super(3);//invocación a un constructor sin parámetros
...
41