面向对象（3）

一、对象的初始化过程

当我们用这条语句“Person p = new Person("name",20);“创建了第一个Person对象时，

计算机都做了哪些工作：

1、当new时，JVM将Person.class文件加载进内存

2、执行static代码块，给类进行初始化

3、在堆内存开辟空间，分配地址

4、在堆内存中建立特有属性，并进行默认初化,name =null;age = 0;

5、对对象属性进行显示初初始化

6、执行构造代码块

7、执行对应的构造函数

8、将堆内存地址值赋给栈内存变量p

二、对象调用成员的过程

当我们用这条语句“p.setName("Lishi");“调用非静态方法，给非静态成员变量赋值时，

计算机都做了哪些工作：

对象调用非静态方法"setName("Lishi");"，会在栈内存中开辟空间，内存中有两参数，

 第一个参数是this,是编译器自己加入的，不需要显示声明，表示调用函数的对象引用；

 第二个参数是setName函数的参数，赋值给了this指向的堆内存的实例变量name。

三、帮助文档的制作javadoc

我们创建了一个类，这个类要给其他人使用。这时我们就要制作帮助文档，方便他人使用。

可以用javadoc注释提取工具，生成HTML文件的帮助文档。它通过查找程序内的特殊注释

标签，如@author、@version等。通常，这些标签放在/**开始，*/结束的注释中，示例：

/**
 *定义了个关于人的类，提供了显示个人信息、比较年龄的方法 
 * @author nameless
 * @version v1.1
 */
public class Person {
	/**
	 * 	姓名
	 */
	private String name = "nameless";
	/**
	 * 	年龄
	 */	
	private int 		age = 0;
	/**
	 * 	国籍，static类型
	 */	
	private static String country = "CN";
	//无参构造函数
	/**
	 * 无参构造函数，无输出，初始化属性：name ="nameless",age = 0,coutry = "CN"
	 */
	public Person (){
	}
	/**
	 * 构造函数，无输出，将参数赋值给成员变量name
	 */	
	public Person(String name) {
		//成员变量name ＝ 局部变量name
		this.name =name;
	}	
	/**
	 * 构造函数，无输出，将参数n赋值给成员变量name，a赋值给成员变量age
	 */	
	public Person(String n,int a) {
		this(n);
		age = a;
	}
	/**
	 *显示出个人信息，格式(XX表成员变量)：
	 *name is XX,age is XX country is XX
	 *
	 */
	public void showWho() {
		System.out.println("name is "+ name + ",age is " + age
					      + " country is "+country);
		
	}
	//函数里的this关键字代表调用该函数的对象的引用
	/**
	 *调用者与参数person比较，同龄返回true,不同龄返回false
	 * @param person
	 * @return boolean
	 */
	public boolean isSameAge(Person person ) {
		if(this.age ==person.age) {
			return true;
		}
		return false;
	}
}	

生成的html如下：

四、单例设计模式

单例设计模式：所谓单例就是要保证内存中只能有类的唯一的一个对

想要保证对象唯一：

1、为了避免其它程序过多建立该类对象，先禁止其它对象建立该类

2、还为了让其它程序可以使用该类对象，只好在本类，自定义一个对象

3、还为了让其它程序访问到该类对象，可以对外提供一些访问方式

代码体现：

1、私有化构造函数

2、在类中创建一个对象

3、提供一个方法可以获取到该对象

class Single {	  
	private static  Single s = new Single();
	public static Single getInstance(){
		return s;
	}
	//私有默认构造函数，防止其它程序创建对象
	private Single(){};				
}
class SingleDemo{
	public static void main(String[] args) {
		Single s1 = Single.getInstance();
		Single s2 = Single.getInstance();
		//打印显示引用s1与s2指向的内存地址
		System.out.println("s1 is " +s1 +" s2 is " +s2);
	}
}

单例设计模式的另一种方式：这种方式采用在类方法被调用后，才创建对象，这种

对象的延时加载的方式，也称懒汉式，示例代码：

class SingleTwo {
	private static SingleTwo s = null;
	private SingleTwo(){};
	public static SingleTwo getInstance() {
		if(s==null) 
			/*
			 * -->A
			 * -->B
			 */
			s = new SingleTwo();
		return s;	
	}
}

在开发中，一般不采用懒汉。因为，如果存在多个程序同时调用时就有可能存在问题。

比如，A程序与B程序同时调用getInstance(),当A程序执行完if(s==null)时，被挂起，

接着执行B程序，刚好执行完if(s==null)时，被挂起。因为两者的条件都满足，所以创

建了两个对象，不满足单例原则。解决办法可通过线程加锁，较复杂这里不论述。