黑马程序员——java语言基本组成3

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

< 今日心情 >今天太阳比我起得早o(╯□╰)o

一、 函数

1.函数的定义

函数就是定义在类中的具有特定功能的一段独立小程序。

函数也称为方法。

函数的格式：

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

执行语句;

return 返回值;

}

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

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

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

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

return：用于结束函数。
返回值：该值会返回给调用者。

其实，函数就是将一部分代码摘取出来放到一处特殊的空间中，只有被调用的时候才会运行。

当调用者需要这部分代码处理一些它不知道的数据时，就需要传值给它，此时它就需要有被传值的功能（就好比聋子会说话却无法回答别人的问题一样）

当调用者需要知道这部分代码最后处理的结果时，就需要它返回（return）一个结果，所以函数需要一个返回值类型。（void代表不需要返回）

那么如何定义一个函数呢？
1，既然函数是一个独立的功能，那么该功能的运算结果是什么先明确

因为这是在明确函数的返回值类型。

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

因为是在明确函数的参数列表（参数的类型和参数的个数）。

示例代码：

class FunctionDemo
{
	public static void main(String[] args) 
	{
		//打印从1到10的偶数
		for(int i=1;i<=10;i++)
		{
			if(chu2(i))//如果i能被2整除，结果为true，否则为false
				System.out.println(i);//条件成立，这个数被打印
		}
	}
	public static boolean chu2(int x)//定义一个函数，判断一个数能否被2整除
	{
		if(x%2==0)//对2取模为0，则这个数能被2整除
		{
			return true; //返回“真”，函数停止
		}
		return false; //前面判断不成立，则这个数不能被2整除。返回“假”
	}
}

将判断一个整数是否能被2整除的代码封装当一个函数中后，只要遇到这种判断，调用这个函数就可以了，不需要使用者会计算，可以直接拿来使用

2.函数的特点：

定义函数可以将功能代码进行封装；

函数只有被调用才会被执行；

函数的出现提高了代码的复用性；

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

3.函数的重载

将判断一个整数能否被2整除进行封装后，我们发现当我们判断的数字是比int更大的long型数据时，jvm会报错。

这个时候，不需要再重新定义一个函数，我们可以这么做：

class FunctionDemo
{
	public static void main(String[] args) 
	{
		/*
		//打印从1到10的偶数
		for(int i=1;i<=10;i++)
		{
			if(chu2(i))//如果i能被2整除，结果为true，否则为false
				System.out.println(i);//条件成立，这个数被打印
		}
		*/
		long x=100;
		if(chu2(x))
			System.out.println(x);
	}
	public static boolean chu2(int x)//定义一个函数，判断一个数能否被2整除
	{
		if(x%2==0)//对2取模为0，则这个数能被2整除
		{
			return true; //返回“真”，函数停止
		}
		return false; //前面判断不成立，则这个数不能被2整除。返回“假”
	}
	public static boolean chu2(long x)
	{
		if(x%2==0)
		{
			return true; 
		}
		return false; 
	}
}

这个就是函数的重载。

函数重载的概念：

在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

重载的特点：

与返回值类型无关，只看参数列表。

重载的好处：

方便于阅读，优化了程序设计。

二、数组

1.数组的定义

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

数组也可以看成可以存储许多小盒子的大盒子。

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

数组中每一个元素都有对应的下角标。

格式：

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

示例：int[] arr = new int[5];

2.元素类型[] 数组名= new 元素类型[]{元素，元素，……};

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};

2.数组内存中的结构

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

数组在内存中的结构如图：

栈内存：

用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：

数组和对象，通过new建立的实例都存放在堆内存中；

每一个实体都有内存地址值；

实体中的变量都有默认初始化值；
实体不在被使用，会在不确定的时间内被垃圾回收器回收。

方法区，本地方法区，寄存器

数组做形参和整形变量做形参的区别：

class Test 
{
	public static void main(String[] args) 
	{
		//System.out.println("Hello World!");
		int x=12,y=33;
		int[] n={12,33};
		System.out.println("交换前：x="+x+"y="+y);
		System.out.println("交换前：n[0]="+n[0]+"n[1]="+n[1]);
		change(x,y);
		change(n,0,1);
		System.out.println("交换后：x="+x+"y="+y);
		System.out.println("交换后：n[0]="+n[0]+"n[1]="+n[1]);
	}

	public static void change(int x,int y)
	{
		int z=0;
		z=x;
		x=y;
		y=z;
		System.out.println("交换：x="+x+"y="+y);
	}
	public static void change(int[] n,int i,int j)
	{
		int z=0;
		z=n[i];
		n[i]=n[j];
		n[j]=z;
		System.out.println("交换：n["+i+"]="+n[i]+"n["+j+"]="+n[j]);
	}
}

chang是两个整数交换的重载函数。

通过比较结果发现，int型变量做形参时，虽然两个数做了交换动作，但是结果没有发生变化。数组做形参时即发生了交换动作，也改变了结果。

这是因为，change(int x,int y)中的x，y是在栈内存中开辟了新空间，main中的x，y的数据复制给了新空间供给change函数操作，无论操作结果如何，main中的x，y都不受影响。

而change(int[] n,int i,int j)中，n也是在栈中开辟的新空间，但是调用方法时，是把main中n的地址给了新空间的n，change根据地址操作了堆内存中具体的数据。

3.数组的应用

class ArraySoft 
{
	/*
 * 选择排序
 * */
	public static void softNum(int[] a)
	{
		for(int i=0;i
      
      
       
       a[j])//与前一个位置数据比较，前一个数据较大时
				{
					swap(a,j-1,j);//两者交换
				}
			}//第一次遍历能将最大的排到最后，但是不能保证前排的顺序，所以需要遍历多次
			//第二次遍历又能冒出一个较大的数，但是肯定比前一次冒出的小，所以不需要与最后的值比较
			//以此类推，每次遍历的长度都在变短，而且是从末尾每次减小一个长度
		}
	}
//	交换位置
	public static void swap(int[] a,int i,int j)
	{
		a[i]=a[i]^a[j];
		a[j]=a[i]^a[j];
		a[i]=a[i]^a[j];
	}
}

      
      

3.多维数组

多维数组其实就是在数组中存储新数组的地址。

格式：

1：int[][] arr = new int[3][2];

2：int[][] arr = new int[3][];

arr[0]=new int[3];

arr[1]=new int[1];

arr[2]=new int[2];

赋值：

arr[0][0]=1;

注：给数组赋值脚标必须小于其所在维的长度。如arr是int[3][2]数组，则第一个脚标必须小于3大于等于0，第二个脚标必须小于2大于等于0。