java入门 学习日志五（面向对象3）

数组

在java中，数组属于引用数据类型，所以在数组操作过程中，一定会牵扯到内存的分配问题。

1 声明并开辟数组
数据类型 数组名称 [] = new 数据类型 [长度] ;
数据类型 [] 数组名称 = new 数据类型 [长度] ;
2 分步完成
声明数组 : 数据类型 数组类型 [] = null ;
开辟数组 : 数组名称 = new 数据类型 [长度] ;

java为了方便数组的使用 ，提供了"数组名称 . length"的属性 ,可以取得数组的长度 。

public class TestDemo1
{
	public static void main(String args[]){
		int data [] =new int [3] ;  // 动态定义数组
		data[0]=0;
		data[1]=1;
		data[2]=2;
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+"\t");
		}
		System.out.print("\n");
			int data1[] =null ; //分步动态初始化数组
			data1=new int [3];
			data1[0]=1;
			for(int j=0;j<data1.length;j++){
				System.out.print(data1[j]+"\t");
			}
			System.out.print("\n");
			int data2[]=new int []{9,8,7};
			for(int k=0;k<data2.length;k++){
				System.out.print(data2[k]+"\t");
			}
	}
}

程序执行结果 ：0       1       2
			  1       0       0
			  9       8       7

上述代码分别用不同的方式定义了三个数组 。真麻烦。。。

数组的引用

public class TestDemo1
{
	public static void main(String args[]){
		int data [] =new int [3] ;  // 动态定义数组
		data[0]=0;
		data[1]=1;
		data[2]=2;
		int data1[]=data ;
		data1[0]=2;
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+"\t");
		}
	}
}

程序执行结果 ：2       1       2

还是可以把数组名理解为栈内存 ，他指向一块堆内存 。一块堆内存可以同时被多个栈内存指向 。

二维数组

动态初始化:数组类型 数组名称 [][] =new 数据类型 [行的个数][列的个数];
静态初始化:数组类型 数组名称 [][]= new 数组类型 [][]{{值，值},{值，值}}。

public class TestDemo1
{
	public static void main(String args[]){
		int data[][]=new int[][]{{1,2,3},{9,8,7}};
		for(int i=0;i<data.length;i++){
			for(int j=0;j<data[i].length;j++){
				System.out.print(data[i][j]+" ");
			}
			System.out.println();
		}
	}
}
程序执行结果 ：1 2 3
			  9 8 7

数组做方法参数传递

public class TestDemo1
{
	public static void main(String args[]){
		int data[]= new int []{1,2,3};
		ok(data);
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+" ");
		}
	}
	public static void ok(int temp[]){
		for(int i=0;i<temp.length;i++){
			temp[i]*=2;
		}
	}
}
程序执行结果 ：2 4 6

方法返回数组

public class TestDemo1
{
	public static void main(String args[]){
		int data[]=ok();
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+" ");
		}
		System.out.print("数组长度："+ok().length);
	}
	public static int [] ok(){
		return new int []{8,5,7};
		}
}
程序执行结果 ：8 5 7 数组长度：3

上述代码 ，使用ok（）方法返回一个数组 ，只需要将方法的返回值改为数组即可 ，返回的可以理解为一个堆内存，让栈内存指向他 。我们也可以直接调用length属性取得长度。

数组操作方法

1：数组复制

System.arraycopy(原数组名称 ，原数组开始下标 ，目标数组名称，目标数组开始下标，长度);

public class TestDemo1
{
	public static void main(String args[]){
		int data[]=new int []{1,2,3,4,5,6};
		int data1[]=new int []{9,8,7,6,5,4,3,2,1};
		System.arraycopy(data,1,data1,0,5);
		for(int i=0;i<data1.length;i++){
			System.out.print(data1[i]+" ");
		}
	}
}
程序执行结果 ：2 3 4 5 6 4 3 2 1

2：数组排序

java.util.Arrays.sort(数组名称);

需要注意的是，上面的代码只能从小到大排序 。
java .util是java的系统包，Arrays是系统提供的一个类 。

public class TestDemo1
{
	public static void main(String args[]){
		int data1[]=new int []{9,8,7,6,5,4,3,2,1};
		java.util.Arrays.sort(data1);
		for(int i=0;i<data1.length;i++){
			System.out.print(data1[i]+" ");
		}
	}
}
程序执行结果 ：1 2 3 4 5 6 7 8 9

对象数组

数组是引用类型，类也是引用类型 ，对象数组表示一个引用类型里嵌套其他的引用类型。

格式：对象数组的动态初始化
类名称 对象数组的名称=new 类名称 [长度] ;

格式：对象数组的静态初始化
类名称 对象数组名称=new 类名称 []{实例化对象，实例化对象...} ;

class Book     //定义一个Book类
{
	private String title;    //图书名称 private封装属性 
	private double price ;  //图书价格 private封装属性
	public  Book(String p,double q){  //构造方法 初始化对象
		title = p;
		price = q;
	}
	public void setTitle(String t){
		title = t;
	}
	public void setPrice(double t){
		price = t;
	}
	public String getTitle(){
		return title ;
	}
	public double getPrice(){
		return price;
	}
	public String getInfo(){
		return "图书的名称是："+title+"  图书的价格是："+price;
	}
}
public class TestDemo
{
	public static void main(String args[]){
		Book bk[]=new Book[3];   //动态初始化对象数组 
		bk[0]= new Book("java开发大全",123.987);
		bk[1]= new Book("jsp开发",88.99);
		bk[2]= new Book("算法初探",85.7);
		for(int i=0;i<bk.length;i++){
			System.out.println(bk[i].getInfo());
		}
		System.out.println();
		 //静态初始化对象数组
		Book bk1[] =new Book[]{new Book("java开发大全",123.987),new Book("jsp开发",88.99),new Book("算法初探",85.7)};
		for(int j=0;j<bk.length;j++){
			System.out.println(bk1[j].getInfo());
		}
	}
}

程序执行结果 ：
				图书的名称是：java开发大全  图书的价格是：123.987
				图书的名称是：jsp开发  图书的价格是：88.99
				图书的名称是：算法初探  图书的价格是：85.7
	
				图书的名称是：java开发大全  图书的价格是：123.987
				图书的名称是：jsp开发  图书的价格是：88.99
				图书的名称是：算法初探  图书的价格是：85.7

对象数组最大的好处就是将多个对象统一进行管理，并且除了数据类型以外，和之前的数组没有区别 。
可以把对象数组名理解为栈内存，储存堆内存地址。在这里声明栈内存的时候，需要使用关键字new。在开辟堆内存的时候，又需要使用一次new。。。。。。