【数组--函数--对象】思想

代码:

第一篇：
package com.jichuyufaJava;
/**
 * 函数的测试，函数的定义。
 * @author user
 *
 */
public class Function {
	public static void main(String[]args)
	{
		int c=add(3,54);
		myPrint();
		//调用者调用函数自行处理的函数
		add2(3, 2);
		System.out.println(c);
		
		//画一个矩形
		draw(6,3);
		
		//判断两个数是否相等
		System.out.println(equals(2,2));
		
		//判断两个数最大的数
		
		System.out.println(GetMax(23,2));
		
		//利用重载进行计算任意两个数的和
		System.out.println("int,int="+add_(2,4));
		System.out.println("double,double="+add_(2.2,4.34));
		System.out.println("double,int="+add_(2.23,4));


	}
	 //尝试写一个加法函数add()
	//被调用的必须是相同的类型
	public static int add(int a,int b)
	{
		return a+b;
	}
	public static void myPrint()
	{
		System.out.println("hello world");
		return;
	}
	//函数的返回值应该交由调用者处理。不能有函数自行处理。
	public static void add2(int a,int b)
	{
		System.out.println("由函数自行处理的返回值"+(a+b));
		return;
	}
	
	//定义一个功能，画一个矩形在控制台
	public static void draw(int row,int col)//定义矩形的长row和宽col
	{
		/*
		 * *****
		 * *   *
		 * *****
		 */
		for(int i=1;i<=col;i++)//控制宽，也就是控制行数
		{
			for(int j=1;j<=row;j++)//控制长，也就是控制列数
			{
				if(i==1||i==col)
				System.out.print("*");
				
			}
			System.out.println();
		}
		
	}
	//判断两个数是否相等
	public static boolean equals(int a,int b)
	{
		return (a==b);//返回的值是boolean类型的直接表现出boolean值就可以了	
	}
	//返回两个数中最大的那个
	public static int GetMax(int a,int b)
	{
		return a>b?a:b;//三元组
	}
	
	
	//函数的重载（overload）
	/**
	 * 1.同一个类，同名，参数个数不同，或者参数类型不同
	 */
	//两个数的加法运算 重载
	public static int add_(int a,int b)
	{
		return a+b;
	}
	public static double add_(double a,double b)
	{
		return a+b;
	}
	public static double add_(int a,double b)
	{
		return a+b;
	}
	
}



运行结果：
第二篇：
package com.jichuyufaJava;

public class ArrayDemo {

	/**  数组的测试
	 * @param args
	 */
	public static void main(String[] args)
	{
	
	// TODO Auto-generated method stub
		//元素类型[] 数组名=new 元素类型[元素的长度或元素的个数]；
		
		int[] arr=new int[3];//定义了一个数组
		{
			//局部代码块,限定局部变量的生命周期
			int age=3;
			arr[0]=3;
			System.out.println(arr[0]);
		}
		//打印出arr[]的哈希值
		System.out.println(arr);//[I@148aa23 哈希值，[表示是数组类型的，I表示是整型。
		
		int[] x={2,3,54,5};
		int[] y=new int [4];
		y[0]=23;
		y[3]=2;
		printX_Y(x,y);//打印x,y数组的函数
		
		//将y赋给x :x=y;然后再打印x[2]的值的时候，其值已经变成了y[2]的值。
		x=y;
		printX_Y(x,y);
		System.out.println(x[2]);

		//修改x数组的值也就是修改y数组的值，因为x的地址和y的地址是指向同一个地址的
		x[2]=343;
		printX_Y(x,y);
		
		
		//数组的格式2：
		//元素类型	[]	元素名=new 元素数组名[]{元素1，元素2…………}；
		int[] arr11=new int[]{2,3,5,3};
		int[] arr2={2,3,5,3};
		System.out.println("int[] arr2=new int[]{2,3,5,3}为"+arr2[0]+" "+arr2[1]);
		System.out.println("int[] arr1=new int[]{2,3,5,3}为"+arr11[0]+" "+arr11[1]);
	}
	//打印x,y的函数
	public static void printX_Y(int[] x,int[]y)
	{
		for(int i=0;i<x.length;i++)
		{
			System.out.print(" x"+"["+i+"]"+"="+x[i]);
		}
		System.out.println();
		for(int i=0;i<y.length;i++)
		{
			System.out.print(" y"+"["+i+"]"+"="+y[i]);
		}
		System.out.println();
	}

}
/*
运行结果：
3
[I@1fc4bec
 x[0]=2 x[1]=3 x[2]=54 x[3]=5
 y[0]=23 y[1]=0 y[2]=0 y[3]=2
 x[0]=23 x[1]=0 x[2]=0 x[3]=2
 y[0]=23 y[1]=0 y[2]=0 y[3]=2
0
 x[0]=23 x[1]=0 x[2]=343 x[3]=2
 y[0]=23 y[1]=0 y[2]=343 y[3]=2
int[] arr2=new int[]{2,3,5,3}为2 3
int[] arr1=new int[]{2,3,5,3}为2 3
*/

第三篇：
package com.jichuyufaJava;
//二维数组
public class Array2Demo {
	//测试二维数组的方法
	public static void testArray2(int[][]arr)
	{
		//创建一个二维数组，有三个一维数组，每个一维数组里有两个元素
		System.out.println("二维数组arr[3][2]哈希值是："+arr);//打印出哈希值 [[I@2ce908
		System.out.println("二维数组的rowLength是："+arr.length);//打印二维数组的rowLength
		System.out.println("二维数组中colLength是："+arr[0].length);//打印二维数组的colLength
		System.out.println("二维数组的colLength是："+arr[0]);

		//打印一维数组与二维数组做比较
		int[]arr2;
		arr2=new int[2];
		arr2[0]=223;
		System.out.println("一维数组：arr2[0]是"+arr2[0]);
		
		//二维数组的另一种定义方法
		int[][]arr1=new int[3][];
		arr1[0]=new int[2];//arr1[0]可以看作是一个数组名
		
		
		//对一个数组进行遍历
		for(int i=0;i<arr.length;i++)
		{
			System.out.print("{");
			for(int j=0;j<arr[i].length;j++)
			{
				System.out.print(arr[i][j]+" ");
			}
			System.out.print("}");
		}
}
	
	//主函数
	public static void main(String[]args)
	{
		//定义一个二维数组arr
		int[][]arr={{2,23,21},{234,12,11,34},{234,1,123}};
		testArray2(arr);
		
	}
}

 /*运行结果：
二维数组arr[3][2]哈希值是：[[I@4f1d0d
二维数组的rowLength是：3
二维数组中colLength是：3
二维数组的colLength是：[I@1fc4bec
一维数组：arr2[0]是223
{2 23 21 }{234 12 11 34 }{234 1 123 }
*/



第四篇

package com.jichuyufaJava;

public class ArrayMax {

	/**获取数组中的最大值：
	
	 * 1.需要进行比较，并定义变量记录主每次比较后较大的值
	 * 2.对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
	 * 3.如果遍历到的元素大于变量中记录的元素，就用变量记录住该最大的值。
	 * 4.遍历结果。该变量记录就是最大的值。
	 * 定义一个功能来实现：
	 * 明确一：结果	是数组中 的元素。int
	 * 明确二：未知内容。数组
	 * 
	

	 * @param args
	 */
	//数组里最大值：利用最原始的两个值一对一的比较
	public static int getMax(int[] arr)
	{
		int max=arr[0];
		for(int i=0;i<arr.length;i++)
		{
			if(max<arr[i])
				max=arr[i];
		}
		return max;
	}
	
	//数组里最大值：比较得到比较大的值的时候，互换其所对应的角标
	public static int getMax_2(int[] arr)
	{
		int maxIndex=0;
		for(int i=0;i<arr.length;i++)
		{
			if(arr[maxIndex]<arr[i])
				maxIndex=i;
				
		}
		return arr[maxIndex];
	}
	
	
	

	//主函数入口
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr={22,2323,232};
		System.out.println("getMax="+getMax_2(arr));

	}

}
/*
运行结果：
getMax=2323
*/

第四篇：
package com.jichuyufaJava;

public class SelectSortArray {

	/*“使用大圈套小圈”的思想，进行排序双重for循环
		**
		 * 对于一个数组里的一系列数，对其进行排序。首先用第一个数与剩下的(n-1)个数进行比较，
		 * 其次，用第二个数与剩下的(n-2)个数比较。
		 * 两两比较，较小的放于前边，较大的放于后边。依次进行。
		对于数组arr[],大的遍历圈数是arr.length-1;每个小的遍历圈数是arr.length-1-i;
	 * @param args
	 */
	//选择排序
	public static void selectSortarray(int[] arr)
	{
		for(int i=0;i<arr.length-1;i++)
		{
			for(int j=i+1;j<arr.length;j++)
			{
				
				if(arr[i]>arr[j])//数组里的两个数进行互换
				{
					int temp=arr[j];
					arr[j]=arr[i];
					arr[i]=temp;
				}
			}
		}
	}
	
	public static void selectSortarray_2(int[]arr)//选择排序的第二种方法
	{
		for(int i=0;i<arr.length-1;i++)
		{
			int num=arr[i];
			int index=i;
			for(int j=i+1;j<arr.length;j++)
			{
				if(num>arr[j])
				{
					num=arr[j];
					index=j;
				}
				if(index==i)
					swap(arr,i,index);
			}
		}
	}
	//交换两个数
		public static void swap(int[]a,int b,int c)//是对一个数组里的两个数进行交换，一个数组arr[],两个下标a,b;
		{
			int temp=a[b];
			a[b]=a[c];
			a[c]=temp;
		}
	public static void printArr(int[]arr)//打印数组
	{
		System.out.print("[");
		for(int i=0;i<arr.length;i++)
		{
			if(i!=arr.length-1)
			System.out.print(" "+arr[i]);
			else
				System.out.println("]");
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[]arr={23,2,232,-2,2322};
		System.out.print("排序前的数组：");
		printArr(arr);
		//调用功能，对arr数组进行排序
		selectSortarray_2(arr);
		//调用功能，对arr数组进行打印
		System.out.print("排序后的数组：");
		printArr(arr);
		}
}
/*
运行结果：
排序前的数组：[ 23 2 232 -2]
排序后的数组：[ 23 2 232 -2]
*/
第五篇:

public class BubbleSortMethod {

	/**冒泡排序：相邻的两个排序
	 * [num1,num2,num3,num4]
	 * @param args
	 */
	public static void bubbleSortMethod(int[]arr)//冒泡排序
	{
		for(int i=arr.length;i>0;i--)
		{
			for(int j=0;j<i-1;j++)//避免越界
			{
				if(arr[j]>arr[j+1])
				{
					/*
					int temp=arr[j+1];
					arr[j+1]=arr[j];
					arr[j]=temp;
					*/
					swap(arr,j,j+1);
				}
			}
		}
	}
	
	//交换两个数
	public static void swap(int[]a,int b,int c)//是对一个数组里的两个数进行交换，一个数组arr[],两个下标a,b;
	{
		int temp=a[b];
		a[b]=a[c];
		a[c]=temp;
	}
	//打印出数组
	public static void printArray(int[]arr)
	{
		System.out.print("数组：");
		for(int i=0;i<arr.length;i++)
		{
			
			System.out.print(arr[i]+" ");
		}
	}
	
	//数组常见功能：查找  索引
	public static int getIndex(int[]arr,int key)
	{
		for(int i=0;i<arr.length;i++)
		{
			if(arr[i]==key)
				return i;			
		}
		return -1;
	}
	
	//二分法查找
	public static int halfSearch(int[]arr,int key)
	{
		
		int min=0;//初始化定义所查找的数组里的最小的角标
		int max=arr.length-1;//初始化定义所查找数组里的最大的角标
		int mid=(min+max)/2;//初始化定义数组的中间角标
		
		while(arr[mid]!=key)//最根本的是比较中间值arr[mid]是否和key相等
		{
			if(key>arr[mid])
				min=mid+1;
			else if(key>arr[mid])
				max=mid-1;
			if(max<min)
				return -1;
			mid=(min+max)/2;
		}
		return mid;
	/*	for(int i=0;i<arr.length;i++)
		{
			//情况：所查找的数在数组的范围里
			//情况：不再范围里，return -1;
			if(key<arr[mid])//如果key比arr[mid]中间值小
			{
				max=mid-1;//此时max的值为mid的值向左移一位：即max=mid-1
				
			}
			else if(key>arr[mid])
			{
				max=mid+1;
			}
			
		}return mid;*/
	
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.print("2的32次方");
		System.out.print(1l<<32);
		
		int[]arr={123,1,3,343};
		bubbleSortMethod(arr);//进行冒泡排序
		printArray(arr);//打印排序后的数组
		
		int index=getIndex(arr,343);//索引
		System.out.println("index="+index);
		int[]arr1={234,2,2342,12,11};
		int key1=halfSearch(arr1,12);//二分法查找
		System.out.println("key="+key1);

	}
}
/*
运行结果：
2的32次方4294967296数组：1 3 123 343 index=3
*/

第六篇：
package com.jichuyufaJava;
/**
 * 面向对象的测试：
 * 		写一个汽车类：
 * 		进行分析：1，属性（轮胎数，颜色）2，行为（运行）
 * @author user
 *
 */
 class Car//这是一个汽车类
{
	 //汽车的属性
	 int num;//定义轮子的个数
	String color;//定义汽车的颜色
	
	//汽车的行为
	void run()//汽车可以运行的行为
	{
//		int num=10;//打印出来的是10
		System.out.println("汽车轮子个数："+num+"汽车颜色"+color);
	}
}
 
public class Object_Oriented_Demo1car//汽车类
{
	public static void main(String[]args)
	{
		System.out.println("********通过给c1.num,c1.color赋值，调用c1.run()*********");
		//创建对象。
		Car c1=new Car();//创建一个c1
		Car c2=c1;//c2对象
		
		//成员变量赋值		
		c1.num=4;
		c2.color="red";
		c1.run();
		
		
		//c1=null;
		System.out.println("********定义类类型参数的方法，同过调用类类型对象打印*********");
		Car c3=new Car();
		//类类型
		show(c1);//调用类类型对象
		show(c2);	
		show(c3);
		
		
		System.out.println("********没有名字的对象：匿名对象，直接使用匿名对象调用方法，但是匿名对象只能使用一次*********");
		//匿名对象
		new Car().num=4;//匿名对象；只改变了num的值
		new Car().color="green";//只改变了color的值
		new Car().run();//成员变量的值都为空
	
		//匿名对像可以作为实际参数进行传递
		show(new Car());//类类型直接是匿名对象
		
	}
	
	//为了提高代码的复用性，单独写一个有类类型的方法
	public static void show(Car c)//参数为汽车类型，类类型的变量指向对象。
	{
		//成员变量赋初始化值
		c.num=3;
		c.color="blank";
		
		//打印方法
		System.out.println("show:"+c.num+"......"+c.color);
	}
}


运行结果：
 
第七篇：
/**
 * 基本数据类型参数传递
 * @author user
 *
 */
//基本数据类型参数传递测试
public class Object_Oriented_Demo2 {

	
	//先写一个主函数
	public static void main(String[] args)
	{
		int x=3;//对show方法里的参数进行定义
		show(x);//调用show()方法    	 结果：4
		System.out.println("x="+x);//结果：3
		
	}

	
	//写一个演示方法
	public static void show(int x)//用来演示的方法
	{
		x=4;//参数为int x;函数体为 ：x=4;
	}
}
/*
运行结果：x=3
*/

第七篇：
//引用数据类型参数传递
public class Object_Oriented_Demo2
{
	int x=3;
	//写一个主函数
	public static void main(String args[])
	{
		Object_Oriented_Demo2 ood=new Object_Oriented_Demo2();
		ood.x=9;
		show(ood);
		System.out.println("ood.x="+ood.x);
	}
	
	//写一个展示的方法
	public static void show(Object_Oriented_Demo2 ood)//类类型对象
	{
		ood.x=4;
	}
}
/*
 * 运行结果：ood.x=4
 */