JavaDay09 类加载，单例模式，接口，包装类，==和equals_练习题

1. 分析以下四个程序的输出结果

//构造器、静态代码块、方法体的执行顺序
public class Test {
	public Test() {
		System.out.println("构造器");
	}
	public void info() {
		System.out.println("info");
	}
	static {
		System.out.println("test static 1");
	}
	public static void main(String[] args) {
		new Test().info();
	}
	static {
		System.out.println("test static 2");
	}
}
/*
 * 输出结果：
 * test static 1
 * test static 2
 * 构造器
 * info
 */

在main方法中new一个对象时，虚拟机要加载这个类，首先会加载这个类的静态属性和静态代码块，然后调用这个类的构造器，然后再调用这个类的方法，再执行方法体。

2. 编写一个类,实现简单的单例模式

单例模式:单例模式是一种常用的软件设计模式,其定义是保证整个系统中一个类只有一个对象的实例,实现这种功能的方式就叫单例模式。

1. 写一个类实现单例模式：

public class Superman {
	private String name;
	private static Superman superman = null;
	private Superman() {}
	public static Superman getInstence() {
		if(superman==null) {
			superman = new Superman();
			//return superman;
		}
		return superman;
	}
	public void fly() {
		System.out.println("超人会飞");
	}
}

2. 测试这个单例：

public class SupermanTest {
	public static void main(String[] args) {
		Superman sm1 = Superman.getInstence();
		Superman sm2 = Superman.getInstence();
		System.out.println(sm1==sm2);
	}
}

3. 利用接口做参数，写个计算器，完成加减乘除运算的功能

要求:

1. 定义一个接口Compute含有一个方法int computer(int n, int m)。
2. 设计四个类分别实现此接口,完成加减乘除运算。
3. 设计一个类UseCompute,类中含有方法:public void useCom(Compute com, int one, int two),此方法能够用传递过来的对象调用computer方法完成运算,并输出运算的结果。
4. 设计一个主类Test,调用UseCompute中的方法useCom来完成加减乘除运算。

//1.Compute接口，用于获取要计算的值：
public interface Compute {
	int computer(int n, int m);
}

//2.实现四个运算方法：加、减、乘、除，各自继承接口进行运算：
//加
public class Add implements Compute{
	@Override
	public int computer(int n, int m) {
		return n+m;
	}
}
//减
public class Sub implements Compute{
	@Override
	public int computer(int n, int m) {
		return n-m;
	}
}
//乘
public class Mul implements Compute{
	@Override
	public int computer(int n, int m) {
		return n*m;
	}
}
//除
public class Rem implements Compute{
	@Override
	public int computer(int n, int m) {
	//对0是除数的情况进行处理
		if(m==0){
			System.out.print("0不能做除数"+"请为被除数重新选择除数：");
			return n;
		} else {
			return n/m;
		}
	}
}

//3.定义一个计算器类，用于把计算结果打印出来
public class UseCompute {
	public void useCom(Compute com, int one, int two) {
		System.out.println(com.computer(one, two));
	}
}

//4.定义一个测试类，测试四种运算：
public class Test {
	public static void main(String[] args) {
		Compute add = new Add();
		Compute sub = new Sub();
		Compute mul = new Mul();
		Compute rem = new Rem();
		UseCompute uc = new UseCompute();
		uc.useCom(add, 3, 1);
		uc.useCom(sub, 3, 1);
		uc.useCom(mul, 3, 1);
		uc.useCom(rem, 3, 1);
	}
}

4. ==和equals()的区别

==是一个操作符，不能重写，而且大多被用在基础类型的比较上，因为基本数据类型不能使用equals()方法。

1. ==操作符的本意就是用来比较操作符两边的对象是否是同一个,也就是他们的引用地址一不一样。
2. equals是个方法，而且是Object的方法，在Java中，所有的类都是Object的子类，故所有对象都有equals()方法。如果没有重写equals()方法的话,那么默认的就是Object的方法,如下:

public boolean equals(Object obj) {
	return (this == obj);
}

显然，其实它的底层也就是==进行比较。但是==是操作符不能重写，equals是方法可以重写，所以就产生了区别。
==主要用于基本数据类型的比较，比较的是基本数据类型的值，在比较引用的时候则是比较引用的地址值。
equals则是主要用在引用对象的比较上，不重写的情况下和==一样，重写就看子类是否需要。

5. 基本数据类型的包装类分别是什么？

byte -- Byte
short -- Short
int -- Integer
long -- Long
float -- Float
double -- Double
char -- Character
boolean --Boolean

基本数据类型和包装类的相关问题：

1. 自动装箱：基本数据类型转换成对应的包装类的过程。
   自动拆箱：包装类转换成基本数据类型。
2. 为什么要有包装类？
   因为基本数据类型只是一些数字，不能调用属性和方法。
3. 包装类之间有没有类型的大小这种描述？
   类型转换时，int类型可以自动转换成long类型的数据，但是Integer类型和Long类型没有子父类关系。

6. 写出以下程序的输出结果：

Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
//比较引用地址
System.out.println(i1 == i2);//false 用了new就创建了不同的对象，地址值不同
//重写过，值比较value
System.out.println(i1.equals(i2));//true 比较两个对象的值

Integer i3 = new Integer(148);
Integer i4 = new Integer(148);
//比较引用地址
System.out.println(i3 == i4);//false
//重写过，值比较value
System.out.println(i3.equals(i4));//true

Integer i5 = 97;
Integer i6 = 97;
//Integer这个类中缓存了-128~127的地址
System.out.println(i5 == i6);//true
//重写了方法，还是比较值
System.out.println(i5.equals(i6));//true

Integer i7 = 148;
Integer i8 = 148;
//148超过缓存的数值的范围
System.out.println(i7 == i8);//false
System.out.println(i7.equals(i8));//true
//==：比较基本数据类型时，比较的是数值
int a = 148;
int b = 97;
Integer c = 97;
//一个Integer与int比较,先将Integer转换成int类型,再做值比较,所以返回的是true
System.out.println(i7==a);//true
System.out.println(b==c);//true

包装类的equals方法重写后，进行的是值的比较。
基本数据类型和包装类进行比较的时候，包装类会先转换成基本数据类型，再进行值的比较。这个自动拆箱的过程调用方法："包装类.xxxValue()"获取到包装类的数值，这个数值的对应的基本数据类型。而自动装箱时会通过"包装类.valueOf(基本数据类型变量)"的方式，把基本数据类型的数据转换成包装类。