格式：
swithch（表达式）{
case 值1:
语句;
break;
case 值2:
语句2;
break;
....
default:
语句n;
break;
}
switch后的表达式的数据类型可以是
byte short int long
JDK5以后可以是枚举类型
JDK7以后可以是String类型
case后面的值只能是常量，不能是变量
break：跳出选择结构
defaul的位置可以在switch结构语句体中的任何位置，需要注意的是default语句不在switch结构末尾时，必须要添加break语句；
switch可以利用case的穿透，来实现某种功能
例如：3，4，5月均是春季
完整结构：
case 3：
System.out.println("春季");
break；
case 4：
System.out.println("春季");
break；
case 5：
System.out.println("春季");
break；
可以简化为：
case 3：
case 4：
case 5：
System.out.println("春季");
break；
循环结构语句——for
格式：
for(初始化值;条件判断语句;步长语句){
循环体语句;
}
执行过程：先进行初始化，判断条件是否成立，成立则执行循环体语句，然后执行步长语句，在进行判断，如果不成立则循环体结束
for循环的嵌套：
外层控制行，内层控制列
例如：打印99乘法表
public class summary {
public static void main(String[] args) {
for(int i = 1 ; i < 10 ; i++){
for(int j = 1 ; j <= i ;j++){
System.out.print(j+"*"+i+"="+i*j+"\t");
}
System.out.println();
}
}
}
public class High {
public static void main(String[] args) {
int count = 0;
double h = 0.01;
while(h < 8848){
h *= 2;
count++;
}
System.out.println("折叠了"+count+"次");
}
}
方法名相同，但是方法的参数类型和参数个数不同的这类方法称为方法的重载
eg:
public static void sum(){}
public static void sum(int a){}
public static void sum(double b){}
public static void sum(int a ,int b){}
public static void sum(int a,double b){}
这些都是方法重载
数组
数组由相同数据类型的多个数据组成
数组的定义
格式：
数据类型[] 数组名称(推荐使用)
数据类型 数组名称[]
数组的初始化
动态初始化：
数据类型[] 数组名 = new 数据类型[数组长度];
eg:int[] arr = new int[3];
静态初始化：
数据类型[] 数组名 = new 数据类型[]{值1,值2,...}
eg:int[] arr = new int[]{1,2,3,4};
静态初始化的简写格式：
数据类型[] 数组名 = {值1,值2,...};
eg:int[] arr = {1,2,3,4};
例如：
int[] arr == new int[3];
首先在方法区运行字节码文件，加载主方法，进栈内存中创建int[] arr，然后在堆内存中创建new int[3]对象，将新创建的对象的堆内存空间地址赋给栈内存中的arr，并且对象一旦创建，arr链接的堆内存地址就固定不变了
数组一旦创建，系统会自动为新创建的数组对象进行初始化
数组的简单应用
数组的遍历
public class PrintArray {
public static void main(String[] args) {
int[] arr = {15,25,31,54,75};
printArray(arr);
int max = maxArray(arr);
System.out.println("最大值是："+max);
int min = minArray(arr);
System.out.println("最小值是："+min);
}
public static void printArray(int[] arr){
System.out.print("[");
for(int i = 0 ; i < arr.length; i++ ){
if ( i == arr.length-1){
System.out.println(arr[i]+"]");
}else{
System.out.print(arr[i]+", ");
}
}
}
}
结果：
[15, 25, 31, 54, 75]
数组的最值
public class PrintArray {
public static void main(String[] args) {
int[] arr = {15,25,31,54,75};
printArray(arr);
int max = maxArray(arr);
System.out.println("最大值是："+max);
int min = minArray(arr);
System.out.println("最小值是："+min);
}
public static void printArray(int[] arr){
System.out.print("[");
for(int i = 0 ; i < arr.length; i++ ){
if ( i == arr.length-1){
System.out.println(arr[i]+"]");
}else{
System.out.print(arr[i]+", ");
}
}
}
public static int maxArray(int[] arr){
int max = arr[0];
for(int i = 1;i < arr.length; i++){
if(max < arr[i]){
max = arr[i];
}
}
return max;
}
public static int minArray(int[] arr){
int min = arr[0];
for(int i = 1;i < arr.length; i++){
if(min > arr[i]){
min = arr[i];
}
}
return min;
}
}
结果：
[15, 25, 31, 54, 75]
最大值是：75
最小值是：15
数组内元素的查找
public class PrintArray {
public static void main(String[] args) {
int[] arr = {15,25,31,54,75};
int index = lookArray(arr,54);
System.out.println("元素54对应的数组的索引值是："+index);
}
public static int lookArray(int[] arr,int num){
int index = -1;
for(int i = 0 ; i < arr.length; i++ ){
if(num == arr[i]){
index = i;
}
}
return index;
}
}
结果为：
元素54对应的数组的索引值是：3
数组排序——冒泡排序
特点：相邻两元素之间进行比较，较大的后移
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {95,25,12,26,8};
printArray(arr);
bubbleSort(arr);
printArray(arr);
}
public static void printArray(int[] arr){
System.out.print("[");
for(int i = 0 ; i < arr.length; i++ ){
if ( i == arr.length-1){
System.out.println(arr[i]+"]");
}else{
System.out.print(arr[i]+", ");
}
}
}
public static void bubbleSort(int[] arr){
for(int i = 0 ; i < arr.length-1; i ++){
for( int j = 0; j < arr.length - 1 -i; j++){
if(arr[j] > arr[j+1]){
int temp =arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}