//实验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);
}
}