黑马程序员--java基础--函数和数组

-------
android培训、java培训、期待与您交流！ ----------

函数

定义：定义在类中的具有特定功能的一段独立小程序。也称方法。

格式：

修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，…）

{

执行语句；

return返回值；

}

注意：

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return：用于结束函数。

返回值：该值会返回给调用者。

特点：



定义一个函数必须要两个明确

1、明确要定义的功能最后的结果是什么。

2、明确在定义该功能的过程中，是否需要未知内容参与运算。

练习一下

class Demo
{

/*
需求1： 定义一个功能，完成两个整数的和的获取。
思路：既然定义功能，就是可以用函数来体现。
如何定义一个函数呢？
通过两个明确来完成。
明确一：这个功能的结果是什么？
是和。是功能的结果，所以该功能的返回值类型是int 。
其实就是在明确函数的返回值类型。

明确二：这个功能实现过程中是否需要未知内容参与运算？
有，加数和被加数。这就是函数的参数列表(参数的个数，参数的类型)
其实就是在明确参数列表。

注意：返回值类型和参数类型没有直接关系。

*/
public static int add(int a,int b)
{
int sum = a+b;
return sum;
}

/*
需求2： 定义一个功能，画一个矩形在控制台。
明确一：这个功能的结果是什么？
没有结果，因为直接打印到了，控制台，并未返回给调用者。
用void表示。
明确二：这个功能实现过程中是否需要未知内容参与运算？
有，行和列不确定。两个。整数 int.
*/
public static void draw(int row,int col)
{
for (int x=1; x<=row ;x++ )
{
for (int y=1;y<=col ; y++ )
{
System.out.print("*");
}
System.out.println();
}
//		return ;//可以省略不写。
}

/*
需求3： 定义一个功能，比较两个数是否相等。
明确一：这个功能的结果是什么？
有，boolean.
明确二：这个功能实现过程中是否需要未知内容参与运算？
有，两个整数。

*/
public static boolean equals(int a,int b)
{
/*
if(a==b)
return true;
else
return false;

boolean x ;
if(a==b)
x = true;
else
x = false;
return x;

*/
//		return (a==b)?true:false;

return a==b;

}

/*
需求4： 定义一个功能，获取两个整数中较大的那个数。
明确一：这个功能的结果是什么？
有，其中一个数。 int
明确二：这个功能实现过程中是否需要未知内容参与运算？
有，参与比较的两个整数 int
*/
public static int getMax(int a,int b)
{
/*
if(a>b)
return a;
else
return b;
*/

return a>b?a:b;
}
}

定义功能，打印99乘法表

public static void print99()
{
for(int x=1; x<=9; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}

根据考试成绩获取学生分数对应的等级

90~100
A

80~89 B

70~79 C

60~69 D

60以下 E

public static char getLevel(int num)
{
char level ;
if(num>=90 && num<=100)
level = 'A';
else if(num>=80 && num<=89)
level =  'B';
else if(num>=70 && num<=79)
level =  'C';
else if(num>=60 && num<=69)
level =  'D';
else
level =  'E';

return level;
}

函数特性：重载






什么时候用重载

当定义的功能相同，但参与运算的未知内容不同。

例如

//加法运算。两个整数的和。
public static int add(int a,int b)
{
return a+b;
}

//加法运算。两个小数的和。
public static double add(double a,double b)
{
return a+b;
}

//加法运算，三个整数的和。
public static int add(int a,int b,int c)
{
return add(a,b)+c;
}

小练习：定义一个打印乘法表功能

打印乘法表。
*/
public static void printCFB(int num)
{
for(int x=1; x<=num; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}

数组

概念



数组也被称为引用数据类型。

了解一下内存的划分

Java程序在运行时，为了提高运算效率，对空间进行了不同区域的划分，每一片区域都有特定的处理数据方式和内存管理方式。



数组常见问题

1、数组脚标越界异常(ArrayIndexOutOfBoundsException)。

访问数组中的不存在的脚标时

2、空指针异常(NullPointerException)。例：

arr引用没有指向实体

数组的核心思想： 对数组的操作就是对角标的操作。（存取动作）

数组中常见操作

1、获取最大值

思路：
1，需要进行比较。并定义变量记录住每次比较后较大的值。
2，对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
如果遍历到的元素大于变量中记录的元素，就用变量记录住该大的值。
3，遍历结果，该变量记录就是最大值。

定义一个功能来是实现。
明确一，结果。
是数组中的元素。int .
明确二，未知内容。
数组.
*/
public static int getMax(int[] arr)
{
//定义变量记录较大的值。
int maxElement = arr[0];//初始化为数组中的任意一个元素。
for(int x=1; x<arr.length; x++)
{
if(arr[x]>maxElement)
maxElement = arr[x];
}
return maxElement;
}
public static int getMax_2(int[] arr)
{
//定义变量记录较大的值。
int maxIndex = 0;//初始化为数组中任意一个角标。
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[maxIndex])
maxIndex = x;
}
return arr[maxIndex];
}

2、选择排序

/*
选择排序。
*/
public static void swap(int[] arr,int a,int b)//定义换位功能
{
int temp = arr[a];
arr[a] = arr;
arr[b] = temp;
}
public static void selectSort(int[] arr)//大圈套小圈思想
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
/*
int temp  = arr[x];
arr[x] = arr[y];
arr[y] = temp;
*/
}
}
}
}

[b]

3、冒泡排序

/*
冒泡排序。
*/
public static void swap(int[] arr,int a,int b)//定义换位功能
{
int temp = arr[a];
arr[a] = arr;
arr[b] = temp;
}
public static void bubbleSort(int[] arr)//大圈套小圈
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=0; y<arr.length-1-x; y++)
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
/*
int temp  = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
*/
}
}
}
}

练习：

[b]给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，

那么个元素的存储的角标为如何获取。



一般方法

public static int getIndex(int[] arr,int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;
}

二分查找法

public static int halfSearch(int[] arr,int key)
{
int max,min,mid;
min = 0;
max = arr.length-1;
mid = (max+min)/2;

while(arr[mid]!=key)
{
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;

if(max<min)
return -1;

mid = (max+min)/2;
}
return mid;

}

获取一个整数的16进制表现形式

public static void toHex(int num)
{

if(num==0)
{
System.out.println("0");
return ;
}
//定义一个对应关系表。
char[] chs = {'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
/*
一会查表会查到比较的数据。
数据一多，就先存储起来，在进行操作。
所以定义一个数组。 临时容器。
*/
char[] arr = new char[8];
int pos = arr.length;

while(num!=0)
{
int temp = num&15;
arr[--pos] = chs[temp];
num  = num >>> 4;
}

System.out.println("pos="+pos);
for(int x=pos ;x<arr.length; x++)
{
System.out.print(arr[x]);
}

}

十进制转换为二进制、八进制、十六进制的小程序

//十进制-->十六进制。
public static void toHex(int num)
{
trans(num,15,4);
}
//十进制-->二进制。
public static void toBinary(int num)
{
trans(num,1,1);
}
//十进制-->八进制。
public static void toOctal(int num)
{
trans(num,7,3);
}

public static void trans(int num,int base,int offset)
{

if(num==0)
{
System.out.println("0");
return ;
}
//定义一个对应关系表。
char[] chs = {'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
/*
一会查表会查到比较的数据。
数据一多，就先存储起来，在进行操作。
所以定义一个数组。 临时容器。
*/
char[] arr = new char[32];
int pos = arr.length;

while(num!=0)
{
int temp = num & base;
arr[--pos] = chs[temp];
num  = num >>> offset;
}

for(int x=pos ;x<arr.length; x++)
{
System.out.print(arr[x]);
}
System.out.println();

}

查表法查星期几

public static String getWeek(int num)
{

if(num>7 || num<1)
{
return "错误的星期";
}
String[] weeks = {"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};

return weeks[num];
}

多维数组

我们主要讲二维数组。



二维数组的基本用法

public class TESSET {

public static void main(String[] args) {
int [] arr = new int [3];
System.out.println(arr);//[I@15db9742   打印结果@左边是实体的类型                    @右边是实体的哈希值
int [][] arr1 = new int [3][2];//创建一个二维数组，这个数组中有三个一维数组，每个一维数组中有两个元素
System.out.println(arr1);//直接打印二维数组    打印结果[[I@6d06d69c
System.out.println(arr1[0]);//直接打印二维数组中角标是0的一维数组          打印结果[I@7852e922
System.out.println(arr1[0][0]);//直接打印二维数组中角标是0的一维数组中角标是0的元素     空指针异常（如果用的是eclipse则结果是0）
System.out.println(arr1.length);//直接打印二维数组的长度
System.out.println(arr1[0].length);//直接打印二维数组中角标是0的一维数组的长度
}

}