《Java实验四》

//实验4--附录一代码
public class PassValueTest
{
    //静态代码块，类一加载就执行的部分。
    //所以运行这个程序会输出 class loding
    static {
        System.out.println("class loding");
    }
    public static void main(String[] args){

    }
}

//实验4--附录二代码

/*
所有解释体现在代码中的注释中。
*/
public class PassValueTest
{
    private int i = -100;    //定义一个私有的成员变量i，初值是-100.

    //定义一个test1方法，参数类型是整形，功能是给局部变量b赋值为100.
    public void test1(int b)
    {
        b = 100;
    }

    //定义一个test2方法，参数是类PassValueTest类型的引用变量，功能是修改私有
    //变量i的值为100.
    public void test2(PassValueTest b)
    {
        b.i = 100;
    }

    //定义一个test3方法，参数是类PassValueTest类型的引用变量，功能是把本对象的私有
    //成员变量赋值给局部类类型的变量b。
    public void test3(PassValueTest b)
    {
        b = this;
    }

    //定义主函数。
    public static void main(String[] args)
    {
        //创建一个类PassValueTest的对象。
        PassValueTest obj = new PassValueTest();

        //定义一个整形变量temp，赋值为100.
        int temp = 100;

        //调用成员方法test1,并对方法中的局部整形变量赋值为100.
        obj.test1(temp);
        System.out.println(temp);

        //调用成员方法test2,并修改其成员变量i的值为100.
        obj.test2(obj);
        System.out.println(obj.i);

        //修改私有成员变量i的值为100.
        obj.i = 100;//这句代码对吗？哦哦，对，因为是在一个类中访问的。

        //创建一个类PassValueTest的对象。
        PassValueTest newobj = new PassValueTest();
        //调用成员方法test3,并把当前对象的私有成员变量i的值(为-100)赋给局部类类型
        //的变量b
        newobj.test3(newobj);
        System.out.println(newobj.i);
    }
}

////实验4--附录三代码
/*
问题如下：
编译如下代码，分析结果；将“注释这行”所在的行注释，再将
注释的call2方法和main方法中的“StaticTest.call2(obj);”方
去掉注释，再次编译，观察结果分析其原因。

回答如下：
（1）在没有去掉注释之前进行编译，会发生如下错误：
========================================================================
StaticTest.java:13: 错误: 无法从静态上下文中引用非静态 方法 nonstaticmethod()
                nonstaticmethod();//注释这行.
                ^
1 个错误
===========================================================================
这个错误说明：在用类名直接调用静态方法时可以的，但在此例中(没有去掉代码中的注释)，
直接用类名调用了call1方法（StaticTest.call1();）但是在call1方法中有调用到了静态的
staticmethod()方法，这是没错的，但是在call1方法中又调用了非静态的nonstaticmethod
方法。此时编译器出现报错提示如上。
    从而也就是说：静态的方法可以有类名直接调用，非静态的方法不能有类名调用。

（2）按照题目要求的做法后，在编译不会出现问题；
    运行结果是：
    静态方法被调用
    非静态方法被调用
    非静态方法被调用

    分析运行结果如下：
    首先在主函数中创建了一个StaticTest类的对象obj,然互直接由类名调用静态方法
call1,在call1方法中又调用到了静态的staticmethod方法，然后输出(1)“静态方法被调用”。
接着用类名直接调用了静态的方法call2,并把对象obj传递给静态方法的形式参数o1.在
静态的call2方法中，传递过来的对象调用了非静态的方法nonstaticmethod,此时便打印输出
了(2)“非静态方法被调用”，紧接着又在静态的call2方法中创建了一个本类对象o2,然后用o2对象
也调用了非静态的方法nonstaticmethod.便输出了(3)“非静态方法被调用”

    从以上分析（和自己在代码中的测试）来看：可以总结的是，静态方法可以由类名直接调用，
也可以由对象调用，而非静态的方法只能由对象调用

*/

public class StaticTest
{
    public static void call1()
    {
        staticmethod();
        //nonstaticmethod();//注释这行.
    }

    public static void call2(StaticTest o1)
    {
        o1.nonstaticmethod();
        /*
        *o1.staticmethod();
        *这一句是测试用的，是用于测试静态的方法也能由对象直接调用
        *如果加上这一句，编译运行都没有错，运行的结果是：
        *    静态方法被调用
        *    非静态方法被调用
        *    静态方法被调用
        *    非静态方法被调用
        *则说明了静态的方法也能被对象直接调用。
        */
        StaticTest o2 = new StaticTest();
        o2.nonstaticmethod();
    }

    public void nonstaticmethod()
    {
        System.out.println("非静态方法被调用");
    }

    public static void staticmethod()
    {
        System.out.println("静态方法被调用");
    }

    public static void main(String[] args)
    {
        StaticTest obj = new StaticTest();
        StaticTest.call1();
        StaticTest.call2(obj);
    }
}

//实验四---第三题：
class Circle
{
    private final double PI = 3.14;
    private double radius;
    private double area;
    private double length;

    Circle(){}
    //构造函数
    Circle(double radius)
    {
        this.radius = radius;
    }
    //设置圆半径
    public void setRadius(double radius)
    {
        this.radius = radius;
    }
    //获取圆半径
    public double getRadius()
    {
        return radius;
    }

    //求圆的面积
    public double getArea()
    {
        area = PI*radius*radius;
        return area;
    }

    //求圆的周长
    public double getLength()
    {
        length = 2*PI*radius;
        return length;
    }

    public void print()
    {
        System.out.println("圆的半径="+getRadius()+"圆的面积="+getArea()+"圆的周长="+getLength());
    }

    public static void main(String[] args)
    {
        Circle c1 = new Circle();
        c1.setRadius(1);
        //c1.getArea();
        //c1.getLength();
        c1.print();

        Circle c2 = new Circle(100);
        c2.print();
    }
}

//实验四---第四题：
public class MyDate
{
    //成员变量：
    private int year;
    private int month;
    private int day;
    private boolean leap;

    //构造函数
    MyDate(){}

    MyDate(int year,int month,int day)
    {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    private void setYear(int year)
    {
        this.year = year;
    }
    private  int getYear()
    {
        return year;
    }

    private void setMonth(int month)
    {
        this.month = month;
    }
    private int getMonth()
    {
        return month;
    }

    private void setDay(int day)
    {
        this.day = day;
    }
    private int getDay()
    {
        return day;
    }

    //判断是否是闰年。
    public  boolean isRunyear(int year)
    {
        if(year%4==0){
            if(year%100==0){
                if(year%400==0)
                    leap = true;
                    else
                        leap = false;
                }
                else
                    leap = true;
            }
            else
                leap = false;
        return leap;
    }

    //计算输入的xx年xx月xx日是本年的第几天。
    public int f()
    {
        int sum=0;
        switch(month)
        {
            case 1:sum=0;break;
            case 2:sum=31;break;
            case 3:sum=59;break;
            case 4:sum=90;break;
            case 5:sum=120;break;
            case 6:sum=151;break;
            case 7:sum=181;break;
            case 8:sum=212;break;
            case 9:sum=243;break;
            case 10:sum=273;break;
            case 11:sum=304;break;
            case 12:sum=334;break;
            default:System.out.println("data error!");break;
        }
        sum+=day;
        boolean l = isRunyear(year);
        if(l && month>2)
            sum++;
        return sum;
    }
    //打印相关信息。
    public void print(boolean l)
    {
        if(l)
            System.out.print(year+"是闰年   ");
        else
            System.out.print(year+"不是闰年   ");
        System.out.println(year+"/"+month+"/"+day+"是这一年的第"+f());
    }

    public static void main(String[] args)
    {
        MyDate d1 = new MyDate();
        d1.setYear(2012);
        d1.setMonth(10);
        d1.setDay(1);
        int x = d1.getYear();
        boolean y = d1.isRunyear(x);
        d1.print(y);

        System.out.println("=======================================");
        MyDate d2 = new MyDate(2009,4,1);
        int n = d2.getYear();
        boolean m = d2.isRunyear(n);
        d2.f();
        d2.print(m);
    }
}