Java课堂练习4
使用类的静态字段和构造函数，我们可以跟踪某个类所创建对象的个数。请写一个类，在任何时候都可以向它查询“你已经创建了多少个对象？”。
package jxl;
class sum{
public static int a=0;
int c1;
public sum(int c2){
c1=c2;
a++;
}
public int get(){
return a;
}
}
public class Test4 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
//调用
sum one=new sum(2);
sum two=new sum(3);
//输出
System.out.println(one.get());
}
}
请输入并运行以下代码，得到什么结果?
package meiju;
public class cesh {
public static void main(String[] args) {
// TODO Auto-generated method stub
Foo obj1=new Foo();
Foo obj2=new Foo();
System.out.println(obj1=obj2);
}
}
class Foo
{
int value = 100;
}
结果：
以下代码为何无法通过编译？哪儿出错了？
如果类提供了一个自定义的构造方法，将导致系统不再提供默认构造方法。
以下代码输出结果是什么？
package meiju;
public class cesh {
public static void main(String[] args) {
// TODO Auto-generated method stub
InitializeBlockClass obj=new InitializeBlockClass();
System.out.println(obj.field);
obj=new InitializeBlockClass(300);
System.out.println(obj.field);
}
}
class InitializeBlockClass{
{
field=200;
}
public int field = 100;
public InitializeBlockClass(int value)
{this.field=value;}
public InitializeBlockClass()
{
}
}
Java字段初始化的规律:
（1）执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”。
（2）执行类的构造函数。
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();
}
}
静态初始化块的执行顺序:
对象静态初始化块的执行顺序的初始化顺序:首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。
静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?
public class Employee {
static int n = 200; //静态变量
public static void main(String[] args) {
New e = new New();
n = e.Shi(); //将实例变量赋值给静态变量
New.Jing(n); //
}
}
class New{
int m = 100; //实例变量
int Shi(){
int x;
x = m;
return x;//实例函数，返回一个实例值
}
static void Jing(int x){
System.out.println(x); //输出静态变量
}
}
