Sesion 07 nivel_acceso_miembros_clases

TECNICAS DE PROGRAMACION
Universidad Católica Los Angeles de Chimbote

MODIFICADORES DE ACCESO A LOS MIEMBROS
DE UNA CLASE

Los modificadores de acceso, como su nombre indica, determinan desde qué
clases se puede acceder a un determinado elemento. En Java tenemos 4 tipos:
public, private, protected y el tipo por defecto, que no tiene ninguna palabra clave
asociada, pero se suele conocer como default o package-private.

Si no especificamos ningún modificador de acceso se utiliza el nivel de acceso por
defecto, que consiste en que el elemento puede ser accedido sólo desde las
clases que pertenezcan al mismo paquete.

Docente: Ing. Martín Salcedo Quiñones Pagina: 1


El nivel de acceso public permite a acceder al elemento desde cualquier clase,
independientemente de que esta pertenezca o no al paquete en que se encuentra
el elemento.

private, por otro lado, es el modificador más restrictivo y especifica que los
elementos que lo utilizan sólo pueden ser accedidos desde la clase en la que se
encuentran. Este modificador sólo puede utilizarse sobre los miembros de una
clase y sobre interfaces y clases internas, no sobre clases o interfaces de primer
nivel, dado que esto no tendría sentido.

Es importante destacar también que private convierte los elementos en privados
para otras clases, no para otras instancias de la clase. Es decir, un objeto de una
determinada clase puede acceder a los miembros privados de otro objeto de la
misma clase.

El modificador protected, por último, indica que los elementos sólo pueden ser
accedidos desde su mismo paquete (como el acceso por defecto) y desde
cualquier clase que extienda la clase en que se encuentra, independientemente de
si esta se encuentra en el mismo paquete o no. Este modificador, como private, no
tiene sentido a nivel de clases o interfaces no internas.

Los distintos modificadores de acceso quedan resumidos en la siguiente tabla:



Static
A pesar de lo que podría parecer por su nombre, heredado de la terminología de
C++, el modificador static no sirve para crear constantes, sino para crear
miembros que pertenecen a la clase, y no a una instancia de la clase. Esto
implica, entre otras cosas, que no es necesario crear un objeto de la clase para
poder acceder a estos atributos y métodos. Este es el motivo por el cual es
obligatorio que main se declare como static; de esta forma no tenemos que ofrecer
un constructor vacío para la clase que contiene el método, o indicar de alguna
forma a la máquina virtual cómo instanciar la clase.
Un uso del modificador static sería, por ejemplo, crear un contador de los objetos
de la clase que se han creado, incrementando la variable estática en el
constructor:

Como es de esperar, dado que tenemos acceso a los atributos sin necesidad de
crear un objeto, los atributos estáticos como usuarios no se inicializan al crear el
objeto, sino al cargar la clase.
Podemos acceder a estos métodos y atributos bien desde la propia clase



o bien desde una instancia cualquiera de la clase:

Otro uso sería el de crear una recopilación de métodos y atributos relacionados a
los que poder acceder sin necesidad de crear un objeto asociado, que podría no
tener sentido o no ser conveniente, como es el caso de la clase Math.

Una característica no muy conocida que se introdujo en Java 1.5 son los static
imports, una sentencia similar al import habitual, con la salvedad de que esta
importa miembros estáticos de las clases, en lugar de clases de los paquetes,
permitiendo utilizar estos miembros sin indicar el espacio de nombres en el que se
encuentran. El ejemplo anterior podría haberse escrito también de la siguiente
forma utilizando esta característica:



Si por algún motivo requerimos cualquier tipo de computación para inicializar nuestras
variables estáticas, utilizaremos lo que se conoce como bloque estático o inicializador
estático, el cuál se ejecuta una sola vez, cuando se carga la clase.

Por último, una curiosidad relacionada que podéis utilizar para romper el hielo con una
programadora Java es que podemos utilizar un bloque static para escribir un programa
sencillo sin necesidad de un main, añadiendo una llamada a System.exit para que el
programa termine tras cargar la clase sin intentar llamar al método main

Final

Indica que una variable, método o clase no se va a modificar, lo cuál puede ser útil
para añadir más semántica, por cuestiones de rendimiento, y para detectar
errores.

Si una variable se marca como final, no se podrá asignar un nuevo valor a la
variable. Si una clase se marca como final, no se podrá extender la clase. Si es un
método el que se declara como final, no se podrá sobreescribir.



Algo muy a tener en cuenta a la hora de utilizar este modificador es que si es un
objeto lo que hemos marcado como final, esto no nos impedirá modificar el objeto
en sí, sino tan sólo usar el operador de asignación para cambiar la referencia. Por
lo tanto el siguiente código no funcionaría:

Pero, sin embargo, este si:

Miembros de clase Estaticos
Cada objeto de una clase tiene su propia copia de todas las variables de ejemplar
de clase. En ciertos casos, una sola copia de la variable en particular debe ser
compartida por todos los objetos de la clase. Por esta y otras razones utilizamos
las variables de clase static (estáticas). Una variable de clase static representa
información “que abarca toda la clase”. La declaración de un método estático
comienza con la palabra clave static.

PROGRAMAS RESUELTOS

1) Crear una clase Empleado que haga uso del modificador static y luego crea dos
objetos de Empleados.

import java.io.*;



class Empleado{
private String nombres;
private String apellidos;
private static int contador;

public Empleado(String nom, String ape)
{
nombres=nom;
apellidos=ape;
contador++;
}

public void finalize()
{
--contador;
}

public void setNombres(String nom)
{
nombres=nom;
}

public void setApellidos(String ape)
{
apellidos=ape;
}

public static void setContador(int cont)
{
contador=cont;
}

public String getNombres()
{
return nombres;
}



public String getApellidos()
{
return apellidos;
}

public static int getContador()
{
return contador;
}

public String toString()
{
return apellidos+" "+nombres;
}
}

public class PruebaEmpleadoVariableEstatica{
public static void main(String args[]) throws IOException
{
System.out.println(“Numero de objetos creados :
“+Empleado.getContador());
Empleado e1= new Empleado("Torres","Fidel");
System.out.println(e1);
System.out.println("Número de objetos creados : "+e1.getContador());
Empleado e2= new Empleado("Villanueva","Nelsa");
System.out.println(e2);
System.out.println("Número de objetos creados :
"+Empleado.getContador());
}
}



Interpretación de la programación:
En el programa anterior usamos un atributo private static y un método public static.
El atributo contador se inicializa en cero por omisión. Esta variable va contando el
numero de Objetos de la Clase Empleado que se van creando, esta variable se va
incrementando en el constructor cada vez que se crea un objeto.
Para saber cuantos objetos hemos creados llamamos al método estatico
getContador() que devuelve el valor de la variable contador.
Un método declarado static no puede acceder a miembros de clase no estáticos.
Un método static no tiene referencia this porque las variables de clase static y los
métodos static existen independientemente de que existan o no objetos de clase.
En la primera linea del Programa colocamos llamamos Empleado.getContador()
pues como es un método extático no es necesario usar un objeto de la clase par
llamar al método, solo se usa el nombre de la Clase y luego el método
getContador().

2) Crea una clase denominada FigurasGeometricas y calcula el área y el perímetro
del cuadrado, rectángulo y del triangulo. Hacerlo con métodos estáticos y métodos
no estáticos.
Respuesta con métodos estáticos:
import java.io.*;
class FigurasGeometricas
{
public static double areaCuadrado(int lado1)
{
return lado1*lado1;
}

public static double areaRectangulo(int lado1, int lado2)
{
return lado1*lado2;
}
public static double areaTriangulo(int lado1, int lado2, int lado3)
{



double p, r;
p=(lado1+lado2+lado3)/2.0;
r=p*(p-lado1)*(p-lado2)*(p-lado3);
if (r>0)
return Math.sqrt(r);
else
return 0.0;
}
public static int perimetroCuadrado(int lado1)
{
return 4*lado1;
}
public static int perimetroRectangulo(int lado1, int lado2)
{
return 2*lado1+2*lado2;
}
public static int perimetroTriangulo(int lado1, int lado2, int lado3)
{
return lado1+lado2+lado3;
}
}
public class CalculoAreaPerimetro
{
public static void main(String args[])throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int opcion, l1,l2,l3;
System.out.println("CALCULO DEL AREA Y PERIMETRO");
System.out.print("Ingrese 1: cuadrado, 2:rectangulo, 3:triangulo -> ");
opcion=Integer.parseInt(br.readLine());
if (opcion==1)
{
System.out.print("Ingrese el valor del lado del cuadrado: ");
l1=Integer.parseInt(br.readLine());
System.out.println("El area del cuadrado es:
"+FigurasGeometricas.areaCuadrado(l1));



System.out.println("El perimetro del cuadrado es:
"+FigurasGeometricas.perimetroCuadrado(l1));
}
if (opcion==2)
{
System.out.print("Ingrese el valor del lado 1 del rectangulo: ");
System.out.println("El area del rectangulo es:
"+FigurasGeometricas.areaRectangulo(l1,l2));
System.out.println("El perimetro del rectangulo es:
"+FigurasGeometricas.perimetroRectangulo(l1,l2));
}
if (opcion==3)
{
System.out.print("Ingrese el valor del lado 1 del triangulo: ");
System.out.println("El area del triangulo es:
"+FigurasGeometricas.areaTriangulo(l1,l2,l3));
"+FigurasGeometricas.perimetroTriangulo(l1,l2,l3));
}
}
}

Respuesta con métodos no estáticos:
import java.io.*;

class FigurasGeometricas
{



public double areaCuadrado(int lado1)
{
return lado1*lado1;
}

public double areaRectangulo(int lado1, int lado2)
{
return lado1*lado2;
}

public double areaTriangulo(int lado1, int lado2, int lado3)
{
double p, r;
p=(lado1+lado2+lado3)/2.0;
r=p*(p-lado1)*(p-lado2)*(p-lado3);
if (r>0)
return Math.sqrt(r);
else
return 0.0;
}

public int perimetroCuadrado(int lado1)
{
return 4*lado1;
}

public int perimetroRectangulo(int lado1, int lado2)
{
return 2*lado1+2*lado2;
}

public int perimetroTriangulo(int lado1, int lado2, int lado3)
{
return lado1+lado2+lado3;
}
}



public class CalculoAreaPerimetro
{
public static void main(String args[])throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int opcion, l1,l2,l3;
FigurasGeometricas F=new FigurasGeometricas();
System.out.println("CALCULO DEL AREA Y PERIMETRO");
System.out.print("Ingrese 1: cuadrado, 2:rectangulo, 3:triangulo -> ");
opcion=Integer.parseInt(br.readLine());
if (opcion==1)
{
System.out.print("Ingrese el valor del lado del cuadrado: ");
System.out.println("El area del cuadrado es: "+F.areaCuadrado(l1));
System.out.println("El perimetro del cuadrado es: "+F.perimetroCuadrado(l1));
}
if (opcion==2)
{
System.out.println("El area del rectangulo es: "+F.areaRectangulo(l1,l2));
"+F.perimetroRectangulo(l1,l2));
}
if (opcion==3)
{



System.out.println("El area del triangulo es: "+F.areaTriangulo(l1,l2,l3));
"+F.perimetroTriangulo(l1,l2,l3));
}
}
}

EJECUTANDO LA PRIMERA APLICACION

1. Crea un proyecto denominado: Sesion07_Aplicaciones.

Observa que debes crear la clase principal PruebaEmpleadoVariableEstatica
dentro del paquete sesion07_aplicaciones. Luego dar clic en el botón de
comando Terminar.

2. Ahora se observa el entorno de NetBeans listo para colocar la programación de
la primera aplicación.



3. Asi debe quedar luego de colocar las instrucciones de la primera aplicación.



4. Luego a proceder a ejecutar la aplicación.

Posteriormente dar clic en Ejecutar archivo.


Sesion 07 nivel_acceso_miembros_clases

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Sesion 07 nivel_acceso_miembros_clases

Ähnlich wie Sesion 07 nivel_acceso_miembros_clases (20)

Sesion 07 nivel_acceso_miembros_clases