Java中的toString、equals方法覆写，懒汉式单例模式，及异常处理

1).Person类有name,age,salary属性，要求实现至少两个构造方法，并且属性私有，提供对应的getter、setter。
2).覆写toString方法，要求在System.out.println()函数中传递Person对象能打印出三个属性值而不是对象地址。

3).覆写equals方法，要求两个Person类对象的值相同时返回true。

class Person{
	private String name;
	private int age;
	private double salary;
	
	public Person() {
	}
	public Person(String name, int age, double salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}

	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", salary=" + salary + "]";
	}
	public boolean equals(Object obj) {
		if(obj==null) {
			return false;
		}
		if(obj==this) {
			return true;
		}
		if(obj instanceof Person) {
			Person tmp = (Person)obj;
			if(tmp.getAge()!=this.age) {
				return false;
			}
			if(tmp.getName()==null) {
				if(this.name!=null) {
					return false;
				}
			}else if(!tmp.getName().equals(this.name)) {
				return false;
			}
			if(tmp.getSalary()==this.salary) {
				return true;
			}			
		}
		return false;		
	}
	
}

public class Test412 {
	public static void main(String[] args) {
		Person p1 = new Person();
		Person p2 = new Person();
		Person p3 = new Person("张三", 20, 2000.5);
		Person p4 = new Person("张三", 20, 2000.5);
		Person p5 = new Person("李四", 20, 2000.5);
		System.out.println(p1.equals(p2));
		System.out.println(p3.equals(p4));
		System.out.println(p3.equals(p5));
		System.out.println(p1);
		System.out.println(p2);
		System.out.println(p3);
		System.out.println(p4);
		System.out.println(p5);
	}
	
}

//3.说出下列程序的执行结果，并说明原因: 
 Integer a = 55; 
 Integer b = 55; 
 System.out.println(a==b); 
 System.out.println(a==new Integer(55)); 
 System.out.println(a.equals(new Integer(55))); 
 Integer c = 129; 
 Integer d = 129; 
 System.out.println(c==d);

结果：

1. true //直接赋值，数值在-128~127之间的数，对象会在IntegerCache.cache 产生，会复用已有对象，所以返回结果为true

2. flase //通过new在堆内存开辟新的空间，所指向的不是同一地址，地址值不同，结果为false

3. true //我们看一下Integer的equals的源码

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

显然，Integer的equals的方法经过覆写了，它比较的该对象的属性value,55==55所以返回true

4. flase //如1所说的，数值129不在范围内，故在堆内存上开辟新的空间，两对象引用固然不同

懒汉单例模式和饿汉单例模式

package com;

//懒汉式单例模式 
class Singleton {
	private static Singleton instance;	
	private Singleton() {		
	}
	public static Singleton getInstance() {
		if(instance==null) {
			Singleton.instance = new Singleton();
		}
		return instance;
	}	
	public void print() {
		System.out.println("懒汉单例模式");
	}
}

//饿汉式单例模式 
class SingletonH{
	private final static SingletonH INSTANCE = new SingletonH();
	private SingletonH() {
	}
	public static SingletonH getInstance() {
		return INSTANCE;
	}
	public void print() {
		System.out.println("饿汉单例模式");
	}
}

public class Trst413 {
	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		s1.print();
		SingletonH h1 = SingletonH.getInstance();
		SingletonH h2 = SingletonH.getInstance();
		s2.print();
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(h1);
		System.out.println(h2);
	}
}

从结果上来看，两者并没有什么不同，但是懒汉式存在多线程安全问题，而饿汉式不会。

从结构上看，懒汉式的属性instance没有初始化，而饿汉式在属性上初始化，可以这样理解记忆，懒汉式懒得去初始化交给方法去做，饿汉式已经饿的不行了，急着要吃这个实例化对象。

异常处理

1).定义一个MulException类继承Exception类，要求两数相乘等于100报错，在主类中定义一个方法，在方法中抛出此异常，在主方法观察结果。

class MulException extends Exception{
	public MulException() {
		super("两数的乘积不能等于100");
	}
}
public class Trst413 {
	public static void main(String[] args) {
		try {
			System.out.println(mul(20, 5));
		}catch (MulException e) {
			e.printStackTrace();
		}	
	}
	
	public static int mul(int a, int b) throws MulException{
		if(a*b==100) {
			throw new MulException();
		}
		return a*b;
	}
}

2).定义一个DivException类继承RuntimeException类，要求两数相除等于2报错，在主类中定义一个方法，在方法中抛出此异常，在主方法观察结果。

class DivException extends RuntimeException{
	public DivException(String msg) {
		super(msg);
	}
}
public class Trst413 {
	public static void main(String[] args) {
		try {
			System.out.println(div(4, 2));
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	public static int div(int x, int y) throws DivException{
		int res=0;
		res = x/y;
		if(res==2) {
			throw new DivException("两数相除不能等于2");
		}
		return res;
	}	
}

题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。

拿一天来举例：昨天的数量/2-1=今天的数量，则，昨天的数量=（今天的数量+1）*2，猴子是从第一天开始吃的，到第十天共吃了9天，所以只要做9次循环即可

	int n = 1;
	for(int i=0;i<9;i++) {
		n=(n+1)*2;
	}
	System.out.println(n);

结果：1534