实验目的：

理解Java对象的面向对象的特征以及在编程中的应用。

实验内容：

1、验证对象作为参数传递是引用传递，而普通数据类型为值传递。

class Test
{
    int number;
    public void Info()
    {
        System.out.println("number="+number);
    }
    public void twice(int b,int c)
    {
        b=b*2;
        c=c*2;
        System.out.println("b="+b);
        System.out.println("c="+c);
    }
}
public class ParaExample
{
    private int num;
    public static void Change(Test a, int num)
    {
        a.number=num;
        a.Info();
    }
    public static void main(String[] args)
    {
        int num=8;
        int b=3,c=5;
        Test a=new Test();
        a.twice(3,5);               //调用a对象的twice方法，
        System.out.println("b="+b); //在屏幕上输出结果，
        System.out.println("c="+c); //验证普通数据类型为值传递
                       
        Change(a,num);              //调用Change静态方法，验证对象作为
        System.out.println("number="+a.number);//参数传递是引用传递
    }
}


2、验证构造方法和静态属性与方法专属于类，而其他属性和方法虽然在类中定义，但是为对象而定义。

public class ClassMethodExample
{
    //定义普通属性
    public int num1;
    //定义静态属性
    static String name="name一个静态属性";
    //定义静态方法
    public static void Method()
    {
        System.out.println("静态方法被调用");
    }
    //定义构造函数
    ClassMethodExample()
    {
        System.out.println("构造方法被调用");
    }
    public static void main(String[] args)
    {
        //验证静态属性和方法专属于类。可以用类名直接调用
        System.out.println(ClassMethodExample.name);
        ClassMethodExample.Method();
        //验证构造函数属于类
        ClassMethodExample a=new ClassMethodExample();
        //a.ClassMethodExample(); //不能用对象来调用
        //验证其它属性和方法为对象而定义
        System.out.println("num1="+a.num1);
        //System.out.println("num1="+num1);
    }
}


3、验证子类对象实例化时，通过继承，不仅将public、protected、缺省的属性和方法拷贝到对象当中，也将父类的私有属性拷贝到对象当中。

class Base
{
    //定义各种属性
    int def_field=1;
    public int pub_field=2;
    private int pri_field=3;
    protected int pro_field=4;
    //定义各种方法
    void GetDefField()
    {
        System.out.println("GetDefField: def_field="+def_field);
    }
    public void GetPriField()
    {
        System.out.println("GetPriField: pri_field="+pri_field);
    }
    protected void GetProField()
    {
        System.out.println("GetProField: pri_field="+pro_field);
    }
    private void GetPubField()
    {
        System.out.println("GetPubField: pub_field="+pub_field);
    }
}
public class ExtendExample extends Base
{
    public void GetField()
    {
        //私有属性只能通过public方法间接访问
        GetPriField();
    }
    public static void main(String[] args)
    {
        ExtendExample pe=new ExtendExample();
        //验证各种属性和方法拷贝到对象中
        pe.GetDefField();
        pe.GetProField();
        //pe.GetPubField();//权限不够
        pe.GetPriField();
        //验证父类的私有属性拷贝到对象当中。
        pe.GetField();
                 
    }
}


4、编写程序，体会类在重载情况下的相互调用，体会构造方法重载的调用方式。

public class OverloadExample
{
    public int a,b;
    //构造方法重载
    OverloadExample(int _a)
    {      
        a=_a;
    }
    OverloadExample(int _a,int _b)
    {
        this(_a);
        b=_b;
    }
    //类中普通方法的重载调用
    public void SetVar(int x,int y)
    {
        SetVar(x);
        b=x+b;
    }
    public void SetVar(int x)
    {
        a=x+a;
    }
    //主函数验证
    public static void main(String[] args)
    {
        OverloadExample p1=new OverloadExample(2,3);
        OverloadExample p2=new OverloadExample(4);
               
        p1.SetVar(8,9);
        p2.SetVar(5,6);
        //输出结果
        System.out.println(p1.a);
        System.out.println(p1.b);
        System.out.println(p2.a);
        System.out.println(p2.b);
    }
}


5、编程体现this的三种用法，super的两种用法，指出this.属性在什么情况下不可以省略，指出super.成员方法在什么情况下不能省略，指出this指代对象的作用。

class Base1
{  
    int num1,num2;
    Base1(int _num1,int _num2)
    {
        //this的用法二：this(参数)
        this(_num1);
        num2=_num2;
    }
    Base1(int _num1)
    {
        num1=_num1;
    }
}
class DDD
{
    ThisAndSuperExample p;
    public void Message(ThisAndSuperExample _p)
    {
        if(_p!=null)
            p=_p;
        p.GetValue();
    }
}
public class ThisAndSuperExample extends Base1
{
    int num2;
    DDD d;
    ThisAndSuperExample(int _num1,int _num2)
    {
        //super的用法二：super(参数)
        super(_num1,_num2);
        num2=_num2*2;
    }
    public void Communicate()
    {
        d=new DDD();
        //this的用法三：指代当前对象
        d.Message(this);
    }
    public void GetValue()
    {   int num2=10;
        //this的用法一：this.域变量/this.成员方法
        System.out.println("this.num2="+this.num2);
        //super的用法一：super域变量/super.成员方法
        System.out.println("super.num2="+super.num2);
    }
    public static void main(String[] args)
    {
        ThisAndSuperExample t=new ThisAndSuperExample(1,2);
        t.GetValue();
        t.Communicate();
    }
}


6、设计Src和Dis两个类, Src中有一个被封装的属性，类型为int（要求为非负值），每当我们通过特定方法更改Src对象中的这个属性后，Dis对象都能得到通知，并向Src发消息获得此属性值

class Src
{
    private int field;
    Dis dis;
    public int  field)
    {
        //保证非负性
        if(field>=0)
            this.field=field;
        else
            this.field=0;
    }
    public void SetDis(Dis _dis)
    {
        //建立两个类之间的联系
        if(_dis!=null)
        {dis=_dis;}
    }
    public void SetField(int num)
    {
        if(num>=0)//保证非负性
        {
            field=num;
            //给Dis类发送通知
            dis.Message();
        }
    }
    public int GetField()
    {
        return field;
    }
}
public class Dis
{
    Src src;
    public Dis(Src _src)
    {
        //建立两个类之间的联系
        src=_src;
        _src.SetDis(this);
    }
    public void Message()
    {
        int temp;
        System.out.println("src的field被更改");
        //向Src发消息获得此属性值
        temp=src.GetField();
        System.out.println("被改变后的值是:"+temp);
    }
    public static void main(String[] args)
    {
        Src s=new Src(9);//创建Src对象，初始值9
        Dis d=new Dis(s);
        //模拟Src类的属性被改变
        for(int i=0;i<10;i++)
        {
            s.SetField(i);
        }
    }
}