1、使用类的静态字段和构造函数，我们可以跟踪某个类所创建对象的个数。请写一个类，在任何时候都可以向它查询“你已经创建了多少个对象？”。
设计思路：定义类的构造函数时使静态变量i进行i++,即每构造一次就叠加一个构造的对象数。
程序流程图：
源程序代码：
package tiaoshi;
import java.util.Scanner;
public class Tiaoshi
{
static int i=0;
public Tiaoshi()
{
i++;
}
public static int getTimes()
{
return i;
}
public static void main(String[] args)
{
int x=1;
Scanner con=new Scanner(System.in);
for(;x!=0;)
{
System.out.print("构建个数(0退出)：");
x=con.nextInt();
for(int t=0;t<x;t++)
{
Tiaoshi g=new Tiaoshi();
}
System.out.println("程序已经创建对象的个数为："+getTimes());
}
}
}
结果截图：
2、验证ClassAndObjectTest.java（使用自定义类）
public class ClassAndObjectTest
{
public static void main(String[] args)
{
//创建类的实例，定义一个对象变量引用这一实例
MyClass obj = new MyClass();
//通过对象变量调用类的公有方法
obj.myMethod("Hello");
//给属性赋值
obj.setValue(100);
//输出属性的当前值
System.out.println(obj.getValue());
//直接访问对象公有字段
obj.Information = "Information";
//输出对象公有字段的当前值
System.out.println(obj.Information);
}
}
class MyClass {
public String Information = "";
public void myMethod(String argu) {
System.out.println(argu);
}
private int value;
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
验证结果：
3、早期我们经常这样定义变量“int value=100;”,而前面的示例中这样定义变量“MyClass obj=new MyClass();”,这两种方式定义的变量是一样的吗？
这两种变量是不一样的。
前者是原始数据类型，例如int，float之类的变量，当声明一个原始数据类型的变量时,实际上并没有创建一个对象，此变量=null。
后者是引用类型变量，“引用”一个对象的变量称为“引用类型”的变量，定义一个原始类型的变量时,会马上给其分配内存，而对象变量的初始化中，该变量若不引用一个真实的对象，则必须声明为null。而且引用对象后的对象变量，且如果不再使用此变量，将会回收类定义的对象所占用的内存。
4、对于原始数据类型的变量（比如int)，可以直接使用“==”判断两变量值是否相等，那么对象变量也可以使用“==”判断两变量值是否相等吗？
不可以，类似于字符串的比较大小，使用equals()进行比较，用法与其相同。当“==”施加于“原始数据类型”变量时，是比较变量所保存的数据是否相等，当“==”施加于“引用类型”变量时，是比较这两个变量是否引用同一对象。引用代表地址，所以“==”实际上相当于比较两个引用类型变量中保存的对象地址是否相同。
5、请输入并运行以下代码，得到什么结果?
public class Test
{
public static void main(String[] args)
{
Foo obj1 = new Foo();
Foo obj2 = new Foo();
System.out.println(obj1==obj2);
}
}
class Foo
{
int value=100;
}
结果截图：
6、如何比较两个对象的“内容”是否一样？
“内容相等”，其实是就“对应字段值”一致。在JAVA中要比对两个对象的字段值，可以 重写基类的equals()方法；Object是Java的最顶层基类，其中定义了equals( )方法。
重写基类的equals()方法：
public class ObjectEquals
{
public static void main(String[] args)
{
MyTestClass obj1=new MyTestClass(100);
MyTestClass obj2=new MyTestClass(100);
System.out.println(obj1==obj2);
System.out.println(obj1.equals(obj2));
}
}
class MyTestClass
{
public int Value;
public boolean equals(Object obj)
{
return ((MyTestClass)obj).Value==this.Value;
}
public MyTestClass(int initValue)
{
Value=initValue;
}
}
结果截图：
7、以下代码为何无法通过编译？哪儿出错了？
public class Test
{
public static void main(String[] args)
{
Foo obj1 = new Foo();
}
}
class Foo{
int value;
public Foo(int initValue){
value=initValue;
}
}
结论：如果类提供了一个自定义的构造方法，就将导致系统不再提供默认构造方法。所以，“Foo obj1 = new Foo();”中需要添加默认的参数。
8、如果一个类中既有初始化块，又有构造方法，同时还设定了字段的初始值，谁说了算？
在“public int field = 100;”在“{field=200;}”之前时，是“{field=200;}”说了算；在之后时，是“public int field = 100;”说了算。也就是谁比较靠后就是谁初始化起作用。执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”。
构造函数，类的初始化块不接收任何的参数，只要一创建类的对象，它们就会被执行。因此，适合于封装那些“对象创建时必须执行的代码”。
运行结果：
①“public int field = 100;”在“{field=200;}”之前：
②“public int field = 100;”在“{field=200;}”之后：
9、请运行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();
System.out.println("Mid的带参数构造器，其参数值：" + msg);
}
}
class Leaf extends Mid
{
static{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf()
{
super("Java初始化顺序演示");
System.out.println("执行Leaf的构造器");
}
}
public class TestStaticInitializeBlock
{
public static void main(String[] args)
{
new Leaf();
}
}
结果截图：
10、静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?
public class text4
{
public static void main(String[] args)
{
System.out.println("(静态变量)total_employees = "+Employee.clear());
Employee e = new Employee();
System.out.print("(实例变量)name = "+e.name);
}
}
class Employee
{
String name = "2";
static int total_employees = 0;
static int clear(){
return total_employees;
}
static void clear2(){
}
}
结果截图：
原文：http://www.cnblogs.com/guobin-/p/7687607.html