-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
java 基础知识 函数、数组
函数的定义：
1、函数就是定义在类中具有特定功能的一段独立小程序
函数也称为方法
2、函数的格式：
修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，..）
{
执行语句；
return 返回值
}
返回值类型：函数运行后结果的数据类型
参数类型：是形式参数的数据类型
形式参数：是一个变量，用于存储调用函数式传递给函数的实际参数
实际参数：传递给形式参数的具体数值
return：用于结束函数。
返回值：该值会返回给调用者
函数的特点：
定义函数可以将功能代码进行封装
便于对该功能进行复用
函数只有被调用才会执行
函数的出现提高了代码的复用性
对于函数没有具体的返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
注意：函数中只能调用函数，不可以在函数内部定义函数
定义函数时，函数的结果应该返回给调用者，交由调用者处理
函数的应用
/*
需求：调用函数方法，求x+y的和
*/
class
{
public static void main(String[] args)
{
int sum =method(3,9)//定义一个int 型变量sum来存储metohd方法返回的值
System.out.println(sum);
}
public static int method(int x,int y) //由于是整数计算，所以返回值是int型
{
return x+y
}
}
函数的重载
1、重载的概念：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可
2、重载的特点：
与返回值类型无关，只看参数列表
3、重载的好处：
方便阅读，优化了程序设计
4、重载示例：
//返回两个整数的和
int add(int x,int y){return x+y;}
// 返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y；}
5、什么时候用重载
当定义的功能相同，但参与运算的未知内容不同，那么这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。
数组：
数组的定义：
1、概念：同一种类型的集合，其实数组就是一个容器
2、数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素
3、格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度]；
示例：int[] arr = new int[7];有默认初始化化值，都为0；
4、格式2：
元素类型[] 数组名 = new 元素类型[]{元素，元素，..}
int[] arr = new int[]{3,2,3,,7};
int[] arr = {2,7,3,};
数组的内存分配及特点：
1、栈内存
用于存储局部变量，当数据使用完，所占空间会自动释放
2、堆内存
数组和对象通过new建立的实例都存放在堆内存中
每一个实体都有一个内存地址值
实体中的变量都有默认初始化值
实体不在被使用，会在不确定时间内被垃圾回收器回收
3、方法区，本地方法区，寄存器
内存布局图
数组操作常见问题:数组角标越界和空指针异常
数组常见操作：
1.获取数组中的元素 ，通常会用到遍历。
2、数组中有一个属性可以直接获取数组元素个数 。length 使用方式：数组名.length
示例：：
<span style="font-size:14px;">/*
给定一个数组{5,1,6,4,2,8,9}。
获取数组中的最大值，以及最小值
思路：
1：获取最值需进行比较，每一次比较都会有一个较大的值，因为该值不确定。
通过一个变量进行临存
2：让数组中的每一个元素都和这个变量中的值进行比较，如果大于了变量中的
值，就用该变量记录较大值。
3，当所有的元素都比较完成，那么该变量中存储的就是数组的最大值了。
步骤：
1：定义变量。初始化为数组中的任意元素即可
2，通过循环语句对数组进行遍历
3，在遍历过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给
该变量。
需要定义一个功能来完成。以提高复用性
1，明确结果。数组中的最大元素 int
2，未知内容，一个数组。int[]
*/
class ArrayTest
{
public static void main(String[] args)
{
int[]x=new int[]{5,1,6,4,2,8,9};
int max= Max(x);
System.out.println("max="+max);
}
public static int Max(int[] x)
{
int y=x[0];
for(int i=1;i<x.length;i++)
{
if(y<x[i])
y=x[i];
}
return y;
}
}
</span>
选择排序：：
<span style="font-size:14px;">/*打印结果：
对给定数组元素进行排序，由小到大
{3,6,4,8,9,12,10}
思路：1，对数组进行遍历，将第一个元素与数组的其它元素依次对比，把较小的
值存放在数组的第一个元素中
2，从第二个元素开始，向后逐一比较，方法类同1方法
3，这样就必须使用for-for嵌套循环来遍历数组
*/
class SelectDemo
{
public static void main(String[] args)
{
int[] arr = new int[]{3,6,4,8,9,12,10};
method(arr);
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]);
}
}
public static void method(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
}
</span>
冒泡排序法：
<span style="font-size:14px;">/*打印结果
思路：1，数组从左往右相邻的两个元素之间进行逐一比较，比较完后，数组中的最大值在数组的最后一位，下次比较时最后一位元素不用比较，数组比较长度缩短一位。 2，这样就必须使用for-for嵌套循环来遍历数组
*/
class SelectDemo2
{
public static void main(String[] args)
{
int[] arr = new int[]{3,6,4,8,9,12,10};//定义一个数组
method(arr);//调用函数
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)//如果没遍历到最后一个元素打印元素加逗号
System.out.print(arr[x]+",");
else
System.out.println(arr[x]);
}
}
public static void method(int[] arr)//定义冒泡排序函数
{
for(int x=0;x<arr.length;x++)//
{
for(int y=0;y<arr.length-x-1;y++)
{
if(arr[y]>arr[y+1])//两个相邻的元素之间进行比较
{
int temp=arr[y];
arr[y] = arr[y+1];
arr[y+1]=temp;
}
}
}
}
}
</span>
进制转换
<pre name="code" class="java"><span style="font-size:14px;">class ArrayTest
{
public static void main(String[] args)
{
toBin(9);
toHex(60);
}
/*
十进制-->二进制： 原理 ：%2和除2
*/
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer();//定义一个容器来存储每次计算后的值
while(num>0)
{
//System.out.println(num%2)
sb.append(num%2);//往容器中添加值
num =num/2;
}
System.out.println(sb.reverse());//打印反转后的值
}
/*
十进制转16进制。原理：&15 ，右移4位 四位二进制数代表一个十六进制数
*/
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for(int x=0;x<8;x++)//int型整数是32位的二进制数
{
int temp = num & 15;
if(temp>9)
//System.out.println((char)(temp-10+'A'));
sb.append((char)(temp-10+'A'));
else
//System.out.println(temp);
sb.append(temp);
num = num>>>4;//无符号右移4位
}
System.out.println(sb.reverse());
}
}
</span>
打印结果
进制转换优化：查表法
<span style="font-size:14px;">class ArrayTest2打印结果：
{
public static void main(String[] args)
{
toBin(11);
toOctor(60);
toHex(-40);
}
public static void toBin(int num)//十进制转二进制
{
method(num,1,1);
}
public static void toOctor(int num)//十进制转八进制
{
method(num,7,3);
}
public static void toHex(int num)//十进制转16进制
{
method(num,15,4);
}
public static void method(int num,int base ,int offset)//num转换值 base与上的基数 offset偏移量
{
if(num==0)//判断num是否为零，是就直接打印0，程序跳转
{
System.out.println(0);
return;
}
char[] ch = {'0','1','2','3','4','5','6','7','8','9',
'A','B','C','D','E','F',};
char[] arr = new char[32]; //新建一个容量为32位的数组（这样二进制、八进制、十六进制数都能存进来）
int index = arr.length;
while(num!=0)
{
int temp =num & base;
arr[--index] = ch[temp];//计算后的temp值同过查表，将查表后的值存入arr数组的最后一位
num = num>>>offset;//完成后num偏移offset位
}
for(int x=index;x<arr.length;x++)
{
System.out.print(arr[x]);
}
System.out.println();
}
}
</span>
数组中的数组：二维数组[][]
格式1：int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有三个一维数组
每一个一位数组中有2个元素
一维数组的名称分别为 arr[0],arr[1],arr[2]
给第一个一维数组1角标赋值100的写法是：arr[0][1]=78;
格式2：int [] [] arr= new int[3][];
二维数组中有三个数组
每个一维数组都是默认初始化值null
可以对着3个一位数组分别进行初始化：
arr [0] = new int [3];
arr [1] = new int [1];
arr [2] = new int [2];
内存分布图：
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------