今天做的一道题要创建类（类名为id）的数组，开始时只写了
 
id[] ID=new id[10];
结果运行时一直出错，后来想了想发现正确的格式应为
 
id[] ID=new id[10];
for(int i;i<10;i++) 
  
ID[i]=new id();
 

对象数组的概念：
 如果一个数组中的元素是对象类型，则称该数组为对象数组。
 当需要一个类的多个对象时，应该用该类的对象数组来表示，通过改变下标值就可以访问到不同的对象。
 对象数组的定义和使用：
 对象数组的定义与一般数组的定义类似，但是需要为每一个元素实例化。
 对象数组的声明形式是：
 类名 对象数组名 [ ];
 为对象数组分配内存空间：
 对象数组名=new 类名[数组长度]；//注意 ：此处不是构造方法了
 可以将对象数组的声明和创建用一条语句来完成。例如：定义一个学生类对象数组，可以用下面的语句定义：Student stu[ ]=new Student[30]; stu [ ]是对象数组名，它所表示的数组一共有30个元素，每一个元素都是Student类的对象名，还没有实例化，所以还必须为每一个元素实例化。比如如下的过程：
 for(int i=0;i<stu.length;i++)
 stu[i]=new Student()；
 实例化以后就可以使用每一个元素对象。
 设计一个雇员类，并创建雇员类的对象数组，输出每个雇员的信息
 
//设计一个雇员类，并创建雇员类的对象数组，输出每个雇员的信息
class Employee {   //雇员类
 private String id;  //编号
 private String name; //姓名
 private int age;     //年龄
 private String vocation; //职务
 public Employee(){} //构造方法一
 public Employee(String id,String name,int age,String vocation){
  set(id,name,age,vocation);
 }
 //设置属性的方法
 public void set(String id,String name,int age,String vocation){
  this.id=id;
  this.name=name;
  this.age=age;
  this.vocation=vocation;
 }
 public String toString() {
  String mess=id+","+name+","+age+","+vocation;
  return mess;
 }
}
public class Example4  {
 public static void main(String[] args) {
  Employee 雇员[]=new Employee[3];
  int i;
  for(i=0;i<雇员.length;i++)//为对象数组中每一个元素实例化
  雇员[i]=new Employee();//如果没有写构造方法一，而这样写，会出错
  //因为类中有有参的构造方法，系统就不会在默认给无参的构造方法了，
  //所以当类中写了有参的构造方法后，要用无参的构造方法时必须写出来
  
  //每一个对象元素分别初始化
  雇员[0].set("0001","张文军",50,"总经理");
  雇员[1].set("0002","李琦",45,"副经理");
  雇员[2].set("1016","张丽",28,"秘书");
  for (Employee employee:雇员)
   System.out.println(employee.toString());
 }
}
 

 普通型for循环和增强型for循环
 普通型
 
a={1,2,3,4,5};
for(int i=0;i<a.length;i++) {
 System.out.println9(a[1]);
}
 
增强型
 
for(int element:a) {
System.out.println(element);
}
 
两者结果相同，但是增强型更为简洁
 
对象数组还可以采用初始化的方法创建。创建形式是：
 类名 对象数组名[ ]={对象列表}；
 
设计一个雇员类，创建雇员类的对象数组并初始化，输出每个雇员的信息，仍然沿用上面的Employee类，程序如下
 
class Employee {   //雇员类
 private String id;  //编号
 private String name; //姓名
 private int age;     //年龄
 private String vocation; //职务
 public Employee(){} //构造方法一
 public Employee(String id,String name,int age,String vocation){
  set(id,name,age,vocation);
 }
 //设置属性的方法
 public void set(String id,String name,int age,String vocation){
  this.id=id;
  this.name=name;
  this.age=age;
  this.vocation=vocation;
 }
 public String toString() {
  String mess=id+","+name+","+age+","+vocation;
  return mess;
 }
}
public class Example11 {
 public static void main(String[] args) {
  //先创建3个雇员对象
  Employee employee1=new Employee("0001","张文军",50,"总经理");
  Employee employee2=new Employee("0005","李琦",45,"副经理");
  Employee employee3=new Employee("1016","张丽",28,"秘书");
  //声明对象数组并直接初始化
  Employee 雇员1[]={employee1,employee2,employee3};
  output(雇员1);//输出雇员信息
  System.out.println("------------------");//分割线
  //声明对象数组并直接初始化，初始化元素直接调用
  //构造方法创建对象
  Employee 雇员2[]={new Employee("0001","张文军",50,"总经理"),
  new Employee("0005","李琦",45,"副经理"),
  new Employee("1016","张丽",28,"秘书")};
  output(雇员2);
 }
 //定义方法用于输出雇员信息，注意方法是private,static
 private static void output(Employee 雇员[]){
  for(Employee employee:雇员)
   System.out.println(employee.toString());
 }
}
 

    在C或C++的原生数组里，有一点不好的就是数组越界是察觉不到，代码也不会提醒，至于越界产生的bug什么时候引发系统问题，我们也无从知晓。在这里我们可以创建一个数组类，内部包含数组长度、数组越界访问时能主动发现。
 
    数组类的创建我们还是按照顺序表的思路，创建一个Array类，实现基本的操作，再创建StaticArray与DynamicArray一个静态一个动态数组类，数组存储位置及大小，均在这两个子类完成，同时提供数组类对象间的赋值。
 
 
首先我们来看下父类Array，采用类模板方式，继承自MyObject类，并完成基本的数组操作
 
#ifndef __ARRAY_H__
#define __ARRAY_H__

#include "MyObject.h"
#include "MyException"

namespace MyLib
{
template <typename T>
class Array : public MyObject
{
protected:
    T* m_array;	//指针
public:
	
    virtual bool set(int index, const T& e)	//设置固定位置的值
    {
	bool ret = ( (0 <= index)&&(index <length()) );
	if (ret)
	{
	    m_array[index] = e;
	}
	else
	{
	    THROW_EXCEPTION(IndexOutOfBoundsException, "Index Out Of Bounds Array");
	}
	return ret;
    }

    virtual bool get(int index, T& e)	//获取固定位置的值
    {
    	bool ret = ( (0 <= index)&&(index < length()) );
	if (ret)
	{
	    e = m_array[index];
	}
	else
	{
	    THROW_EXCEPTION(IndexOutOfBoundsException, "Index Out Of Bounds Array");
	}
    }

    T& operator[](int index)	//重载[]操作符，使得类能想数组那样使用
    {
	bool ret = ( (0 <= index)&&(index < length()) );
	if (ret)
	{
	    return m_array[index];
	}
	else
	{
	    THROW_EXCEPTION(IndexOutOfBoundsException, "Index Out Of Bounds Array");
	}
    }

    T operator[](int index) const	//重载const类的[]
    {
	return const_cast<Array<T>&>(*this)[index];
    }

    virtual int length() = 0;	//提供一个获取数组长度的纯虚函数，在子类中实现
};

}
#endif	//__ARRAY_H__
 
StaticArray类，继承自父类，数组空间由在栈提供
 
#ifndef __STATIC_H__
#define __STATIC_H__

#include "Array.h"

namespace MyLib
{
template <typename T, int N>
class StaticArray : public Array<T>
{
private:
    T array[N];		//分配数组空间
    int m_length;	//数组长度

public:
    StaticArray()
    {
	m_array = array;
	m_length = N;
    }

    StaticArray(const StaticArray<T, N>& obj)	//重写拷贝构造函数
    {
	m_array = array;
	for (int i=0; i<obj.m_length; i++)
	{
	    m_array[i] = obj[i];
	}
	m_length = obj.m_length;
    }

    StaticArray<T, N>& operator= (const StaticArray<T, N>& obj)	//重写赋值构造函数
    {
	if (this != &obj)
	{
	    for (int i=0; i<m_length; i++)
	    {
		m_array[i] = obj[i];
	    }
	}
	return *this;
    }

    int length()	//将继承自父类Array的length()函数实现
    {
	return m_length;
    }
};
}
#endif	//__STATIC_H__
 
下边是DynamicArray子类，与StaticArray类似，只是数组的空间所在的位置是在堆空间上
 
#ifndef __DYNAMICARRAY_H__
#define __DYNAMICARRAY_H__

#include "Array.h"

namespace MyLib
{
template <typename T>
class DynamicArray : public Array<T>
{
private:
    int m_length;
public:
    DynamicArray(int length)
    {
	m_array = new T[length];	//构造函数中指定数组长度，并分配堆空间
	if (m_array)
	{
	    m_length = length;
	}
	else
	{
	THROW_EXCEPTION(NoEnoughtMemoryException, "No Enought Memory to Create DynamicArray...");
	}
    }

    DynamicArray(const DynamicArray<T>& obj)	//重写拷贝构造函数
    {
	T* array = new T[obj.m_length];
	if (array)
	{
	    m_array = array;
            m_length = obj.m_length;
	    for (int i=0; i<m_length; i++)
	    {
		m_array[i] = obj[i];
	    }
	}
	else
	{
	    THROW_EXCEPTION(NoEnoughtMemoryException, "No Enought Memory to Create DynamicArray...");
	}

    }

    DynamicArray<T>& operator=(const DynamicArray<T>& obj)	//重写赋值构造函数
    {
	if (this != &obj)
	{
	    for (int i=0; i<m_length; i++)
	    {
		m_array[i] = obj[i];
	    }
	}
	return *this;
    }

    void resize(int length)		//重定义数组大小
    {
	T* array = new T[length];

	if (array)
	{
            int len = m_length < length ? m_length : length;
	    for (int i=0; i<len; i++)
	    {
	    	array[i] = m_array[i];
	    }

	    T* temp = m_array;
	    m_array = array;
	    m_length = length;

	    delete[] temp;
	}
	else
	{
	    THROW_EXCEPTION(NoEnoughtMemoryException, "No Enought Memory to Create DynamicArray...");
	}
    }

    int length()	//实现继承自父类的length()函数
    {
	return m_length;
    }
};
}

#endif	//__DYNAMICARRAY_H__
 
上边就把Array、StaticArray、DynamicArray实现完了，这里我们将他们都实现在头文件中，也可以分开到源文件中，下边我们在main函数中调用一下
 
#include <iostream>

#include "StaticArray.h"
#include "DynamicArray.h"

using namespace std;
using namespace MyLib;

int main()
{
    cout << "StaticArray..........." << endl;
    StaticArray<int, 10> list1;

    for (int i=0; i<list1.length(); i++)
    {
    	list1[i] = i;	//设置数组元素
    }
    for (int i=0; i<list1.length(); i++)
    {
    	cout << list1[i] << " " ;
    }

    cout << endl << "DynamicArray.........." << endl;
    DynamicArray<int> list2(10);	
    for (int i=0; i<list2.length(); i++)
    {
    	list2[i] = i;	//设置数组元素
    }
    for (int i=0; i<list2.length(); i++)
    {
    	cout << list2[i] << " ";
    }
    cout << endl;

    system("pause");

    return 0;
}
 
编译执行
 
到这里我们的数组类就创建完成了，也可以按照需求增减功能。

JAVA“类”数组的创建与调用和C++相比是不同的。
 
先看这样一个类数组的创建
 
注：bookFeature 是一个类
 
错误1：
 
class bookList {
    private int bookNum=0;
    final int MAXSIZE=1001;
    public bookList(){
        bookNum=0;
        bookFeature[] List=new bookFeature[MAXSIZE];
        }
    }
 
这里在构造方法bookList()里定义了bookFeature[] List=new bookFeature[MAXSIZE];
 
这样是不行的，JAVA要求对每个变量都要初始化，必须在构造方法里加上这样一行代码：
 

1
2
for(int i=0;i<MAXSIZE;i++){
            List[i]=new bookFeature();
 
这样是否就行了呢？接下来看错误2
 
错误2：
 

1
2
3
4
5
6
7
8
9
10
11
class bookList {
    private int bookNum=0;
    final int MAXSIZE=1001;
    bookFeature[] List;
    public bookList(){
        bookNum=0;
        bookFeature[] List=new bookFeature[MAXSIZE];
        for(int i=0;i<MAXSIZE;i++){
            List[i]=new bookFeature();
        }
    }
 
这里先定义了 bookFeature[] List;再在构造方法，这样也是不行的，这里数组变量必须放在对象中。
 
两种错误都会报错 java.lang.NullPointerException 
  
 记住数组在JAVA中是对象！！！
 
下面给出正确的类数组的声明
 
1
2
3
4
5
6
7
8
9
10
11
import java.util.*;
class bookList {
    private int bookNum=0;
    final int MAXSIZE=1001;
    bookFeature[] List=new bookFeature[MAXSIZE];
    public bookList(){
        bookNum=0;
        for(int i=0;i<MAXSIZE;i++){
            List[i]=new bookFeature();
        }
    }