JAVA面向对象编程学习 (2)对象交互

问题引入

当一个对象里有多个对象的时候，那些对象之间是如何交互的，对象和对象之间的联系是如何建立的，对象如何和其他对象交流。

对象和对象之间的联系紧密程度叫做耦合。对象和对象的耦合程度越紧，表现在源代码上，就是它们的代码是互相依赖、互相牵制的。我们理想的模型，是对象和对象之间的耦合要尽可能的松，平行的对象要尽量减少直接联系，让更高层次的对象来提供通信服务。

两个对象组成时钟程序

用一个类的两个对象，去构造出了另外一个的类
我们在设计时钟这个类的时候，需要有两个实现进位的对象，这两个对象应该是互不干扰，平行运作的，然后再clock里面通过if或者while等手段来实现产生联系的效果。

进位程序代码

package clock;

public class Diaplay
{
	private int val=0;
	private int lim=0;
	
	public Diaplay(int limit)
	{
		this.lim=limit;
	}
	
	public void increase()
	{
		val++;
		if(val==lim)
		{
			val=0;
		}
	}
	
	public int getval()
	{
		return val;
	}
	
	public static void main(String argvs[])
	{
		Diaplay d= new Diaplay(24);
		while(true)
		{
			d.increase();
			System.out.println(d.getval());
		}
	}
}

clock对象中代码

package clock;

public class Clock
{
	private Diaplay hour=new Diaplay(24);
	private Diaplay minute=new Diaplay(60);
	public void start()
	{
		while(true)
		{
			minute.increase();
			if(minute.getval()==0)
			{
				hour.increase();
			}
			System.out.printf("%02d:%02d\n", hour.getval(),minute.getval());
		}
	}
	public static void main(String s[])
	{
		Clock clock=new Clock();
		clock.start();
	}
}

这个设计就是在设计到对象中嵌套对象的这种设计的时候，会考虑耦合性，尽量保证这对象中的对象的运作是平行运作的，再在外层大对象中实现对这两个对象的操作。

访问属性

封装

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

实现封装的注意事项:
1.所有的成员变量必须是private的，这样就避免别人任意使用你的内部数据；
2.所有public的函数，只是用来实现这个类的对象或类自己要提供的服务的，而不是用来直接访问数据的。除非对数据的访问就是这个类及对象的服务。简单地说，给每个成员变量提供一对用于读写的get/set函数也是不合适的设计。

private

private只能用于成员变量还有成员函数,它的意思是说这个变量或者函数是这个类所私有的,只有在这个类的内部才能访问到
而类的内部指的是成员函数和定义初始化
这个限制是对类的而不是对对象的(这一点我们可以这样解释，在一个定义有多个对象的类中，在类内部的对象可以互相使用类内的对象)

public

public字如其名，可以被任何对象所调用。
值得注意的是，当我们不在成员函数上使用public关键字的时候，被认为是"friendly",在同一个包下是可以被使用的，

同时，我们在定义类的时候也用到的是public，我们在java类文件的类名称必须与文件名一致，否则需要重构
上面提到的定义public成员函数和成员变量的，对于定义类也是这么一回事，没有在这个包里面就不能用。

包

包就是Java的类库管理机制，它借助文件系统的目录来管理类库，一个包就是一个目录，一个包内的所有的类必须放在一个目录下，那个目录的名字必须是包的名字。

学这个的时候让我联想到了C++里面的namespace，指代的是某一个目录空间下的文件，进行相对应的代码联系，use namespace这个就相当于JAVA里面的import xxx.xxx，就是指代你要用哪个包里面的哪个类。
只要你用的那个类不跟你在同一个包里面的，你就要import进来。

import display.*//这个把那个包内的所有的包都弄进来

类变量与类函数

类是描述，对象是实体。在类里所描述的成员变量，是位于这个类的每一个对象中的。

而如果某个成员有static关键字做修饰，它就不再属于每一个对象，而是属于整个类的了。

通过每个对象都可以访问到这些类变量和类函数，但是也可以通过类的名字来访问它们。类函数由于不属于任何对象，因此也没有办法建立与调用它们的对象的关系，就不能访问任何非static的成员变量和成员函数了。

static关键字(静态)

这个关键字可以用来定义类变量，这个变量是存在于整个类中的，它可以在对象中直接呼出，并且修改，修改的时候所有属于这个类的对象都会被相对应地修改，也可以直接通过类直接呼出变量进行修改。

在含有static定义的函数可以在一个类内直接调用。
类函数中没有this，因为类函数不会和某个对象或者其成员产生互动，也就不需要使用this标识调用其的是哪个对象。

作业题

package clock;

import java.util.Scanner;

public class Main 
{
	public static void main(String s[])
	{
		int hour,min,sec;
		Scanner in = new Scanner(System.in);
		hour=in.nextInt();
		min=in.nextInt();
		sec=in.nextInt();
		Clock clock=new Clock(hour,min,sec);
		clock.clock_start();
		in.close();
	}
}

class Clock
{
	private int hour;
	private int min;
	private int sec;
	private int index=0;
	private Disaply Hour;
	private Disaply Min ;
	//其实不需要这么写的,只是我为了理解一个对象管理多个对象这种模式的写法
	Clock(int hour_in,int min_in,int sec_in)//构造函数
	{
		this.hour=hour_in;
		this.min=min_in;
		this.sec=sec_in;
		Hour =new Disaply(this.hour, 24);
		Min = new Disaply(this.min, 60);
	}
	public void tick()
	{
		final int time_lim=60;
		this.sec++;
		if(this.sec==time_lim)
		{
			this.sec=0;
		}
	}
	public String toString()
	{
		return String.format("index:%02d:%02d:%02d:%02d", this.index++,Hour.getVal(),Min.getVal(),this.sec);
	}
	public void clock_start()
	{
		while(this.index<=50)//为了验证程序的正确性，我只打印前五十条信息来看各种信息是否都对应上
		{
			this.tick();
			if(this.sec==0)
			{
				Min.tick();
				if(Min.getVal()==0)
				{
					Hour.tick();
				}
			}
			System.out.println(toString());
		}
	}
}

class Disaply
{
	private int val;
	private int lim;
	Disaply(int value,int limit)//构造函数
	{
		this.val=value;
		this.lim=limit;
	}
	
	//1.进位机制
	public void tick()
	{
		this.val++;
		if(this.val==this.lim)
		{
			val=0;
		}
	}
	
	//2.返回函数
	public int getVal()
	{
		return this.val;
	}
}