用一个类的两个对象去组成另一个类，这两个对象直接没有直接的关系；
一个类里面的成员变量可以是其他类的对象；
电子时钟的设计
//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();
}
}
注意：这里有个直接输出对象；
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();
}
}
访问属性
封装，就是把数据和对这些数据的操作放在一起，并且用这些操作把数据掩盖起来，是面向对象的基本概念之一，也是最核心的概念。
我们有一个非常直截了当的手段来保证在类的设计的时候做到封装：
- 所有的成员变量必须是private的，这样就避免别人任意使用你的内部数据；
- 所有public的函数，只是用来实现这个类的对象或类自己要提供的服务的，而不是用来直接访问数据的。除非对数据的访问就是这个类及对象的服务。简单地说，给每个成员变量提供一对用于读写的get/set函数也是不合适的设计。问属性
private
- 只有这个类内部可以访问；
- 类内部指类的成员函数和定义初始化；
- 这个限制是对类的而不是对对象的；
一个类的所有的不同对象之间可以访问其他对象的私有成员；
私有是针对类；
public
public class * 必须在即在自己的文件里面才可以，最多有一个 public；
包
当你的程序越来越大的时候，你就会需要有一个机制帮助你管理一个工程中众多的类了。包就是Java的类库管理机制，它借助文件系统的目录来管理类库，一个包就是一个目录，一个包内的所有的类必须放在一个目录下，那个目录的名字必须是包的名字。
类变量
类是描述，对象是实体。在类里所描述的成员变量，是位于这个类的每一个对象中的。
而如果某个成员有static关键字做修饰，它就不再属于每一个对象，而是属于整个类的了。
通过每个对象都可以访问到这些类变量和类函数，但是也可以通过类的名字来访问它们。类函数由于不属于任何对象，因此也没有办法建立与调用它们的对象的关系，就不能访问任何非static的成员变量和成员函数了。
static 的初始化和对象是没有关系的，只初始化一次；
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
}
}