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;
arr[b]=temp;
}
}

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

/*
** 查找数组中的元素
*/
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;
}
}