黑马程序员—java编程基础+函数+数组

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

函数

 

1.函数的定义： 函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。 

2.函数的格式： 

  修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2...) 

{ 

  执行语句; 

  return 返回值; 

} 

 

注意：

形式参数：

实际参数：

 

函数与函数是平级关系，不能嵌套定义

函数只有被调用才执行

函数的调用

A:有明确返回值

a:单独调用 一般没有意义。

b:输出调用 但是如果想拿结果继续操作，就有问题了。所以，不好。

c:赋值调用 推荐方式。

 

B:void类型

单独调用

 

 

 

 

 

3.函数的特点： 

1).定义函数可以将功能代码进行封装，便于对该功能进行复写。 

2).函数只有被调用才会被执行。 

3).函数的出现提高了代码的复用性。 

4).对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的 return语句如果在最后一行可以省略不写。 

5).函数中只能调用函数，不可以在函数内部定义函数。 

6).定义函数时，函数的结果应该返回给调用者，交由调用者处理。 

7).可以自定义一个访问权限。

 

定义函数时需要注意： 

1.功能中只定义所需内容，不是该功能所需的内容不要定义。 

 

2.如果非要定义，也是单独定义一个功能来体现。以后开发时，尽量都将功能以不同的函数来体现。 

 

3.不要将代码都定义在主函数中。 

 

4.主函数的作用是：对已有的功能的进行调用，可以理解为用于功能的测试。 

 

5.函数名就是一个自己定义的标示符。函数名的定义，要尽量体现出这个函数的功 能。是为了增强该函数的阅读性，方便于调用者使用，所以函数名一定要有起的有意义。 

 

6.静态方法只能调用静态方法。主函数是静态的。 

 

7.返回值类型和参数类型没有直接关系。

 

 

 

 

   定义函数时候需要有两个明确：

1）这个函数会得到什么结果，也就是返回值是什么。 

 

2）有没有未知内数据参与运算。 

 

 

4.函数的重载（Overload）： 

1).重载的概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数和参数类型不同即可。 

 

2).重载的特点：与返回值类型无关，只看参数列表。 

 

3).重载的好处：方便于阅读，优化了程序设计。 

 

注:Java是严谨性语言，如果函数出现的调用不确定性，会编译失败。 

 

5.函数重载什么时候使用？ 

重载：当定义的功能相同，但参与运算的未知内容不同，那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。 

 

 

 数组

 

1.数组的概述： 

 

1).概念：同一种类型数据的集合。其实数组就是一个容器。 

 

2).好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。 

 

3).对数组的基本操作就是存和取。核心思想：基于角标。 

 

4)既可以存储基本数据类型又可以存储引用类型，只是长度固定。集合长度可变，但只能存储引用类型。 

 

 

2.数组的定义： 

 

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

 

2）元素类型[] 数组名 ={1,2,3,4,5,6,7};可以直接指定具体的数据 

 

3）元素类型[] 数组名； 

 

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

 

3.数组的特点：

 

1）数组定义时，必须明确数组的长度(就是数组中可以存储的元素的个数。)因为数组长度是固定的。 

 

2）数组定义时，必须明确数组中的元素的数据类型。 

 

例如：

char[] arr = new char[7]; 

 

arr[0] = '张';arr[1] ='三'; 

 

 

4.数组的内存结构： 

 Jva内存区域的划分：1）寄存器 2)地方法区。3）方法区。 4）栈内存。5）堆内存。 

 

为什么划分这么区域？因为每一个内存区域对数据的处理方式不同。目前要讲的就是栈和堆。 

 

 

1）栈内存的特点：存储都是局部变量 

 

 

(函数参数,函数内定义的变量,语句中定义的变量)变量一旦使用完(作用域结束)，就会在栈内存中自动释放。 

 

 

2）堆内存特点：存储的是实体 

 

 

1.堆内存中的实体都有首内存地址值. 

 

2.堆内存中的变量都有默认初始化值. 

 

3.对于没有任何引用变量指向的实体，会视为垃圾，会被垃圾回收机制所回收。 

(数组和对象，只要是new的，都在堆内存中) 

 

 

 

5.操作数组时常见问题： 

A.数组角标越界异常(ArrayIndexOutOfBoundsException):操作数组时，访问到了数组中不存在的角标。 

 

B.空指针异常(NullPointerException)：当引用没有任何指向值为null的情况，该引用还在用于操作实体。 

 

6.对数组的常见操作；

1.获取数组中的元素 (取数组中的元素，通常会用到遍历）

2.获取最值 

3.排序（冒泡排序、选择排序）  

4.查找（折半查找 只针对有序）插入（针对有序） 

 

 

二维数组 

 

1.什么是二维数组： 

 

其实元素就是一个一维数组。 

 

2.二维数组格式： 

 

(1).方式1:元素类型[][] 数组名 = new 元素类型[3][2]; 

 

(2).方式2：元素类型[][] 数组名 =new 元素类型[3][]; 

 

(3).方式3：元素类型[][] 数组名 = {{一维数组元素}{一维数组元素}{一维数组元素}}; 

 

 

3.二维数组的遍历 

 

(1).二维数组的每一个元素是一维数组。 获取到每一个一维数组。 

 

(2).二维数组的遍历。 

 

class Test { 
 
public static void main(String[] args) { 
 
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}}; 
 
//arr.length 获取二维数组的长度，其实也就是一维数组的个数 
 
for(int x=0; x<arr.length; x++) { 
 
//arr[x].length 获取的是每一个一维数组的长度 
 
for(int y=0; y<arr[x].length; y++){ 
 
//arr[x][y] 获取的是二维数组的元素 
 
System.out.print(arr[x][y]+"\t"); 
 
                    } 
 
System.out.println(); 
 
} 
 
} 
} 

 

 

 

怎么操作数组？

1. 获取最值：

初始化任一元素：

public static int getMax(int[] arr)

{

int max = arr[0];

 

for(int x=1; x<arr.length; x++)

{

if(arr[x]>max)

max = arr[x];

}

return max;

}

初始化为数组中任意一个角标：

public static int getMax_2(int[] arr)

{

int max = 0;

 

for(int x=1; x<arr.length; x++)

{

if(arr[x]>arr[max])

max = x;

}

return arr[max];

}

2. 排序： 

选择排序：让第一个数（a）和其他剩余的数字（b,c,d）进行比较，如果a>b就进行交换，此时第一个数为b，与c,d继续比较。与第一轮结束后，第一个数为最小数。从第二个数开始和其他剩余的数字进行比较，进行第二轮---第三轮--第四伦，以此类推比较

 

public class Test2

{

public static void main(String[] args)

{

int[] array = { 3, 6, 1, 7, 2, 9, 4, 52, 56 };

System.out.println("排序前：");

for (int i : array)//高级for遍历

{

System.out.print(i + " ");

}

System.out.println("\n排序后：");

 

SelectSortArray(array);

for (int ii : array)

{

System.out.print(ii + " ");

}

}

 

//选择排序，一轮下来只换一次，代码不好记，效率高

public static void SelectSortArray(int[] arr)

{

//初始化变量

int min = arr[0];

int min_index = 0;

int temp = 0;

 

for (int i = 0; i<arr.length-1; i++)

{

min = arr[i];

min_index = i;

for (int j = i+1; j < arr.length; j++)

{

if (min > arr[j])

{

min_index = j;

min = arr[j];

}

}

temp = arr[min_index];

arr[min_index] = arr[i];

arr[i] = temp;

}

}

 

选择排序。

内循环结束一次，最值出现头角标位置上。代码好记，效率不高

*/

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[i];

     arr[i] = arr[j];

     arr[j] = temp;

     }

     }

    }

} 

 

}

 

 

冒泡排序：容易阅读，但是效率不好，因为堆内存的元素要进行换位。

/*

冒泡排序

内循环结束一次，最值出现头角标位置上。

效率低，因为每一轮循环都要让元素在堆内存中换几次位置

提高效率：通过换角标，每一轮只需要在堆内存中换一次位置

*/

public static void SelectSortArray(int[] arr) 

{ 

    for(int i=0;i<arr.length-1;i++)

    {

     for(int j=0;j<arr.length-1-i;j++)//-i:让每一次比较的元素减少，-1：避免j=4时，j+1就会导致角标越界。

     {

     if(arr[j]>arr[j+1])//每次循环都是相邻元素比较

     {

     int temp = arr[j+1];

     arr[j+1] = arr[j];

     arr[j] = temp;

     }

     }

    }

}

java中已经定义好的Arrays.sort(数组名):排序方式,开发中使用该方法(util包的)。上面的算法只是面试的时候要用到。

 

 

3. 折半查找（二分查找）:

方法1:

与从头到尾查找相比,提高效率，但是必须要保证该数组是有序的数组

/*

折半的第二种方式。

*/

public static int halfSearch_2(int[] arr,int key)

{

int min = 0,max = arr.length-1,mid;

 

while(min<=max)//能折半的条件

{

mid = (max+min)>>1;//相当于除以2

 

if(key>arr[mid])

min = mid + 1;

else if(key<arr[mid])

max = mid - 1;

else

return mid;

}

return -1;

}

/*

折半查找。提高效率，但是必须要保证该数组是有序的数组。

*/

public static int halfSearch(int[] arr,int key)

{

int min,max,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(min>max)

return -1;

mid = (max+min)/2;

}

return mid;

}

 

方法2:

Arrays.binarySearch(数组名,元素);//java提供好的一个进行折半查找的功能。开发时使用这个。

 

 

 

 

 

 

 

 

 

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------