Manejo de Niveles de Acceso en Java

Alcance Privado:

  1 /*
  2  * To change this template, choose Tools | Templates
  3  * and open the template in the editor.
  4  */
  5 
  6 package paqueteA;
  7 
  8 /**
  9  *
 10  * @author igor
 11  */
 12 public class Cliente {
 13     /*
 14      * Alcance Privado:
 15      * los elementos(clase, atributos o métodos) declarados con alcance
 16      * privado solo pueden ser accesados dentro de la clase que los contienen.
 17      * para poder acceder a ellos se implementan métodos que acceden a
 18      * ellos, llamados set y get
 19      */
 20     private String codigoCliente;
 21     private String nombre;
 22     private String apellidos;
 23     private String dni;
 24     private String domicilio;
 25     private String telefono;
 26 
 27     public Cliente(String codigoCliente, String nombre, String apellidos,
 28             String dni, String domicilio, String telefono) {
 29         this.codigoCliente = codigoCliente;
 30         this.nombre = nombre;
 31         this.apellidos = apellidos;
 32         this.dni = dni;
 33         this.domicilio = domicilio;
 34         this.telefono = telefono;
 35     }
 36 
 37     public Cliente() {
 38 
 39     }
 40 
 41     /*
 42      * Inicio de los metodos set y get
 43      */
 44     public String getApellidos() {
 45         return apellidos;
 46     }
 47 
 48     public void setApellidos(String apellidos) {
 49         this.apellidos = apellidos;
 50     }
 51 
 52     public String getCodigoCliente() {
 53         return codigoCliente;
 54     }
 55 
 56     public void setCodigoCliente(String codigoCliente) {
 57         this.codigoCliente = codigoCliente;
 58     }
 59 
 60     public String getDni() {
 61         return dni;
 62     }
 63 
 64     public void setDni(String dni) {
 65         this.dni = dni;
 66     }
 67 
 68     public String getDomicilio() {
 69         return domicilio;
 70     }
 71 
 72     public void setDomicilio(String domicilio) {
 73         this.domicilio = domicilio;
 74     }
 75 
 76     public String getNombre() {
 77         return nombre;
 78     }
 79 
 80     public void setNombre(String nombre) {
 81         this.nombre = nombre;
 82     }
 83 
 84     public String getTelefono() {
 85         return telefono;
 86     }
 87 
 88     public void setTelefono(String telefono) {
 89         this.telefono = telefono;
 90     }
 91 
 92     @Override
 93     public String toString() {
 94         return "\nCliente{" +
 95                 "\ncodigoCliente=" + codigoCliente +
 96                 "\nnombre=" + nombre +
 97                 "\napellidos=" + apellidos +
 98                 "\ndni=" + dni +
 99                 "\ndomicilio=" + domicilio +
100                 "\ntelefono=" + telefono + '}';
101     }
102 
103 }
104 
105 

Alcance Protegido:

 1 /*
 2  * To change this template, choose Tools | Templates
 3  * and open the template in the editor.
 4  */
 5 
 6 package paqueteA;
 7 
 8 import java.util.GregorianCalendar;
 9 
10 /**
11  *
12  * @author igor
13  */
14 /*
15  * Alcance Protegido:
16  * utilizado en la declaración de elementos cuando tratamos de representar
17  * la herencia entre las clases para que una clase en java se convierta
18  * en una clase padre se debe agregar la palabra reservada abstract antes
19  * de class, o que contenga un método abstracto, o que sea una interface.
20  * Un Elemento protegido tiene dos aspectos:
21  * Visible dentro del paquete: tanto como dentro de la clase como para las
22  * demás clases que se comparten en el paquete
23  * Visible fuera del paquete solo para las clases hijas(HERENCIA)
24  *
25  * NOTA: no se pueden crear objetos a partir de una clase abstracta :P
26  * asi que ni lo intenten.
27  */
28 public abstract class Persona {
29     protected String nombre;
30     protected String apellidos;
31     protected String dni;
32     protected GregorianCalendar fechaNacimiento;
33 
34     protected  Persona() {
35         this("no definido", "no definido", "no definido",
36                 new GregorianCalendar());
37     }
38 
39     protected  Persona(String nombre, String apellidos, String dni,
40             GregorianCalendar fechaNacimiento) {
41         this.nombre = nombre;
42         this.apellidos = apellidos;
43         this.dni = dni;
44         this.fechaNacimiento = fechaNacimiento;
45     }
46 
47 }
48 
49 

 1 /*
 2  * To change this template, choose Tools | Templates
 3  * and open the template in the editor.
 4  */
 5 
 6 package paqueteB;
 7 
 8 import java.util.Calendar;
 9 import java.util.GregorianCalendar;
10 import paqueteA.Persona;
11 
12 /**
13  *
14  * @author igor
15  */
16 /*
17  * estamos dentro del paquete B y podemos acceder a los elementos de la
18  * clase Persona declarados con alcance protegido por el mecanismo de
19  * herencia
20  */
21 public class Alumno extends Persona{
22     private String codigoMatricula;
23     private String carrera;
24     private GregorianCalendar fechaIngreso;
25 
26     public Alumno(String nombre, String apellidos, String dni,
27             GregorianCalendar fechaNacimiento, String codigoMatricula,
28             String carrera, GregorianCalendar fechaIngreso) {
29         /*
30          * con super accedemos al constructor que recibe parametros
31          * de la clase Persona
32          */
33         super(nombre, apellidos, dni, fechaNacimiento);
34         this.codigoMatricula = codigoMatricula;
35         this.carrera = carrera;
36         this.fechaIngreso = fechaIngreso;
37     }
38 
39     //accediendo a sus elementos protegidos en el metodo toString();
40     //toString(), usado para mostrar informacion del objeto
41     @Override
42     public String toString(){
43         return "\nAlumno:"
44                 + "\nNombre: "+nombre
45                 + "\nApellidos: "+apellidos
46                 + "\nDni: "+dni
47                 + "\nFechaNacimiento: "+fechaNacimiento.get(Calendar.YEAR)+"/"+
48                 (fechaNacimiento.get(Calendar.MONTH)+1)+"/"+
49                 fechaNacimiento.get(Calendar.DAY_OF_MONTH)
50                 + "\nCodigoMatricula: "+codigoMatricula
51                 + "\nCarrera: "+carrera
52                 + "\nFechaIngreso: "+fechaIngreso.get(Calendar.YEAR)+"/"+
53                 (fechaIngreso.get(Calendar.MONTH)+1)+"/"+
54                 fechaIngreso.get(Calendar.DAY_OF_MONTH);
55     }
56 
57 
58 }
59 
60 

 1 /*
 2  * To change this template, choose Tools | Templates
 3  * and open the template in the editor.
 4  */
 5 
 6 package paqueteA;
 7 
 8 import java.util.Calendar;
 9 import java.util.GregorianCalendar;
10 
11 /**
12  *
13  * @author igor
14  */
15 /*
16  * vean que tambien podemos acceder a los elementos protegidos cuando la clase
17  * hija se encuentra en el mismo paquete que la clase padre
18  */
19 public class Empleado extends Persona {
20     private String codigoEmpleado;
21     private String cargo;
22     private double salario;
23 
24     public Empleado(String nombre, String apellidos, String dni,
25             GregorianCalendar fechaNacimiento, String codigoEmpleado,
26             String cargo, double salario) {
27         super(nombre, apellidos, dni, fechaNacimiento);
28         this.codigoEmpleado = codigoEmpleado;
29         this.cargo = cargo;
30         this.salario = salario;
31     }
32 
33     //metodo que devuelve la fecha en formato dd/mm/aa
34     public String fechaNacimiento(){
35         return fechaNacimiento.get(Calendar.DAY_OF_MONTH) + "/" +
36                 (fechaNacimiento.get(Calendar.MONTH)+1) + "/" +
37                 fechaNacimiento.get(Calendar.YEAR);
38     }
39 
40     @Override
41     public String toString(){
42         return "\nEmpleado:"
43                 + "\nNombre: "+nombre
44                 + "\nApellidos: "+apellidos
45                 + "\nDni: "+dni
46                 + "\nFechaNacimiento: "+fechaNacimiento()
47                 + "\nCodigoEmpleado: "+codigoEmpleado
48                 + "\nCargo: "+cargo
49                 + "\nSalario: "+salario;
50     }
51 
52 }
53 
54 

Alcance Amigable(Friendly):

 1 /*
 2  * To change this template, choose Tools | Templates
 3  * and open the template in the editor.
 4  */
 5 
 6 package paqueteA;
 7 
 8 /**
 9  *
10  * @author igor
11  */
12 /*
13  * Alcance friendly (Amigable)
14  * no existe palabra reservada para representar este tipo de alcance
15  * solo se tiene que declarar el elemento con su tipo de dato y su nombre
16  * de variable o clase.
17  *
18  * los elementos para este tipo de alcance solo son visibles dentro de la clase
19  * y del paquete que contiene a la clase.
20  */
21 public class Planeta {
22     /*
23      * características físicas de un planeta
24      */
25     double masa;
26     double volumen;
27     double densidad;
28     double areaSuperficie;
29     double radio;
30     double gravedad;
31     double velocidadEscape;
32     double periodoRotacion;
33     double anguloInclinacion;
34 
35     public Planeta(){
36 
37     }
38 
39     public Planeta(double masa, double volumen, double densidad,
40             double areaSuperficie, double radio, double gravedad,
41             double velocidadEscape, double periodoRotacion,
42             double anguloInclinacion) {
43         this.masa = masa;
44         this.volumen = volumen;
45         this.densidad = densidad;
46         this.areaSuperficie = areaSuperficie;
47         this.radio = radio;
48         this.gravedad = gravedad;
49         this.velocidadEscape = velocidadEscape;
50         this.periodoRotacion = periodoRotacion;
51         this.anguloInclinacion = anguloInclinacion;
52     }
53 
54     @Override
55     public String toString() {
56         return "\nPlaneta{"
57                 + "\nmasa=" + masa
58                 + "\nvolumen=" + volumen
59                 + "\ndensidad=" + densidad
60                 + "\nareaSuperficie=" + areaSuperficie
61                 + "\nradio=" + radio
62                 + "\ngravedad=" + gravedad
63                 + "\nvelocidadEscape=" + velocidadEscape
64                 + "\nperiodoRotacion=" + periodoRotacion
65                 + "\nanguloInclinacion=" + anguloInclinacion + '}';
66     }
67 
68 
69     //metodo main
70     public static void main(String[] args) {
71         Planeta p = new Planeta();
72         //aqui si puede ser accedido
73         p.masa = 5.6;
74     }
75 
76 }
77 
78 

Alcance Público

 1 /*
 2  * To change this template, choose Tools | Templates
 3  * and open the template in the editor.
 4  */
 5 
 6 package paqueteA;
 7 
 8 /**
 9  *
10  * @author igor
11  */
12 /*
13  * Alcance Público:
14  * Visible fuera del paquete, todos pueden hacer uso de las clases y
15  * metodos. El elemento puede ser accedido desde cualquier parte
16  */
17 public class Avion {
18     public String codigo;
19     public double peso;
20     public String color;
21     public String tipo;
22 
23     public Avion(String codigo, double peso, String color, String tipo) {
24         this.codigo = codigo;
25         this.peso = peso;
26         this.color = color;
27         this.tipo = tipo;
28     }
29 
30     public Avion() {
31 
32     }
33 
34     @Override
35     public String toString() {
36         return "\nAvion{"
37                 + "\ncodigo=" + codigo
38                 + "\npeso=" + peso
39                 + "\ncolor=" + color
40                 + "\ntipo=" + tipo + '}';
41     }
42 
43 }
44 
45 

Probando las Clases

 1 /*
 2  * To change this template, choose Tools | Templates
 3  * and open the template in the editor.
 4  */
 5 
 6 package pruebas;
 7 
 8 import java.util.GregorianCalendar;
 9 import paqueteA.Avion;
10 import paqueteA.Cliente;
11 import paqueteA.Empleado;
12 import paqueteA.Planeta;
13 import paqueteB.Alumno;
14 
15 /**
16  *
17  * @author igor
18  */
19 public class pruebas {
20     public static void main(String[] args) {
21         //creando al objeto cliente
22         Cliente cliente = new Cliente("0001", "Igor Alexander", 
23                 "Quispe Vasquez", "12596520", "Mi Casa 445", "5555-55555");
24         //intentando acceder a un atributo privado de Cliente
25         //->cliente.codigoCliente; esta como comentario por que provoca un
26         //error.
27         //mostrando informacion del objeto creado
28         System.out.println(cliente.toString());
29 
30         //yo que les dije no se pueden crear objetos de persona ya de ahi
31         //les dire por que.
32         //->Persona persona = new Persona(); quiten las barras de comentario
33         //para que puedan observar :\
34         //creando al objeto alumno
35         Alumno alumno = new Alumno("Jhoe Alexander", "Narva Rojas",
36                 "56996478", new GregorianCalendar(1992, 11, 16), "5566971",
37                 "Ingenieria de Sistemas", new GregorianCalendar(2010, 2, 5));
38         System.out.println(alumno.toString());
39 
40         //creando un empleado
41         Empleado empleado = new Empleado("Walter Flavio", "Campos Cabanillas",
42                  "5655214",new GregorianCalendar(1985, 11, 13), "00023",
43                 "Administrador de Data Base", 5000.0);
44         System.out.println(empleado.toString());
45 
46         //creando Planeta
47         Planeta planeta = new Planeta();
48         // esto no puede ser posible por que masa es de alcande friendly
49         // y solo puede ser accedido en su paquete.
50         // planeta.masa = 5.6;
51 
52         //creando un avion, como sus atributos son de alcance public
53         //podemos asignar valores directamente desde este lugar.
54         Avion avion = new Avion();
55         avion.codigo = "AirBus789-66994B";
56         avion.color = "Blanco";
57         avion.peso = 5;
58         avion.tipo = "Transporte Publico";
59         System.out.println(avion.toString());
60 
61     }
62 
63 }
64 
65 

run:
Cliente{
codigoCliente=0001
nombre=Igor Alexander
apellidos=Quispe Vasquez
dni=12596520 domicilio=
Mi Casa 445
telefono=5555-55555}

 Alumno:
Nombre: Jhoe Alexander
Apellidos: Narva Rojas
Dni: 56996478
FechaNacimiento: 1992/12/16
CodigoMatricula: 5566971
Carrera: Ingenieria de Sistemas
FechaIngreso: 2010/3/5

 Empleado: Nombre: Walter Flavio
Apellidos: Campos Cabanillas
Dni: 5655214
FechaNacimiento: 13/12/1985
CodigoEmpleado: 00023
Cargo: Administrador de Data Base
Salario: 5000.0

 Avion{
codigo=AirBus789-66994B
peso=5.0
color=Blanco
 tipo=Transporte Publico}
GENERACIÓN CORRECTA (total time: 4 seconds)

RESUMEN

 1 /*
 2  * To change this template, choose Tools | Templates
 3  * and open the template in the editor.
 4  */
 5 
 6 package paqueteA;
 7 
 8 /**
 9  *
10  * @author igor
11  */
12 public class Resumen {
13     /*
14      * RESUMEN
15      * Alcance Privado:
16      * un miembro privado de una clase declarado private puede ser accedido por 
17      * un objeto de esa clse sólo desde los métodos de dicha clase. Esto
18      * significa que no puede ser accedido por los metodos de cualquier
19      * otra clase, incluidas las subclases.
20      * 
21      * paquete entidades
22      * public class Circulo{
23      *      private double radio;
24      *      private double area;
25      *      private double diametro;
26      * 
27      *      Solo pueden ser accedidos por los metodos de la clase que contiene
28      *      a los miembros privados
29      *      Circulo(){
30      *          radio = 0.0;
31      *          area = 0.0;
32      *          diametro = 0.0;
33      *      }
34      * }
35      * 
36      * 
37      * Paquete pruebas
38      * public class Test{
39      *      public static void main(String[] args){
40      *          Circulo c = new Ciculo(100.0, 200.0, 10.0);
41      *       -> double c = c.radio; // error: miembro privado
42      *      }
43      * }
44      * 
45      * Alcance Protegido
46      * Un miembro de una clase declarado protected se comporta exactamente
47      * igual que uno privado para los métodos de cualquier otra clase, excepto
48      * para los métodos de las clases del mismo paquete o de las subclases
49      * con independencia del paquete al que pertenecen, para las que se
50      * comporta como un miembro público.
51      * 
52      * 
53      * Alcance Amigable(Friendly o de paquete)
54      * Un miembro de una clase declarado sin modificadores de acceso que
55      * indiquen el control de acceso, puede ser accedido por cualquier clase
56      * perteneciente al mismo paquete. Ninguna otra clase, o subClase, fuera
57      * de este puede tener acceso a estos miembros.
58      * Como se puede observar este tipo de control de acceso no tiene mucho
59      * dominio sobre el mismo. Si lo que se pretende es tener un control
60      * preciso sobre como va a ser utilizada nuestra clase por otras, debemos
61      * utilizar los modificadores private, protected, o public en vez de 
62      * aceptar el tipo de control predeterminado.
63      * 
64      * Alcance Público
65      * Un miembro de una clase declarado public puede ser accedido por un
66      * objeto de esa clsae en cualquier para de la aplicación donde el objeto
67      * en cuestion sea accesible.
68      */
69     
70 
71 }
72 
73