java笔记-面向对象-重载、数组

1.函数的重载

概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
特点：与返回值类型无关，只看参数列表。

/*
** 函数重载
** 函数功能名称和功能相同，函数的参数和个数未知。
*/
class OverLoad{
	public static void main(String[] args){
		int x=5,y=3,z=7;
		/*
		** 打印重载函数运算；
		*/
		System.out.println("x=5,y=3,x+y="+add(x,y));
		System.out.println("x=5,y=3,z=7,x+y+z="+add(x,y,z));
		
		/*
		** 打印99乘法表；
		*/
		print99();
	}
	/*
	**函数重载与返回值类型无关。
	*/
	public static int add(int x,int y){
		return x+y;
	}
	public static int add(int x,int y,int z){
		return x+y+z;
	}
	
	/*
	**99乘法表；
	*/
	public static void print99(){
		/*
		for(int x=1;x<=9;x++){
			for(int y=1;y<=x;y++){							//x保持不变，y逐渐递增与x连乘；
				System.out.print(y+"*"+x+"="+y*x+"\t");		//不换行输出；
			}
			System.out.println();							//换行输出；	
		}
		*/
		
		/*
		** 为了提高代码可用性，上述方式可以采用如下进行：
		*/
		print99(9);
	}
	
	/*
	**99乘法表,一直乘到num数值；
	*/
	public static void print99(int num){
		for(int x=1;x<=num;x++){		//x<=num,一直连乘到num；
			for(int y=1;y<=x;y++){							//x保持不变，y逐渐递增与x连乘；
				System.out.print(y+"*"+x+"="+y*x+"\t");		//不换行输出；
			}
			System.out.println();							//换行输出；	
		}
	}
}

2.数组

概念：同一种数据类型的集合。

优点：可以自动给数组中的元素编号，便于操作。

格式：

元素类型[] 数组名称=new 元素类型[元素个数或数组长度];

int[] arr=new int[5];//arr为引用数据类型中的数组；

数组的静态初始化：

int[] arr=new int[]{1,2,3,4};

数组名称arr存放在栈内存中，int[5]存放在堆内存中；放在栈内存中的数据使用完毕会自动释放，局部变量都在栈内存中。

编译只检查语法错误；

取数组的最值和排序：

class maoPao{
	/*
	**获得最大值；
	*/
	/*
	public static int getMax(int[] arr){
		int max=arr[0];
		for(int x = 0; x<arr.length;x++){
			if(max<arr[x]){
				max=arr[x];
			}
		}
		return max;
	}
	public static void main(String[] args){
		int arr[]={1,2,3,6,3,2,6,9,10,-10};
		int max= getMax(arr);
		System.out.println("max="+max+".");
	}
	*/
	
	/*
	**选择排序
	*/
	/*
	public static void XuanZePaiXu(int[] arr){
		int temp;
		for(int x=0;x<arr.length-1;x++){
			for(int y=x+1;y<arr.length;y++){
				if(arr[x]<arr[y]){		//从小到大开始排序
					temp=arr[x];
					arr[x]=arr[y];
					arr[y]=temp;
				}
			}	
		}
	}
	public static void main(String[] args){
		int[] arr_1={3,6,3,2,1,8,82,23,21,32,23,64,73};
		XuanZePaiXu(arr_1);
		System.out.println("{");
		for(int x=0;x<arr_1.length;x++){
			if(x!=arr_1.length){
				System.out.print(arr_1[x],);	
			}
		}
		System.out.println("}");
	}
	*/
	
	/*
	**冒泡排序
	*/
	public void bubble(int[] arr){
		for(int x=0;x<arr.length;x++){
			for(int y=0;y<arr.length-x-1;y++){		//arr.length-x-1：-x是为了减少每一次比较的元素，-1是为了防止脚标越界。
				if(arr[y]>arr[y+1]){				//从小到大排序
					int temp=arr[y];
					arr[y]=arr[y+1];
					arr[y+1]=temp;
				}
			}
		}
	}
	public static void swap(int[] arr,int a,int b){
		int temp;
		temp=arr[a];
		arr[a]=arr[b];
		arr[b]=temp;
	}
}

查找数组中的元素（一般查找）：

/*
** 查找数组中的元素
*/
class findIndex{
	public static void main(String[] args){
		int[] arr=new int[]{1,23,4,3,5};
		int temp;
		temp=findWord(arr,4);
		if(temp>=0){
			System.out.println("word position is "+temp+".");	
		}
		else{
			System.out.println("The array is null,or there have no this word!");
		}
		
	}
	/*
	** 获取元素第一次出现在数组中的位置；
	*/
	public static  int findWord(int[] arr,int key){
		if(arr!=null){							//先判断数组是否为空；
			for(int x=0;x<arr.length;x++){		//查找数组中的元素；
				if(arr[x]==key){
					return x;					//返回数组元素下标；
				}
			}
		}
		return -1;
	}
}

数组折半查找：

折半查找必须为有序数组

public class halfSearch{
	public static void main(String[] args){
		int[] arr=new int[]{1,3,6,12,18,23};
		int temp_1=getIndex_1(arr,32);	//第一种方式判断
		int temp_2=getIndex_1(arr,12);	//第二种方式判断
		System.out.println("getIndex_1 Index is "+temp_1+".");
		System.out.println("getIndex_2 Index is "+temp_2+".");
	}
	
	/*
	** 用数组下标进行判断；
	*/
	public static int getIndex_1(int[] arr,int key){
		int min,max,mid;
		min=0;
		max=arr.length-1;
		while(min<=max){		//用数组下标进行判断；
			mid=(min+max)>>1;	//中间下标赋值；
			if(key>arr[mid]){	
				min=mid+1;		//重置min下标为mid+1；
			}
			else if(key<arr[mid]){
				max=mid-1;		//重置max下标为mid-1；
			}
			else{
				return mid;		
			}
		}
		return -1;
	}
	
	/*
	**按照值判断；
	*/
	public static int getIndex_2(int[] arr,int key){
		int min,max,mid;
		min=0;
		max=arr.length-1;
		mid=(min+max)>>1;
		while(arr[mid]!=key){
			if(key<arr[mid]){
				max=mid-1;
			}
			else if(key>arr[mid]){
				min=mid+1;
			}
			if(min>max){
				return -1;			//数组下标异常则退出；
			}
			mid=(min+max)>>1;		//由于用值进行判断，数组下标要实时进行更新；
		}
		return mid;
	}
}