Conceptos POO (II)

Métodos y atributos de clase. Clases final. Parámetros

Métodos y atributos de clase

Existen dos tipos generales de atributos:

• Atributos de objeto.
• Atributos de clase (static).

Los atributos de clase son variables u objetos que almacenan el mismo valor para todos
los objetos instanciados a partir de esa clase.
Dicho de otra forma: mientras que a partir de un atributo de objeto se crean tantas copias
de ese atributo como objetos se instancien, a partir de un atributo de clase sólo se crea
una copia de ese atributo que será compartido por todos los objetos que se instancien.
Si no se especifica lo contrario, los atributos son de objeto y no de clase. Para declarar un
atributo de clase se utiliza la palabra reservada static.

Los atributos estáticos SOLO pueden ser referenciados por métodos estáticos.

2
class Persona {
static int numPersonas=0; // atributo de clase
String nombre; // atributo de objeto
public Persona (String n) {
nombre = n;
numPersonas++;
}
public void muestra() {
System.out.print("Soy "+nombre);
System.out.println(" pero hay "+ (numPersonas-1) +
" personas más.");
}
}
class Static {
public static void main(String argumentos[]) {
Persona p1,p2,p3;
// se crean tres instancias del atributo nombre
// sólo se crea una instancia del atributo numPersonas
p1 = new Persona("Pedro");
p2 = new Persona("Juan");
p3 = new Persona("Susana");
p2.muestra();
p1.muestra(); 3
} Soy Juan pero hay 2 personas más.
} Soy Pedro pero hay 2 personas más.
3
Miembros de clase vs. Miembros de instancia
package ClasesPractica1;
public class Clase {
private int i;
static int cont=0; // compartido por todos los objetos de la clase
public Clase (int _i) {
i=_i;
cont++;
}
static public int instancias(){
return cont;
}
public int getI(){
return i;
}
}

package ClasesPractica1;
public class Prueba {
public static void main(String[] args) {
Clase c1,c2;
c1=new Clase(3); Instancias:2
c2=new Clase(2); c1.i=3
System.out.print("Instancias:"+ c2.i=2
Clase.instancias()); Instancias:3
System.out.print("c1.i="+c1.getI());
c1.i=7
System.out.print("c2.i="+c2.getI());
c1=new Clase(7); 4
System.out.print("Instancias:"+
Clase.instancias());
System.out.print("c1.i="+c1.getI());
}
}
4
Paso de argumentos
Java pasa todos los argumentos por valor. Realmente se pasan referencias a los objetos.
La referencia no cambiará aunque se modifique dentro del método.
El objeto sí puede modificarse dentro del método.

import java.awt.Point;
class Cambia {
public static void main(String args[ ]) {
Point p1 = new Point(0,0);
cambia(p1);
System.out.println(p1);
}
static void cambia(Point p) {
p.x = 38;
p.y = 97;
} import java.awt.Point;
} class NoCambia {
public static void main(String args[ ]) {
Point p1 = new Point(0,0);
noCambia(p1);
System.out.println(p1);
C:\CJava>java Cambia
java.awt.Point[x=38,y=97] }
C:\CJava>java NoCambia static void noCambia(Point p) { 5
java.awt.Point[x=0,y=0] p = new Point(38, 97);
}
}
5
Métodos sobrecargados

Distintos métodos con el mismo nombre pero diferentes argumentos

Reglas:
1. Si existe el método cuyos argumentos se ajustan exactamente al tipo de los argumentos
de la llamada (argumentos actuales), se llama ese método.
2. Si no existe un método que se ajuste exactamente, se intenta promover los argumentos
actuales al tipo inmediatamente superior (por ejemplo char a int, int a long, float a double,
etc.) y se llama el método correspondiente.
3. Si sólo existen métodos con argumentos de un tipo más amplio (por ejemplo, long en vez
de int), el programador debe hacer un cast explícito en la llamada, responsabilizándose de
esta manera de lo que pueda ocurrir.
4. El valor de retorno no influye en la elección del método sobrecargado. En realidad es
imposible saber desde el propio método lo que se va a hacer con él .

No es posible crear dos métodos sobrecargados, es decir con el mismo nombre, que sólo
difieran en el valor de retorno.

6
Métodos de clase
Estos métodos no actúan sobre objetos concretos, por lo que no tienen argumentos implícitos. Si
suelen recibir como argumentos objetos de su clase como argumentos explícitos.
Para su definición se antepone la palabra static a su declaración detrás del modificador de acceso.
Se pueden llamar desde una instancia de la clase o utilizando el nombre de la clase. En su
implementación sólo pueden utilizarse atributos de la clase (también estáticos), ya que el resto de
atributos son propios de cada objeto y sería necesario disponer de una instancia de la clase

7
El método main
El método main es el método por el que comienza la ejecución de un programa escrito en Java. Su
prototipo estándar es el siguiente:

public static void main(String[] args)

El método es estático ya que la JVM debe poder ejecutarlo sin tener una instancia de la
clase que lo contiene. Los argumentos se pasan al método como un array de String. Al
contrario que en C++, el primer argumento no es el nombre del programa, sino el primer
argumento que se pasa al programa

8
Atributos final

Se emplean para definir constantes

Se inicializan en la declaración
No pueden modificar su valor
Por lógica suelen definirse static

class Circulo {
final double PI=3.14159265;
int radio;
Circulo(int r) {
radio=r;
}
public double area() {
return PI*radio*radio;
}
}
class Final {
public static void main(String
argumentos[]) {
Circulo c = new Circulo(15); 9

System.out.println(c.area());
}
} 9
El objeto this

Es el objeto que recibe el mensaje. Se puede hacer referencia directamente a sus atributos
y métodos, sin poner this.
Sirve especialmente para devolver el objeto actual.
Esto permite encadenar operaciones

10