7_Java_对象交互

用一个类的两个对象去组成另一个类，这两个对象直接没有直接的关系；
一个类里面的成员变量可以是其他类的对象；

电子时钟的设计

//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();
	}
}

访问属性

封装，就是把数据和对这些数据的操作放在一起，并且用这些操作把数据掩盖起来，是面向对象的基本概念之一，也是最核心的概念。

我们有一个非常直截了当的手段来保证在类的设计的时候做到封装：

1. 所有的成员变量必须是private的，这样就避免别人任意使用你的内部数据；
2. 所有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
	}

}