JAVA——第四章——类与对象

接着上一篇博客的总结，我已经学习并总结到了JAVA的类构造器，接着学习并总结。

四 . 将消息传给方法或构造器

参数即是将数据传送给方法或构造器的媒介。形参是指方法声明中的变量列表，而实参是方法调用时实际传递的值。调用方法时，所使用的实参与声明中形参的类型和次序必须相匹配

（1）.形参类型
方法和构造器的形参可以是任意数据类型，包括double、float、interger等基本数据类型，以及对象和数组等引用类型。
这里给出一个方法，他接受数组作为实参。该方法创建新的 Polygon 对象并从 Point 对象数组初始化该对象，假设 Point 是表示 x、y 的类：

public Polygon polygonForm(Point[] corners){
    //method body goes here
}

（注意：Java 程序语言不支持向方法传递方法，但可以将对象传递给方法，然后调用对象的方法）

（2）.任意数目的实参
可变参数构造可用于向方法传递任意数目的值。不清楚某种类型实参的数量是，可以使用可变参数。
要使用可变参数，要在最后一个参数类型后添加省略号（…），然后添加空格和参数名。调用方法时，可以携带任意数量的该参数，包括零个。

（3）.形参名
声明方法或构造器的形参时，要给这些形参指定名称。在作用域内，形参名必须唯一。
形参可以与类的一个字段同名，这种情况下，形参会覆盖字段，会降低代码的可读性，但是我们可以用 this 关键字，在以后会总结到。

（4）.传递基本数据类型实参
基本数据类型的实参通过传值方式传入方法。这就意味着，对参数值的改变都只能发生在方法的作用域内。方法返回时，形参失效，对形参的改变也将丢失。例子：

public class PassPrimitiveByValue{
    public static void main(String[] args) {
        int x = 3;

        passMethod(x);

        System.out.println("After invoking passMethod,x = " + x);

    }

    public static void passMethod(int p){
        p = 10;     
    }
}

程序输出结果如下：

After invoking passMethod,x = 3

（5）.传递引用数据类型实参
引用数据类型（对象等）也可以通过传值方式传入方法。这就是说，当方法返回时，输出的引用仍会引用相同的对象。。但是，如果正确访问对象的字段，其值可以在方法内部改变。

4.2 对象
一个典型的 Java 程序会创建许多对象，这些对象通过调用方法进行交互。
这里给出一个小 Demo ，它创建三个对象：一个 Point 对象和两个 Rectangle 对象。

public class CreatObjectDemo{
    public static void main(String[] args) {
        //创建一个Point对象和两个Retangle对象
        Point originOne = new Point(23,94);
        Rectangle rectOne = new Rectangle(originOne,100,200);
        Rectangle rectTwo = new Rectangle(50,100);

        System.out.println("Width of rectOne: " 
                           + rectOne.width);
        System.out.println("Height of rectOne:"
                           + rectOne.height);
        System.out.println("Area of rectOne: "
                           + rectOne.getArea());

        rectTwo.origin = originOne;
        System.out.println("X Position of rectTwo: "
                           + rectTwo.origin.x);
        System.out.println("Y Position of rectTwo: "
                           + rectTwo.origin.y);
        System.out.println("Now rectTwo has been changed.");
        rectTwo.move(40,72);
        System.out.println("X Position of rectTwo: "
                           + rectTwo.origin.x);
        System.out.println("Y Position of rectTwo: "
                           + rectTwo.origin.y);
        System.out.println(new Rectangle(100,50).getArea());
    }
}

其运行结果如下：

Width of rectOne: 100
Height of rectOne:200
Area of rectOne: 20000
X Position of rectTwo: 23
Y Position of rectTwo: 94
Now rectTwo has been changed.
X Position of rectTwo: 40
Y Position of rectTwo: 72
5000

接下来详细总结关于对象的细节

---

（一）.创建对象
类为对象提供了一个实现框架；可以从类创建对象。下面的语句都是创建一个对象并将其赋值给变量：

Point originOne = new Point(23,94);
Rectangle rectOne = new Rectangle(originOne,100,200);
Rectangle rectTwo = new Rectangle(50,100);

1).声明引用对象的变量

type name;

该形式告诉编译器可以使用 name 引用 type 类型的数据。如果声明是猪类型变量，该声明就会为改变过俩保留适量的内存空间。引用变量也可以单独声明，其形式为：

Point originOne;

简单声明引用变量没有创建对象。若创建对象，则需使用 new 运算符。

2).实例化类
new 运算符实例化类是，会为新对象分配内存并返回该内存的引用。new 运算符也会调用对象的构造器。

new 运算符需要一个后置的实参以调用构造器。构造器的名称是待初始化的类名。
new 运算符返回所创建对象的引用，并将该引用赋值给相应类型的变量。

3).初始化对象
Point 类的代码：

class Point{
    public int x;
    public int y;

    //constructor
    public Point(){}
    public Point(int startX,int startY){
        this.x = startX;
        this.y = startY; 
    }
}

Rectangle 类的代码：

class Rectangle{
    public int width;
    public int height;
    public Point origin;

    //constructor
    public Rectangle(){
        origin = new Point(0,0);
    }
    public Rectangle(Point p){
        origin = p;
    }
    public Rectangle(int startwidth,int startheight){
        width = startwidth;
        height = startheight;
        origin = new Point(0,0);
    }
    public Rectangle(Point startPoint,int startwidth,int startheight){
        origin = startPoint;
        width = startwidth;
        height = startheight;
    }
    public int getArea(){
        return width * height;
    }
    public void move(int changeX,int changeY){
        origin.x = changeX;
        origin.y = changeY;
    }
}

如果类有多个构造器，那他们必须有不同的方法签名。编译器会根据实参的数目和类型来区分构造器。
所有类都至少有一个构造器。如果类没有显式构造器，Java 编译器会自动给提供一个无参构造器，这在前一篇的博文中构造器那一块提到过，无参构造器会调用父类的无参构造器，如果没有父类。会调用 Object 构造器，如果父类没有构造器，即使 Object 有构造器，编译器也会报错。

（二）.使用对象

1).引用对象的字段
对象的字段通过字段名来访问，且字段名是唯一的。类内部只需使用简单的字段名即可。例如：

System.out.println("Width and height are: " 
                           + width + "," + height);

而对象外的代码要访问字段的话么就需要使用对象的引用或 ” 表达式 + 点操作符 + 简单的字段名 ” 的形式 , 如：

System.out.println("Width of rectOne: " 
                           + rectOne.width);
System.out.println("Height of rectOne:"
                           + rectOne.height);

要访问字段，可以使用对象的引用，也可以使用返回对象类型的任意形式，例如：

System.out.println(new Rectangle(100,50).getArea());

上述例子中，创建新的 Rectangle 对象并且立即获得它的 getArea 方法的值。本质上来说，程序并没有保存该对象的引用，执行完该语句后，Java 虚拟机会释放占用资源并回收利用。

2).调用对象的方法
调用对象的引用可以调用对象的方法，只需在对象引用后添加方法的简单名、点操作符和圆括号，并在园括号内添加传给方法的实参列表。

int areaRectangle = new Rectangle(100，50).getArea();

调用对象的方法和向对象传递信息是一样的。上述代码中，调用 getArea() 的对象是构造器返回的 rectangle 。

3).垃圾收集器
Java 平台支持创建任意多对象，而且不需要销毁他们。当 Java 运行时环境确定不再使用某些对象是，就会删除他们。这个过程叫做垃圾收集。
对象没有引用，会被垃圾收集。变量超出作用域，通常删除变量中保存的引用。也可以将该变量的值设为 null ，显式删除其保存的对象引用。程序中同一对象有多个引用，垃圾收集该对象前，必须先删除这些引用。
Java 运行时环境有一个垃圾收集器，它会周期性释放那些没有引用的对象所占用的内存空间。垃圾收集器会在合适的时间自动完成该任务。