动手动脑3（02-类与对象）
10.11（02-类与对象）
1.早期经常这样定义变量 int value=100; 前面的示例中这样定义变量 MyClass obj = new MyClass();这两种方式定义的变量是一样的吗？
第一种仅仅定义了一个变量并为它赋了一个值。而第二种是定义了一个类的对象，通过这个对象可以调用该类中的所有内容。
2.请输入并运行以下代码，得到什么结果?
运行结果：
当“==”施加于原始数据类型变量时，是比较变量所保存的数据是否相等
当“==”施加于引用类型变量时，是比较这两个变量是否引用同一对象。
引用代表地址，所以“==”实际上相当于比较两个引用类型变量中保存的对象地址是否相同。
3.请总结一下，这个方法有哪些“与众不同之处”，你能列出几条？
所标出的方法，称为类的“构造方法”，有时也习惯称为“构造函数”
当创建一个对象时，它的构造方法会被自动调用。构造方法与类名相同，没有返回值。
如果类没有定义构造函数，Java编译器在编译时会自动给它提供一个没有参数的“默认构造方法”。
4.以下代码为何无法通过编译？哪儿出错了？
Foo类重构了构造函数，但是没有写无参的构造函数。所以在主函数中声明对象时，调用无参构造函数失败，报错。
5.
使用该定义的类，以下代码输出结果是什么？请依据代码的输出结果，自行总结Java字段初始化的规律。
运行结果：
1.执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”
2.执行类的构造函数。类的初始化块不接收任何的参数，而且只要一创建类的对象，它们就会被执行。因此，适合于封装那些“对象创建时必须执行的代码”。
6.请运行TestStaticInitializeBlock.java示例，观察输出结果，总结出“静态初始化块的执行顺序”。
TestStaticInitializeBlock.java
class Root
{
static
{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root()
{
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root
{
static
{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid()
{
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg)
{
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值：" + msg);
}
}
class Leaf extends Mid
{
static
{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf()
{
//通过super调用父类中有一个字符串参数的构造器
super("Java初始化顺序演示");
System.out.println("执行Leaf的构造器");
}
}
public class TestStaticInitializeBlock
{
public static void main(String[] args)
{
new Leaf();
}
}
运行结果：
静态初始化块的执行顺序：
静态初始化块总是最先执行，再执行public函数，最后执行函数。
1.静态初始化块只执行一次。
2.创建子类型的对象时，也会导致父类型的静态初始化块的执行。
7.静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?
public class JingTaiHanShu {
int x = 3;
static int y = 4;
public static void Method()//静态方法
{
System.out.println("实例变量x = " + new JingTaiHanShu().x);/ System.out.println("静态变量y = " + y); }
public static void main(String[] args)
{
JingTaiHanShu.Method();
JingTaiHanShu ex = new JingTaiHanShu();
System.out.println("x = " + ex.x);
}
}
运行结果：
在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象
8.Integer类的装箱和拆箱到底是怎样实现的？
public class BoxAndUnbox {
/**
* @param args
*/
public static void main(String[] args) {
int value=100;
Integer obj=value; //装箱
int result=obj*2; //拆箱
}
}
每个原始数据类型的包装类分别是每个数据类型标识符的完全体首字母大写形式，例如int包装类为Integer类，其中先要定义一个变量，然后【包装类】 标识符1 = 标识符2；然后拆箱 原始数据类型 标识符3 = 标识符2*2 ；然后反编译之后发现，装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 intValue方法实现的.
9.两对整数明明完全一样，为何一个输出true，一个输出false？
下面这段代码是Integer的valueOf方法的具体实现：
public static Integer valueOf(int i) {
if(i >= -128 && i <= IntegerCache.high)
return IntegerCache.cache[i + 128];
else
return new Integer(i);
}
而其中IntegerCache类的实现为：
private static class IntegerCache {
static final int high;
static final Integer cache[];
static {
final int low = -128;
// high value may be configured by property
int h = 127;
if (integerCacheHighPropValue != null) {
// Use Long.decode here to avoid invoking methods that
// require Integer‘s autoboxing cache to be initialized
int i = Long.decode(integerCacheHighPropValue).intValue();
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - -low);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
}
private IntegerCache() {}
}
从这2段代码可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。
上面的代码中i1和i2的数值为100，因此会直接从cache中取已经存在的对象，所以i1和i2指向的是同一个对象，而i3和i4则是分别指向不同的对象。
