关闭

二.Java编程基础(二)

433人阅读 评论(0) 收藏 举报
分类:


Java基础_编程基础(二)


2.8函数

1)函数的定义

 定义:函数就是定义在类中具有特定功能的一段独立的小程序,函数也叫方法。

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

{

执行语句;

return 返回值;

}

 返回值类型:就是函数运行后的结果的数据类型。

 参数类型:形式参数的数据类型

 形式参数是一个变量,实际参数是传递给形参的具体数值,形参就是用于存储调用函数时传递给函数的实际参数

return:用来结束函数

返回值:将函数运算后的结果返回

 

定义函数可以将功能代码进行封装从而进行重复使用,极大的提高了代码的复用性。

需要注意的是,函数只有被调用才会被执行,不能在函数内部定义函数,只能调用函数,定义函数时,函数的结果应该返回给调用者,对于没有具体返回值的情况,返回值类型用一个特殊的关键字void表示,那么如果该函数中的return语句如果在最后一行,就可以省略。

2)函数的应用

定义函数的方法:1.函数是一个独立的功能,那么就先明确这个功能的运算结果是什么;

   2.在定义该功能的过程中是否需要有未知的参数参与运算。

下面是一个实例:


/*
需求:定义一个功能,完成1+1的运算,并将结果返回
思路:1.该功能运算后的结果为一个整数的和;
	  2.该功能在运算过程中不需要有未知内容参与进来运算
*/
class Demo
{
	public static void main(String[] args) 
	{
		getSum();	
	}
	public static int getSum()
	{
		return 1+1;
	}
}

3)函数的重载

为了方便阅读程序,优化程序设计,Java语言提供了函数重载(overload)的功能,重载函数与返回值类型无关,只看参数列表,在同一个类中,可以存在一个以上的同名函数,只要它们的参数个数和参数类型不同即可。

示例说明:

void method(int a,char b)

void method(int a,double b)

void method(char a,int b)

void method(int a,char b,double)

这三个函数都与原函数重载,因为参数类型不相同。

 

2.9内存结构

 2.9.1数组

   定义:数组其实就是一个容器,里面装的是同一种类型数据的集合,数组可以自动给数组中的元素从0开始编号。

格式:1.int[ ] arr = new int[3]

  2.int[ ] arr = new int[]{1,4,6}int[ ] arr = {1,4,6}

定义二位数组的格式:

   1.int[ ] [ ] x;一个int型的二维数组

   2.int [ ] y[ ];一个int型的二位数组

   3.int y[ ] [ ];一个int型的二维数组

   4.int [ ] xy[ ]x是一个一维数组,y是一个二维数组

异常:ArrayIndexOutOfBoundsException:数组角标越界,也就是在操作数组时访问到了数组中不存在的角标;

  NullPointerException:空指针异常,也就是引用了没有任何指向值的情况发生的异常。

下面是一些数组常见操作实例:

1)输出数组中的最大值

  /*
  需求:找出数组中的最大值
  */
  class GetMax
  {
  	public static void main(String[] args) 
  	{
  		//定义一个int型数组
  		int[] arr = {2,3,5,4,6,1};
  		//定义一个int型变量
  		int max = arr[0];
  		for (int x=0;x<arr.length ;x++ )
  		{
  			//遍历数组,如果哪个元素大于max,就将值赋给max
  			if (max<arr[x])
  			{
  				max=arr[x];
  			}
  		}
  		System.out.println("最大值为:"+max);
  	}
  }

2)将数组中的元素进行排序

a.选择排序

  /*
  需求:用选择排序实现将一个数组中的元素从小到大排序
  */
  class XuanZepx 
  {
  	public static void main(String[] args) 
  	{
  		//定义一个int型数组
  		int[] arr ={2,4,3,1,5};
  		//遍历数组,让数组中的一个元素与每个元素比较一次
  		for (int x=0;x<arr.length ;x++ )
  		{
  			for (int y=x+1;y<arr.length ;y++ )
  			{
  				if (arr[x]>arr[y])
  				{
  					int t = arr[x];
  					arr[x] = arr[y];
  					arr[y] = t;
  				}
  			}
  		}
  		//输出排序后的数组元素
  		System.out.println("从小到大排序后为:");
  		for (int x=0;x<arr.length ;x++ )
  		{
  			System.out.println(arr[x]);
  		}
  	}
  }

b.冒泡排序

  /*
  需求:用冒泡排序实现将一个数组中的元素从小到大排序
  */
  class MaoPaopx 
  {
  	public static void main(String[] args) 
  	{
  		//定义一个int型数组
  		int[] arr ={2,4,3,1,5};
  		//遍历数组,让两两相邻元素进行对比
  		for (int x=0;x<arr.length ;x++)
  		{
  			for (int y=0;y<arr.length-1 ;y++ )
  			{
  				if (arr[y]>arr[y+1])
  				{
  					int t=arr[y];
  					arr[y]=arr[y+1];
  					arr[y+1]=t;
  				}
  			}
  		}
  		//输出排序后的数组元素
  		System.out.println("从小到大排序后为:");
  		for (int x=0;x<arr.length ;x++ )
  		{
  			System.out.println(arr[x]);
  		}
  	}
  }

两种排序的异同:

相同:都循环数组元素个数次;

区别:前者为一个元素和每个元素比较换位,后者为两两相邻元素比较换位。

c.折半查找

  /*
  需求:用折半查找的方法找出数组中指定的值在哪个位置
  思路:1.该函数运算后应该返回一个int型值,这个值就是要找的那个元素的角标
  	  2.该函数在运算过程中要传递进来一个数组和一个要找的值。
  */
  class ZheBancz 
  {
  	public static void main(String[] args) 
  	{
  		//定义一个int型数组
  		int[] arr ={2,4,3,1,5};
  		System.out.println(find(arr,3));//打印结果为2
  	}
  	public static int find(int[] arr,int key)
  	{
  		int max,min,mid;
  		max = arr.length-1;
  		min = 0;
  		mid = (max+min)>>1;
  		//当中间值不等于要找的这个值时
  		while (key!=arr[mid])
  		{
  			if (key>min)
  			{
  				min++;
  			}
  			else
  			{
  				max--;
  			}
  			//当min>max时就是在数组中找不到这个值,返回-1
  			if (min>max)
  			{
  				return -1;
  			}
  			mid = (max+min)>>1;
  		}
  		return mid;
  	}
  }

d.十进制转换成二进制

  /*
  需求:用代码实现计算一个十进制数的二进制表现形式
  */
  class  ArrayTest
  {
  	public static void main(String[] args) 
  	{
  		toBin(6);
  	}
  	public static void toBin(int num)
  	{
  		//定义一个二进制的表
  		char[] ch = {'0','1'};
  		//定义一个临时存储容器
  		char[] arr = new char[32];
  		//定义一个操作数组的指针
  		int pos = arr.length;
  		while (num!=0)
  		{
  			int temp = num&1;
  			arr[--pos] = ch[temp];
  			num = num>>>1;
  		}
  		for (int x=pos;x<arr.length ;x++ )
  		{
  			System.out.print(arr[x]);
  		}
  	}
  }

分析:如果将十进制数转换成八进制或者十六进制,也就是查找的字符表、要&的数以及右移的位数不同,那么这个代码的运算部分就可以被重用,来实现十进制向其它进制的转换,代码如下:

  /*
  需求:定义一个可以将一个十进制数转换成二进制、八进制或十六进制形式
  */
  class ArrayTest2 
  {
  	public static void main(String[] args) 
  	{
  		toBin(6);//转换成二进制
  		toOct(30);//转换成八进制
  		toHex(60);//转换成十六进制
  	}
  	public static void method(int num,int x,int y)
  	{
  		//定义一个十六进制的表
  		char[] ch = {'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&x;
  			arr[--pos]=ch[temp];
  			num = num>>>y;
  		}
  		for (int i=pos;i<arr.length ;i++ )
  		{
  			System.out.print(arr[i]);
  		}
  		System.out.println();
  	}
  	public static void toBin(int num)
  	{
  		method(num,1,1);
  	}
  	public static void toOct(int num)
  	{
  		method(num,7,3);
  	}
  	public static void toHex(int num)
  	{
  		method(num,15,4);
  	}
  }

2.9.2内存结构

  Java程序在运行时,都需要在内存中分配空间,为了提高运行效率,又将这些空间进行了划分,每一片区域都有特定的数据处理方式和内存管理方式,例如:栈、堆、方法区等等。这里先进行堆和栈的介绍:

栈内存:用于存储局部变量,当数据使用完毕,所占空间会立即释放;

堆内存:通过new建立的实例对象都存放堆内存中,而数组也是通过new建立,所以也存放在堆内存中,每一个实例对象都有内存地址值,当实例不再被使用时,会在不确定的时间内被JAVA垃圾回收器回收,Java的垃圾回收机制也是优于C++的地方。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场