动手动脑以及课后作业

动手动脑

一.代码：

package show6;
public class Test {
    public static void main(String[] args)
    {
        Foo obj1=new Foo();
    }

}
class Foo{
    int value;
    public Foo(int initValue){
        value=initValue;
    }
}

程序无法运行，原因是类本身提供了一个自定义的构造方法，从而系统不再提供默认的构造方法。

二.代码：

package show6;

public class Lei {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        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进行初始化的地方有两个：初始化块和构造函数，其中初始化块又分为静态初始化块和实例初始化块。静态初始化块是类中由static修饰的初始化块，实例初始化块为类中没有任何关键字修饰的初始化语句。如果在主函数中创建对象时没有形参时，如果在类中定义了公共的变量并给与了赋值，那么就会把值赋给主函数中的变量，再调用类中的默认构造函数，如果在主函数中创建对象时有形参，则调用类中对应的构造函数。

三.代码:

package show7;

public class Jiecheng {
    public static void main(String args[])
    {
        Son s=new Son();
        s.print();
        
    }

}
//father
class Father{
    String name;
    int age;
    {
        name="liming";
        age=21;
        
    }
}
//son
class Son extends Father{
    String like="basketball";
    void print()
    {
        System.out.println("name:"+name+"/nage:"+age+"aihao:"+like);
    }
}

运行结果：

当多个类之间有继承关系时，创建子类对象会导致父类初始化块的执行。

四.代码：

package show8;
    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();
            

        }
    }

运行结果：

首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态内容。

五.代码：

package show9;

public class Test {
    protected String alpha;    
    public void dt()
    {        
        System.out.println("abcd");    
        }    
    public static void main(String[] args) 
    {            
        Test t = new Test();                   
        t.dt();    
        }


}

运行结果：

在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。如果静态方法中必须要调用非静态方法，可以先new(实例)，之后通过new实例化的引用调用此类的方法。

课后作业：

代码：

package show5;

public class Chaxun {
     private static int n;
        public  Chaxun()
        {
            n++; //每次new一个对象是n+1
        }
        public static int getNum()
        {
            return n; //返回n值
        }
        public static void main(String[] args){
             Chaxun s1=new  Chaxun();
             Chaxun s2=new  Chaxun();
             Chaxun s3=new  Chaxun(); 
             Chaxun s4=new  Chaxun();//创建对象
            System.out.println("共有对象个数为："+ Chaxun.getNum());
        }



}

运行结果：