Utilice dos objetos de una clase para formar otra clase, estos dos objetos no están directamente relacionados
, las variables miembro de una clase pueden ser objetos de otras clases;
Diseño de Reloj Electrónico
//Display.java
package clock;
public class Display {
private int value = 0;
private int limit = 0;
public Display(int limit){
this.limit = limit;
}
public void increase() {
value ++;
if(value == limit)
{
value = 0;
}
}
public int getValue() {
return value;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
//Clock.java
package clock;
public class Clock {
private Display hour = new Display(24);
private Display minute = new Display(60);
public void start() {
while(true) {
minute.increase();
if(minute.getValue() == 0)
{
hour.increase();
}
System.out.printf("%02d : %02d\n", hour.getValue(), minute.getValue());
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Clock clock = new Clock();
clock.start();
}
}
Nota: aquí hay un objeto de salida directa;
package clock;
class Display{
private int value;
private int limit;
public Display(int limit)
{
this.limit = limit;
}
public void incream()
{
value ++;
}
public void setValue(int value)
{
this.value = value;
}
public int getValue()
{
return value;
}
}
class Clock{
private Display s1 = new Display(60);
private Display m = new Display(60);
private Display h = new Display(24);
public Clock(int a, int b, int c)
{
h.setValue(a);
m.setValue(a);
s1.setValue(c);
}
public void tick()
{
s1.incream();
if(s1.getValue() == 0)
{
m.incream();
if(m.getValue() == 0)
{
h.incream();
}
}
}
public String toString()
{
String s = String.format("%02d:%02d:%02d\n",h.getValue(), m.getValue(),s1.getValue());
return s;
}
}
public class Main{
public static void main(String[] args) {
java.util.Scanner in = new java.util.Scanner(System.in);
Clock clock = new Clock(in.nextInt(), in.nextInt(), in.nextInt());
clock.tick();
System.out.println(clock);
in.close();
}
}
propiedad de acceso
La encapsulación consiste en juntar datos y operaciones sobre estos datos, y usar estas operaciones para encubrir los datos. Es uno de los conceptos básicos de la orientación a objetos y el concepto central.
Tenemos una forma muy sencilla de garantizar la encapsulación durante el diseño de la clase:
- Todas las variables miembro deben ser privadas, para evitar que otros utilicen arbitrariamente sus datos internos;
- Todas las funciones públicas solo se utilizan para implementar los servicios que proporcionarán los objetos de esta clase o la clase misma, no para acceder directamente a los datos. A menos que el acceso a los datos sea un servicio de esta clase y objeto. En pocas palabras, también es un diseño inapropiado proporcionar a cada variable miembro un par de funciones get/set para leer y escribir. preguntar atributo
privado
- Solo dentro de esta clase se puede acceder;
- Dentro de la clase se refiere a las funciones miembro y la definición de inicialización de la clase;
- Esta restricción es para clases, no para objetos;
Todos los objetos diferentes de una clase pueden acceder a miembros privados de otros objetos,
privado es para la clase;
público
public class * debe estar en su propio archivo, como máximo un público;
Bolso
A medida que su programa crezca, necesitará un mecanismo que lo ayude a administrar numerosas clases en un proyecto. El paquete es el mecanismo de administración de la biblioteca de clases de Java. Administra las bibliotecas de clases con la ayuda de los directorios del sistema de archivos. Un paquete es un directorio. Todas las clases en un paquete deben colocarse en un directorio, y el nombre de ese directorio debe ser el nombre del paquete.
variable de clase
Las clases son descripciones, los objetos son entidades. Las variables miembro descritas en la clase se encuentran en cada objeto de la clase.
Y si se modifica un miembro con la palabra clave estática, ya no pertenece a cada objeto, sino a toda la clase.
Se puede acceder a estas variables de clase y funciones de clase a través de cada objeto, pero también se puede acceder a ellas a través del nombre de clase. Dado que las funciones de clase no pertenecen a ningún objeto, no hay forma de establecer una relación con el objeto que las llama, por lo que no pueden acceder a ninguna variable miembro ni función miembro no estática.
La inicialización de static no tiene nada que ver con el objeto, solo se inicializa una vez;
package display;
public class Display {
private int value = 0;
private int limit = 0;
private static int step = 1;
public Display(int limit){
this.limit = limit;
}
public void increase() {
value ++;
if(value == limit)
{
value = 0;
}
}
public int getValue() {
return value;
}
public static void show() {
step ++;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Display d1 = new Display(1);
Display.step = 2;
System.out.println(d1.step);//2
Display d2 = new Display(2);
System.out.println(d2.step);//2
System.out.println(d1.step);//2
System.out.println(d2.step);//2
Display.step = 3;
System.out.println(d1.step);//3
System.out.println(d2.step);//3
show();//4
Display.show();//5
d1.show();//6
System.out.println(d1.step);//6
System.out.println(d2.step);//6
}
}