Descargar

Fundamentos de
Informática
Lección 6. Métodos de
objetos
j
y clases
Curso 2010-2011
José Ángel Bañares y Pedro Álvarez
2/11/2010. Dpto. Informática e Ingeniería de Sistemas.
Índice de contenidos
 Abstracción
 Clases como mecanismo para definir abstracciones
 Declaración de métodos:
 procedimientos y funciones.
funciones
 Invocación de métodos.
 Paso de parámetros.
 Métodos de clase y objeto
 Diseño descendente
Abstracción
 Abstraer,, o el “método de dar nombre”
a conceptos sobre los que construir
nuestros programas
 Podemos asociar un nombre con una dirección de
memoria: Nombre de la variable)
 Podemos asociar un nombre con una “estructura” o
forma de interpretar uno o más bytes: Tipo de dato
 Podemos asociar un nombre con un grupo de
instrucciones java: método
 Podemos asociar nombres a nuevas abstracciones
no soportadas por el lenguaje: nuevos tipos de
datos agrupando variables relacionadas y funciones
Clases
 En Java los p
programas
g
están formados
por una o más clases
 Una de las clases define el método
static void main (String[] args)
agrupa las instrucciones que se ejecutarán al
invocar la ejecución del programa.
 Las clases del programa Java pueden definir
más métodos:
 Nombre que damos a “instrucciones” definidas por el
programador y no soportadas directamente en el
lenguaje
 Diseño top-down: Descomposición del problema en
subproblemas.
Clases
 Las clases p
permiten definir nuevas
“abstracciones” que agrupan:
 datos (fields): agrupación de datos.
 Métodos (methods):acciones que se pueden
con la abstracción.
 Las nuevas abstracciones pueden ser:
 Programas
 Nuevos
N
ti
tipos
de
d datos
d t
 Librería de funciones (por ej. Math).
Declaración de métodos
Declaración del método
Modificadores tipo nombre (parámetros) {
Variables y sentencias
return expresión;
p
; //
//del tipo
p declarado
}
 El tipo
 void
 Tipo
Ti
primitivo
i iti (entero,r
( t
eal,l carácter,
á t
b l
booleano)
)
 Clase
Procedimientos / Acciones
(void)
public class DibujaCaja{
static void caja(){
System.out.println("+-----------+");
System.out.println("+
+");
System out println("+
System.out.println(
+
+
+");
);
System.out.println("+-----------+");
}
public static void main (
(String[]
p
g[] args){
g ){
caja();
}
}
Declaración
Invocación método
estático definido
en la clase
+-----------+
+
+
+
+
+-----------+
Procedimientos / Acciones
(void)
public class DibujaCaja{
static void caja(){
System.out.println("+-----------+");
System.out.println("+
+");
System out println("+
System.out.println(
+
+
+");
);
System.out.println("+-----------+");
}
public static void main (
(String[]
p
g[] args){
g ){
DibujaCaja.caja();
}
}
Declaración
Invocación método
estático definido
en la clase
+-----------+
+
+
+
+
+-----------+
Funciones (valores)
public class LiberiaMat {
public static double E (){
final double PRECISION= 1E-5;
Declaración
double termino = 1.0;
double exp = termino;
double indice = 1;
while (termino > PRECISION){
termino = termino /indice;
exp+=termino;
indice++;
}
return exp;
}
public
bli static
t ti void
id main
i (String[]
(St i [] args){
){
System.out.println(E()+1);
}
Invocación
3.7182815255731922
Llamadas a métodos
Declaración del método
Método (parámetro)
- Declarado en la propia clase
caja();
j ()
Clase. Método(parámetros) - Declarado estático en otra clase
DibujaCaja.caja();
Objeto método (parámetros) - Declarado en otro objeto
Objeto.método
v1.length
Paso de parámetros
 El valor devuelto o la acción p
puede depender
p
de
parámetros
Declaración parámetos formales (o parámetros)
Modificadores tipo nombre (tipo variable, tipo variable ..) {
Variables y sentencias
return expresión;
p
; //
//del tipo
p declarado
}
Argumentos o parámetros reales
(expresion, expresion, ...)
caja(5,5);
Math.exp(2);
p( );
Paso de parámetros
Declaración parámetos formales (o parámetros)
static void caja (int anchura,
anchura int profundidad)
Método caja
tamaño
60
anchura
h
60
A
t o parámetros
á
t
l
Argumentos
reales
Int tamaño= 60;
caja(tamaño,(int) tamaño/2);
profundidad
30
Variable e
instrucciones
del método
caja
Paso de parámetros
 En Java se p
pasan el valor de los
argumentos
 Si es un tipo primitivo
 No se puede modificar el valor.
 Si son objetos
bj t se pasa ell “puntero”
“
t
” all
objeto.
 Se puede modificar el estado del objeto.
objeto
Nota: En lenguajes como Ada se distingue parámetros
de entrada, salida, e/s.
e/s
Declaración de métodos
Declaración del método
Modificadores tipo nombre (parámetros) {
Variables y sentencias
return expresión;
p
; //
//del tipo
p declarado
}
 Modificadores
 public: Puede invocarse por otras clases
 static: Método de clase
 final: Como los atributos final, supone que el
compilador puede sustituir la invocación por
las sentencias del método.
Métodos de clase y objeto
 Cuando la clase define nuevos tipos de
d t
datos,
podemos
d
crear objetos
bj t
d l tipo
del
ti
especificado.
int[] listaEnteros =new int[] {5,4,1};
{5 4 1};
 Los objetos agrupan datos y tienen estado
listaEnteros[1] =2;
 método de objeto: El resultado depende del
j
listaEnteros.length
g ;
estado del objeto
 Método de clase: El resultado no depende del
estado
Math.abs(-1);
Métodos de clase (static)
 Invocación método de clase
NombreClase.NombreMetodo();
NombreObjeto.NombreMetodo();
> Character.getNumericValue('a')
10
> Math.abs(-1)
h b ( 1)
1
 Dentro de la clase en la que se define el método se
puede invocar utilizando sólo el nombre del método
NombreMetodo();
Métodos de objeto
 Invocación método de objeto
j
NombreObjeto.NombreMetodo();
> String nombre = "El mono lleva kimono";
> System.out.println(nombre);
El mono lleva kimono
> String nombreMinuscula=nombre.toLowerCase();
> System.out.println(nombreMinuscula);
el mono lleva kimono
Métodos de objeto
 Todos los métodos de la clase String
g no
cambian el String original. Devuelven un
nuevo String. Los String son inmutables.
> String nombreMayuscula=nombre.toUpperCase();
> System.out.println(nombreMayuscula);
System out println(nombreMayuscula);
EL MONO LLEVA KIMONO
> System.out.println(nombre);
El mono lleva kimono
> nombre = nombre.toUpperCase();
> System.out.println(nombre);
S stem o t println(nombre)
EL MONO LLEVA KIMONO
Declaración de métodos
final
public static final void f() {
System.out.println(”método f() de A");
}
}
// La clase B invoca
i
un método
é
final
i
public class B {
public void g() {
A f()
A.f();
}
}
//En tiempo de compilación nuestra clase B se convierte en:
public class B {
public void g() {
System out println("método
System.out.println(
método f() de A");
A );
}
}
Diseño descendente
 Problema: Dibujar
j tabla con caracteres
‘+’, ‘-’, ‘ ‘
número espacios
p
+---+---+---+
+
Número filas
+
+
+
+---+---+---+
+
+
+
+
+---+---+---+
número columnas
Diseño descendente
 Problema: Dibujar
j tabla con caracteres
‘+’, ‘-’, ‘ ‘
número espacios
p
Número filas
+---+---+---+
dibLHoz
+
dibLSep
+
+
+
+---+---+---+
+
+
+
dibLHoz
+
dibLSep
+---+---+---+
dibLHoz
número columnas
Diseño descendente
Cuadrados (Pb)
dibLHoz;
for (int i=1;i<=nf; i++){
dibLSep;
dibLHoz;
}
dibLHoz (Pb 1)
System.out.print('+');
for (int i=1; i<=nc; i++) {
escribeGuiones(ne);
System.out.print('+');
}
System out println();
System.out.println();
dibLSep (Pb2)
System.out.print(‘+');
for (int i=1; i<=nc; i++) {
escribeBlancos(ne);
System.out.print(’ ');
}
System out println();
System.out.println();
Diseño descendente
Cuadrados (Pb)
dibLHoz (Pb 1)
dibLH
System.out.print('+');
for (int i=1; i<=nc; i++) {
escribeGuiones(ne);
System.out.print('+');
}
S t
System.out.println();
t i tl ()
Escribir-guiones ( Pb1.1)
f (
for(int
i=1;
1 i<=n; i++))
System.out.print('-');
dibLS (Pb2)
dibLSep
System.out.print(‘+');
for (int i=1; i<=nc; i++) {
escribeBlancos(ne);
System.out.print(’ ');
}
System.out.println();
Escribir-blancos (Pb 1.2)
for(int i=1; i<=n; i++)
System.out.print(’ ');
Diseño descendentes sin
métodos
import java.util.Scanner
public class Cuadrados {
static void main(String[] args){
Scanner entrada = new Scanner(System.in);
( y
);
System.out.print("Numero filas:");
int nf = entrada.nextInt();
()
System.out.print("Numero columnas:");
int nc = entrada.nextInt();
System.out.print("Numero espacios:");
int ne = entrada.nextInt();
Diseño descendentes sin
métodos
//Dibujar Linea Horizontal
System.out.print('+');
for (int i=1; i<=nc; i++) {
for(int
( jj=1;; j<=ne;
j
; jj++))
System.out.print('-');
System.out.print('+');
}
System.out.println();
Diseño descendentes sin
for (int i=1;i<=nf; i++){
métodos
//Dibujar linea separación
System.out.print('+');
for (int ll=1;
1; l<=nc;
l< nc; l++)
l ){
for(int j=1; j<=ne; j++)
System.out.print(' ');
y
p ( );
System.out.print('+');
}
System.out.println();
//Dibujar Linea Horizontal
System.out.print('+');
for (int l=1; l<=nc; l++) {
for(int j=1; j<=ne; j++)
System.out.print('-');
System.out.print('+');
}
System.out.println();
}
Métodos con parámetros 0
import java.util.Scanner;
public class Cuadrados {
public static void dibLineaH(int ne, int nc){
System.out.print('+');
for ((int i=1; i<=nc; i++)) {
for(int j=1; j<=ne; j++)
System.out.print('-');
System.out.print('+');
}
System.out.println();
}
Métodos con parámetros 0
public static void dibLineaSep(int ne, int nc){
System.out.print('+');
for (int i=1; i<=nc; i++) {
for(int
( jj=1;; j<=ne;
j
; jj++))
System.out.print(' ');
System.out.print('+');
}
System.out.println();
}
Métodos con parámetros 0
public static void main(String[] args){
Scanner entrada = new Scanner(System.in);
System.out.print("Numero filas:");
int nf = entrada.nextInt();
();
System.out.print("Numero columnas:");
int nc = entrada.nextInt();
System.out.print("Numero
y
p (
espacios:");
p
)
int ne = entrada.nextInt();
dibLineaH(ne,nc);
for (int i=1;i<=nf; i++){
dibLineaSep(ne,nc);
dibLineaH(ne,nc);
}
}
}
Métodos con parámetros I
import java.util.Scanner;
public class Cuadrados1 {
public static void escribeGuiones ((int n){
p
){
for(int i=1; i<=n; i++)
System.out.print('-');
}
public static void escribeBlancos (int n){
for(int i=1; i<=n; i++)
System.out.print(' ');
}
Métodos con parámetros I
public static void dibLineaH(int ne, int nc){
System out print('+');
System.out.print(
+ );
for (int i=1; i<=nc; i++) {
escribeGuiones(ne);
System.out.print('+');
y
p ( );
}
System.out.println();
}
public static void dibLineaSep(int ne, int nc){
System.out.print('+');
for (int i=1; i<=nc; i++) {
escribeBlancos(ne);
System.out.print('+');
}
S
System.out.println();
()
}
Métodos con parámetros I
public static void main(String[] args){
Scanner entrada = new Scanner(System.in);
System.out.print("Numero filas:");
int nf = entrada.nextInt();
();
System.out.print("Numero columnas:");
int nc = entrada.nextInt();
System.out.print("Numero
y
p (
espacios:");
p
)
int ne = entrada.nextInt();
dibLineaH(ne,nc);
for (int i=1;i<=nf; i++){
dibLineaSep(ne,nc);
dibLineaH(ne,nc);
}
}
Métodos con parámetros I
import java.util.Scanner;
public class Cuadrados1 {
public static void escribeGuiones ((int n){
p
){
for(int i=1; i<=n; i++)
System.out.print('-');
}
public static void escribeBlancos (int n){
for(int i=1; i<=n; i++)
System.out.print(' ');
}
Métodos con parámetros II
public static void repiteChar (int n, char letra){
for(int i=1; i<=n; i++)
System.out.print(letra);
}
Métodos con parámetros II
public static void dibLineaH(int ne, int nc){
System.out.print('+');
for (int i=1; i<=nc; i++) {
escribeGuiones(ne);
S t
System.out.print('+');
t i t(' ')
}
System.out.println();
}
public static void dibLineaSep(int ne, int nc){
System.out.print('+');
for (int i=1; i<=nc; i++) {
escribeBlancos(ne);
System.out.print('+');
}
System.out.println();
}
Métodos con parámetros II
public static void dibLinea(int ne, int nc, char inicial, char separacion){
System.out.print(inicial);
for (int i=1; i<=nc; i++) {
repiteChar(ne, separacion);
S t
System.out.print(inicial);
t i t(i i i l)
}
System.out.println();
}
Métodos con parámetros II
import java.util.Scanner;
public class Cuadros {
public
bli static
t ti void
id repiteChar
it Ch (int
(i t n, char
h letra){
l t ){
for(int i=1; i<=n; i++)
System.out.print(letra);
}
public static void dibLinea(int ne, int nc, char inicial, char separacion){
System.out.print(inicial);
for (int i=1; i<=nc; i++) {
repiteChar(ne, separacion);
System.out.print(inicial);
}
System.out.println();
}
Métodos con parámetros II
public static void main(String[] args){
Scanner entrada = new Scanner(System.in);
System.out.print("Numero filas:");
i t nff = entrada.nextInt();
int
t d
tI t()
System.out.print("Numero columnas:");
int nc = entrada.nextInt();
System out print("Numero espacios:");
System.out.print("Numero
int ne = entrada.nextInt();
dibLinea(ne,nc,
dibLinea(ne
nc '+'
+ ,'-');
);
for (int i=1;i<=nf; i++){
dibLinea(ne,nc,'+',' ');
dibLinea(ne nc '+'
dibLinea(ne,nc,
+ ,'-');
);
}
}