对象数组的概念：
 如果一个数组中的元素是对象类型，则称该数组为对象数组。
 当需要一个类的多个对象时，应该用该类的对象数组来表示，通过改变下标值就可以访问到不同的对象。
 对象数组的定义和使用：
 对象数组的定义与一般数组的定义类似，但是需要为每一个元素实例化。
 对象数组的声明形式是：
 类名 对象数组名 [ ];
 为对象数组分配内存空间：
 对象数组名=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());
 }
}
 

数组属于引用数据类型，在使用前必须初始化，否则会报NullPointerException（空指针异常：运行时异常）
  一维数组初始化：
 动态初始化：（声明并开辟数组）
  数据类型[ ] 数组名称=new 数据类型[长度]

 int[ ] data=new int [5] :声明并开辟一个长度为5的数组
 
数组通过下标索引来获取元素，下标默认从0开始。数组下标超出数组长度，数组越界异常（运行时异常）
 
数组中每个元素都有默认值，默认值是该数据类型默认值
 
数组长度：数组名称.length
 
数组遍历推荐使用JDK1.5 提供for-each循环（仅限于数组内容读取），要修改数组内容，还是使用常规for循环
 
    for(int x : data)
 
{
 System.out.println(x+" ");
 }
 引用传递：多个栈内存指向同一块堆内存
 
int[ ] tmp=data; //引用传递 注意是地址的传递
 tmp[3]=10; ----> x[3]=10;
 
数组静态初始化
 简化格式：
 数据类型[ ] 数组名称 ={值，值…}
 完整格式: （推荐使用）
 数据类型[ ] 数组名称 =new 数据类型[ ]{值，值…}
 int[ ] data =new int[ ] {1,2,3} ;
 
长度 ：数组名称.length ,静态初始化长度固定，根据值的个数确定长度，并且长度不可修改
 
匿名数组：没有任何栈内存指向，在使用一次后会变成垃圾，只会使用一次
 
二维数组
动态初始化:数据类型[ ][ ] 数据名称 =new 数据类型[ 行个数] [列个数]

 int[ ] [ ]data =new int [3][4];开辟行数为3，列数为4的整型数组
 
静态初始化：
 数据类型[ ][ ] 数组名称 =new 数据类型[ ][ ]{ {第一行的值},{第二行的值}…}
 
int[ ][ ] data={{1,2，3}，{4,5,6}，{7}}；
 
x<data.length
 
y<data[x].length
 
对象数组初始化：
 
首先看对象数组动态初始化：
 
对象数组动态初始化
public class ArrayDemo
{
    public static void main(String[] args)
    {
        String[] str=new String[3];  //数组动态初始化，每个元素都是其对应数据类型的默认值
        for(String num :str)
        {
            System.out.print(num+"、"); //null、null、null、
        }
        str[0]=new String("pick");
        str[1]=new String("happy");
        str[2]=new String("day");
       for(String num :str)
       {
           System.out.print(num+"、"); //pick、happy、day、
       }
    }
}
 
对象数组静态初始化：
 
public class ArrayDemo
{
    public static void main(String[] args)
    {
        String[] str=new String[]{"pick","happy","day"};  //数组静态初始化，pick、happy、day、
       for(String num :str)
       {
           System.out.print(num+"、"); //pick、happy、day、
       }
    }
}

      Java是纯面向对象语言。类是其重要构成单位。然后，在实际编程中，我们会自定义一些类，如Point
 
 
<span style="font-size:14px;">public class Point {
	
	public Point(){
		Lat=0.0;
		Lng=0.0;
	}
	
	public double GetLat(){
		return Lat;
	}
	public double GetLng(){
		return Lng;
	}
	
	public void SetLat(double pLat){
		Lat=pLat;
	}
	public void SetLng(double pLng){
		Lng=pLng;
	}
	private double Lat;
	private double Lng;

}</span>
       
诸如，这样的实体类，我们经常会要用到其对象数组。但是，Java当中对象数组的声明与初始化不同于其固定类型的声明和初始化。下面请看。 
 
 
<span style="font-size:14px;">//Init class Point
		points=new Point[totalPoints];//statement of points Array
		//Initing 
		for(int i=0;i<totalPoints;i++){
			points[i]=new Point();
		}</span>

 

 
 

 

 
数组是大多数编程语言提供的一种复合结构，如果程序需要多个类型相同的变量时，就可以考虑定义一个数组。Java语言的数组变量是引用类型的变量，因此具有Java独有的特性。
 
在正常的Java开发中，使用Java数组之前，我们都会对数组进行初始化，为数组中的元素分配内存空间、赋值等，但Java数组一定要初始化吗？不初始化可以 么？
 
其实，java的数组变量是引用类型的变量，并不是数组对象本身，只要让数组变量指向有效的数组对象，程序中就可使用该数组变量，比如下面这个例子：public class T {
 
/**
 
* @param args
 
*/
 
public static void main(String[] args) {
 
// TODO Auto-generated method stub
 
//定义并初始化nums数组
 
int nums[] = new int[]{3,13,4,6};
 
//定义一个prices数组变量
 
int prices[];
 
//让prices数组指向nums所引用的数组
 
prices = nums;
 
for(int i=0;i<>
 
System.out.println(prices[i]);
 
}
 
//将prices数组的第三个元素赋值为100
 
prices[2] = 100;
 
//访问nums数组的第三个元素 将看到数组100
 
System.out.println(nums[2]);
 
}
 
}
 
从上面代码可以看出，定义了prices数组之后，并未对prices数组进行初始化。 当执行int prices[]之后，
 
程序的内存分配如图
 

 
从图可以看出，此时的prices数组还未指向任何有效的内存，未指向任何数组对象，此时的程序还不可使用prices数组变量。
 
当程序执行prices = nums之后，prices变量将指向nums变量所引用的数组，此时prices变量和nums变量引用同一个数组对象。
 
执行这条语句之后，prices变量已经指向有效的内存及一个长度为4的数组对象，因此程序完全可以正常使用prices变量了。
 
对于数组变量来说，它并不需要进行所谓的初始化，只要让数组变量指向一个有效的数组对象，程序即可正常使用该数组变量。
 
所以，Java语言中的数组，不一定要初始化也可正常使用。Java初学者可以尝试用上面这里例子的方法，实际操作一下，加深印象。最后，希望小编的分享对大家有帮助。
 
学习Java的同学注意了！！！
 
学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：454297367【长按复制】 我们一起学Java！