---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ---------------------
一、程序流程控制
1.判断结构
判断结构是if语句，它有三种结构
1.如果条件为真，则执行{}中的语句，否则不执行。
2.如果条件为真，则执行{}中的语句，否则执行else{}里面的代码。
3.如果条件为真，则执行{}中的语句然后结束这个结构，否则判断是否满足第二个if表达式，如果条件为真，则执行{}中的语句然后结束这个结构，否则、、、以此类推。
格式:
1.
if(条件表达式)
{
执行语句;
}
2.
if(条件表达式)
{
执行语句;
}else
{
执行语句;
}
3.
if(条件表达式)
{
执行语句;
}else if(条件表达式)
{
执行语句;
}
...
else
{
执行语句;
}
2.选择结构
switch特点：
1.表达式不可为布尔型表达式
2.case的取值只能为byte、short、int、char以及字符串、枚举等六种类型，
注：在JDK1.5中还因为出现了枚举，也可以在switch中应用此类型。
3.case与default没有必然的顺序，要先执行case，执行从上向下执行，没有找到匹配的case执行default。
4.结束switch语句的两种情况：遇到break或者执行到switch结尾结束。
5.如果没有break，每个case都会判断一次，如果不符合表达式的值，则继续判断下面的case取值，如果满足表达式的值，执行完当前语句后，会继续判断并执行后面全部的语句，直到switch语句结束。
格式：
switch(表达式)
{
case 取值1:
执行语句;
break;
case 取值2:
执行语句;
break;
......
default:
执行语句;
break;
}
if和switch的选择：
如果判断的具体数值不多，而是符合byte short int char 这湿种类型。
虽然两个语句都可以使用，建议使用switch语句，因为效率稍高。
其他情况：对区间判断，对结果为boolean类型的判断，使用if，if的使用范围更广
示例：
class DemoSwitch
{
public static void main(String[] args)
{
int x = 5;
switch (x)
{
case 3:
case 4:
case 5:
System.out.println(x+"夏季");
break;
case 6:
case 7:
case 8:
System.out.println(x+"秋季");
break;
case 9:
case 10:
case 11:
System.out.println(x+"冬季");
break;
case 12:
case 1:
case 2:
System.out.println(x+"春季");
break;
default :
System.out.println(x+"错误的月份");
break;
}
}
}
3.循环结构：
当要对某些语句执行很多次时，就使用循环结构。
代表语句：while 、do while 、for
while:先判断条件，只有条件满足才执行循环体。
do while：先执行循环体，在判断条件，条件满足，在继续循环。
简单一句话：do while：无论条件是否满足循环体至少执行一次。
for:变量有自己的作用域对于for来讲；如果将用于控制循环的增量定义在for语句中。那么该变量在for语句内有效。for语句执行完毕，该变量在内存中被释放。
for和while可以进行互换，如果需要定义循环增量，又for更为合适
while语句格式:
while(条件表达式)
{
执行语句;
}
do while语句格式：
do
{
执行语句;
}
while(条件表达式)
for语句格式:
for(初始化表达式;循环条件表达式;循环后的操作表达式)
{
执行语句;
}
无限循环的最简单表现形式。
for(;;){}
while(true){}
二、函数
1.函数的概述：
函数也称为方法，是定义在类中的具有特定功能的一段独立的小程序。函数可以实现某些特定的功能。
定义函数的体现：
在写程序时，发现运算中获取不同数据的运算结果，总是重复使用一些代码，为了提高代码的复用性，就对代码进行了抽取。
将这个抽取的部分定义为一个独立的功能，方便日后重复使用。这就是函数的体现形式。
函数的格式：
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,......)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型
参数类型：是形式参数的数据类型，就是传入的数据的类型
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数
实际参数：传递给形式参数的具体数值
return：用于结束函数运行的语句，表示函数执行完毕
返回值 ：该值将返回给调用者，即函数实现功能需要获得的数据。
说明：当函数运行完，没有具体的返回值，这时的返回值类型可以用一个特殊的关键字来表示，即void，它代表的是函数没有具体的返回值的情况。此时，函数中的return可以省略不写。
何时定义函数：
首先要明确函数的功能，这个功能实现的运算结果是什么.其实就是在明确返回值类型
在定义函数功能的过程中需要明确是否含有位置内容参与运算.其实就是在明确函数的参数列表（参数类型和参数个数）
示例：
/*
需求：打印a ~ b 中每个数与c的乘积
分析：明确功能的结果：打印运算结果，返回类型无，为void
在实现功能的过程中是否有位置内容：有，int型的a、b和c
*/
public static void Chengji(int a,int b,int c)
{
int j = 1;
for(a=1;a<=b;a++)
{
int m = c*a;
System.out.print(m + "\t");
if(j == a/10)//十个数换一次行
{
j++;
System.out.println(" ");
}
}
}
2.函数的特点：
1：定义函数可以将功能代码进行封装，体现了java的封装性
2：定义函数可以提高代码的复用性，便于使用，可对功能进行复用
3：函数需要被调用才能被执行，否则就是一段代码
4：无返回值类型的函数用void修饰，则可以省略函数中的return
5：函数中不可以定义函数（内部类除外），但函数间可以相互调用。
3.函数的重载：
1：定义：在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。
2：特点：与返回值类型无关，只看参数列表。
3：好处：方便与阅读，优化了程序设计。
4：重载解析：编译器对于重载的方法会进行选择，，匹配出相应的方法，如果编译器找不到匹配的参数，或者找出了多个可能的匹配函数，那么就会产生编译错误。
示例：
//定义函数，求两个数的和
public static int add(int a,int b)
{
return a+b;
}
//定义函数，求三个数的和
public static int addT(int a,int b,int c)
{
return add(a,b)+c;
}
三、数组
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.数组赋值：
数组的初始化
对于上面两种格式的赋值：
第一种是隐式初始化，每个元素的值都为相对应的各类型的初始化值，具体看数据类型的总结。
第二种是显式初始化，每个元素都已经被赋予初值。
还可以定义匿名数组：
new int[]{3,2,6,7,9,1,4}
数组的间的赋值：
java中，可以将一个数组的变量的引用值赋给另一个数组的变量。如：String[] b = a;
例子：打印数组中的元素。元素间用逗号隔开。
class ArrDame
{
public static void main(String[] args)
{
int[] i = {3,6,7,82,3,5,4};
printArray(i);
}
public static void printArray(int[] 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]);
}
}
}
4.数组的排序与查找：
/*给定一个数组{5,1,6,4,2,8,9}。
获取数组中的最大值，以及最小值。*
/
例子：获取数组最大值
class ArrayTest {/*获取数组中的最大值。思路：1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。通过一个变量进行临储。2，让数组中的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值，就用该该变量记录较大值。3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。步骤：1，定义变量。初始化为数组中任意一个元素即可。2，通过循环语句对数组进行遍历。3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；需要定义一个功能来完成。以便提高复用性。1，明确结果，数组中的最大元素 int。、2，未知内容：一个数组。int[]*/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;}/*获取最大值的另一种方式。可不可以将临时变量初始化为0呢？可以。这种方式，其实是在初始化为数组中任意一个角标。*/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];}/*获取最小值。*/public static int getMin(int[] arr){int min = 0;for(int x=1; x<arr.length; x++){//比较两个元素if(arr[x]<arr[min])min = x;}return arr[min];}//获取double类型数组的最大值。因为功能一致，所以定义相同函数名称。以重载形式存在。public static double getMax(double[] arr){int max = 0;for(int x=1; x<arr.length; x++){//比较两个元素if(arr[x]>arr[max])max = x;}return arr[max];}public static void main(String[] args){int[] arr ={5,1,6,4,2,8,9};int max = getMax_2(arr);int min = getMin(arr);System.out.println("max="+max);System.out.println("min="+min);double[] arr2 ={5.4,1.3,6.3,5.2,2,8,9.12};double max2 = getMax(arr2);System.out.println("max="+max2);}}
数组的排序：
例子：
class ArrayText
{
//选择排序
public static void selectSort(int[] arr)
{
for (int i=0;i<arr.length;i++)
{
//i=j，每比较一轮就减少一个数，比较后，再用第二个数获得后面的最小值
for (int x=i+1;x<arr.length;x++)
{
//换值
if (arr[i]>arr[x])
{
int temp = 0;
temp = arr[i];
arr[i] = arr[x];
arr[x] = temp;
}
}
}
}
//冒泡排序
public static void bubbleSort(int[] arr)
{
for (int i=0;i<arr.length-1;i++)
{
for (int x=0;x<arr.length-i-1;x++)//-i:让每一次比较的元素减少。-1：避免角标越界
{
if (arr[x]>arr[x+1])//若改成<是从大到小排序
{
int temp = arr[x];
arr[x] = arr[x+1];
arr[x+1] = temp;
}
}
}
}
//打印数组
public static void printArray(int[] arr)
{
System.out.print("{");
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 main(String [] args)
{
int[] arr0 = {5,2,4,8,6,1,9};
int[] arr1 = {5,2,5,8,6,1,9};
//选择排序前
printArray(arr0)
selectSort(arr0);
//选择排序后
printArray(arr0)
//冒泡排序前
printArray(arr1)
bubbleSort(arr1);
//冒泡排序后
printArray(arr1)
}
}
数组的查找操作：
class ArrayTest4
{
public static void main(String [] args)
{
int[] arr = {1,6,11,2,8,5,3,13};
int index = getIndex(arr,3);
System.out.println("index=" + index);
int[] arr1 = {2,3,4,6,7,9};
index = halfSearch(arr1,3);
System.out.println("index=" + index);
}
//方法一：遍历每一个元素查找
public static int getIndex(int[] arr,int key)
{
for(int i=0;i<arr.length;i++)
{
if(arr[i] == key)
{
return i;
}
}
return -1;
}
/*方法二：折半，前提是数组是按大小顺序排列好的，
用查找的值和中间值比较，大则和下一半中间值比依次，小则和上一半中间值比，找到则返回。
小值的编号在左移或大值的编号在右移。要判断是否大小值的编号相遇，仍若未找到，则不再循环，返回-1
*/
public static int halfSearch(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (min + max)/2;
//循环，查找中间值与要查找的值比较
while(key != arr[mid])
{
if (key > arr[mid])
min = mid +1;
else
max = mid - 1;
if (min > max)
return -1;
mid = (min + max)/2;
}
return mid;
}
//方法三：折半第二种
//while的条件改变
public static int halfSearch_2(int[] arr,int key)
{
int min = 0,max = arr.length-1,mid;
//循环，查找中间值与要查找的值比较
while(min <= max)
{
mid = (min + max)>>1;
if (key > arr[mid])
min = mid +1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
}
例子：进制转换
class ArrayTest5
{
public static void main(String [] args)
{
toBin(34);
toHex(34);
toHex_2(60);
toBin_2(60);
}
//十进制-->二进制
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer();
while(num>0)
{
sb.append(num%2);
num = num/2;
}
System.out.println(sb.reverse());
}
//十进制-->十六进制
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for(int x = 0; x<8;x++)
{
int temp = num & 15;
if(temp>9)
sb.append((char)(temp-10+'A'));
else
sb.append(temp);
num = num>>>4;
}
System.out.println(sb.reverse());
}
//十进制-->十六进制 查表法
public static void toHex_2(int num)
{
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;
}
for(int x = pos ; x<arr.length;x++)
{
System.out.print(arr[x]);
}
System.out.println();
}
//十进制转二进制 查表法
public static void toBin_2(int num)
{
//定义二进制的表
char[] chs = {'0','1'};
//定义一个临时存储的容器
char[] arr = new char[32];
//定义一个操作数组的指针
int pos = arr.length;
while(num!=0)
{
int temp = num & 1;
arr[--pos] = chs [temp];
num = num >>> 1;
}
for(int x=pos;x<arr.length;x++)
{
System.out.print(arr[x]);
}
System.out.println();
}
}
//进制转换优化
class ArrayTest6
{
public static void main(String[] args)
{
toBin(60);
toOctal(60);
toHex(60);
}
//十进制-->二进制
public static void toBin(int num)
{
trans(num,1,1);
}
//十进制-->八进制
public static void toOctal(int num)
{
trans(num,7,3);
}
//十进制-->十六进制
public static void toHex(int num)
{
trans(num,15,4);
}
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();
}
}
多维数组：也称数组中的数组
这里主要总结一下二维数组：
格式：
格式一：int[][] arr = new int[2][3];
定义了一个名为arr的数组，数组中有2个一维数组，每个一维数组中含有3个元素。
可以对其赋值：arr[0][0] = 3;即对第一个一位数组的第一个元素赋值。
格式二：int[][] arr = new int[3][];
此二维数组中含有3个一维数组，每个一维数组的默认初始化值都为null，每个一维数组中的元素值都为0；可对每个元素赋值，如：
arr[0] = new int[3];
arr[1] = new int[2];
arr[2] = new int[1];
格式三：
显式初始化二维数组：int[][] arr = {{1,5,7},{4,8},{3,9,20,12}}
二维数组中的第一维数组的长度：arr[0].length//为3
----------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com