JAVA基础－程序的基本结构、函数与数组

JAVA程序的结构包括顺序结构、选择结构和循环结构三种。
1、顺序结构
在顺序结构中，程序是由上而下逐行执行的，一条语句执行完之后才继续执行下一条语句，一直到程序的末尾。顺序结构是程序设计中最常用的结构，因为大部分程序基本上都是由上而下的流程来设计。顺序结构的流程如下图：



2、选择结构
选择结构首先要依据判断条件的成立与否，再决定要执行哪些语。选择结构包括if语句和switch语句。其流程如下图：



 
2.1、if语句
当需要根据判断条件的成立与否来执行不同的语句时，一般使用if语句。If语句有三种格式：
1)  if(判断条件)
              {
                       执行语句；
               }
         2)  if(判断条件)
              {
                       执行语句；
              }
              else
              {
                        执行语句；
              }
          3)  if(判断条件)
              {
                       执行语句；
              }
               else  if (判断条件)
             {
                      执行语句 ； 
             }
              ……
             else
            {
                      执行语句；
            }
2.2、switch语句
switch语句可以将多选一的情况简化，使程序简洁易懂，当要在多个选择条件中找到并执行一个符合判断条件的语句时，一般使用switch语句。Switch语句有如下格式：
switch(表达式)
                {
                       case取值1:
                             执行语句；
                              break；
                       case取值2:
                             执行语句；
                              break；
                       …...
                      default:
                             执行语句；
                             break；
                }
switch语句需要先计算括号中表达式的结果，根据表达式的值是否与case后面的值相等而执行相应case所包含的语句，若无符合的case，则执行default所包含的语句。Switch语句有如下特点：
（1）：选择的类型只有4种：byte,short,int,char
   （2）：case之间与default没有顺序，先执行第一个case，没有匹配的case执行default
   （3）：结束语句有两种情况：遇到break或执行到语句结束
   （4）：如果匹配的case或default没有break，程序会继续向下执行，运行可以执行的语句，直到遇到break或语句结尾。
3、循环结构
循环结构根据判断条件的成立与否，重复执行循环体内的语句。循环结构包括while循环、do  while循环和for循环。循环结构流程如下图：



3.1、while循环
当事先不知道循环体该执行多少次时，一般用到while循环，在while循环中，只有一个判断条件，当判断条件为真时，循环体就会重复执行，直到判断条件为假时才会跳出while循环。为了使程序最终会跳出循环，必须在进入while循环前定义循环控制变量，并在循环体内有对循环变量进行更改的语句以使循环的判断条件为假。While循环格式如下：
             while(条件表达式)
             {
                 执行语句；
             }
其执行流程如下图：



 
3.2、do while循环
do while循环与while循环一样也是在未知循环体执行次数的时候使用，而do while与while循环不同的是，while循环在进入循环体前会先判断循环条件的真假再决定是否执行循环主体，而do while循环是无论循环条件是否为真都会先执行一次循环体，然后再判断条件的真假，即do while循环至少会执行一次循环主体。do while循环的格式如下：
  do
             {
                 执行语句；
             }while(条件表达式);
do while循环流程如下：



 
3.3、for循环
当明确地知道循环要执行的次数时，可以使用for循环。for循环与while循环的区别在于，可以在for循环中定义用于控制循环增量，且该变量只在for语句内有效，for语句执行完毕，该变量在内存中被释放。for循环有如下格式：
            for(初始化表达式；循环条件表达式；循环后的操作表达式)
            {
                 执行语句；
            }
其循环流程如下：
 


 
3.4、循环嵌套
当循环语句中包含有其他的循环语句时，就称为循环嵌套。
3.5、其他流程控制语句
主要包括break语句和continue语句。
（1）break语句：可以用于选择结构和循环结构。可以强迫程序跳出当前循环。
   （2）continue语句：用于循环结构。可以强迫程序跳回到循环的开始处继续运行。
需要注意：
（1）这两个语句离开应用范围，存在是没有意义的。
（2）这两个语句只能单独存在，下面不可以有语句，因为执行不到。
（3）continue语句是结束本次循环继续下次循环。
（4）标号的出现可以让这两个语句作用于指定的范围。

4、函数的定义
函数就是定义在类中的具有特定功能的一段独立小程序，也称为方法。当程序中某部分代码出现了重复时，为了提高代码的复用性，对代码进行抽取后将这个部分定义成一个独立的功能，以方便日后使用。Java中对功能的定义是通过函数的形式来体现的。
5、函数的格式
    修饰符  返回值类型  函数名（参数类型 形式参数1，参数类型 形式参数2，）
    {
         执行语句；
         return 返回值；
    }
说明：
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数是传递给函数的实际参数。
return：用于结束函数。
返回值：该值会返回给调用者。
6、函数的特点
（1）定义函数可以将功能代码进行封装。
（2）便于对功能进行复用。
（3）函数只有被调用才会被执行。
（4）函数的出现提高了代码的复用性。
（5）对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
注意：
（1）函数中只能调用函数，不可以函数内部定义函数。
（2）定义函数时，函数的结果应该返回给调用者，交由调用者处理。
7、如何定义一个函数
（1）既然函数是一个独立的功能，那么先明确该功能的运算结果，即明确函数的返回值类型。
（2）再明确在定义该功能的过程中是否需要未知的内容参与运算，即明确函数的参数列表（参数的类型和参数的个数）。
8、一个打印九九乘法表的函数示例



程序运行结果：



9、函数的重载
9.1、重载的概念
在同一类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
9.2、重载的特点
函数的重载与返回值类型无关，只看函数的参数列表。
9.3、重载的好处
方便于阅读，优化了程序设计。
9.4、示例
intadd(int x,int y){return x+y;} //返回两个整数的和
intadd(int x,int y,int z){return x+y+z} //返回三个整数的和
doubleadd(double x,double y){return x+y} //返回两个小数的和

10、数组的定义
10.1、概念：数组是同一种类型数据的集合，其实数组就是一个容器。
10.2、数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
11、数组的格式
11.1、格式一：
元素类型[]  数组名＝new  元素类型[元素个数或数组长度]
11.2、格式二：
元素类型[]  数组名＝new  元素类型[]{元素，元素，……}
12、内存结构
Java程序在运行时，需要在内存中分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每片区域都有特定的处理数据的方式和内存管理方式。
12.1、栈内存
栈内存用于存储局部变量，当数据使用完，所占空间会自动释放。
12.2、堆内存
（1）数组和对象，通过new建立的实例对象都存放在堆内存中。
（2）每一个实体都有内存地址。
（3）实体中的变量都有默认初始化值。
（4）实体不在被使用，会在不确定的时间内被垃圾回收器回收。
12.3、数组在内存中的存储
当声明一个数组时，在栈内存中为数组名开辟一个内存空间，在堆内存中为数组数据开辟内存空间存储数组数据，而将数据在堆内存中的内存地址值赋于数组名，即数组名不直接存储数据中的值，而是存储数组在堆内存中的地址值，数组名通过数组在堆内存中的地址值去引用数组的值。所以数组属于引用类型的实体。
13、数组的异常操作
（1）操作数组时，访问到了数组中不存在的角标时，发生ArrayIndexOutOfBoundsException异常
（2）当引用没有任何指向值为null的情况，该引用还在用于操作实体，发生NullPointerException空指针异常。
14、数组的应用
14.1、遍历
通常会用到遍历来获取数组中的元素。可以通过数组中的length属性来获取数组中的元素个数，使用方式：数组名.length。
数组遍历示例（求一个数组中的最大值）：



运行结果：



14.2、排序
（1）选择排序：先找到一个数列中的最值，然后将它放在最前面，再在剩下的数中找到最值，以此类推。
（2）冒泡排序：重复地比较数列中相邻的两个数，如果不符合排序要求则将其换位，直到得到按要求排序的数列。
选择排序冒泡排序示例：

public classArrayDemo2
{
       public static void main(String[] args)
       {
              int[]arr={5,4,2,6,9,8,7};
              selectSort(arr);
              System.out.print("selectSort:");
              arrayPrint(arr);
              bubbleSort(arr);
              System.out.print("bubbleSort:");
              arrayPrint(arr);
       }
    //定义选择排序方法
       public static void selectSort(int[] arr)
       {
              for(int i=0;i<arr.length-1;i++)
              {
                     for(int j=i+1;j<arr.length;j++)
                     {
                            if(arr[i]>arr[j])
                            {
                                   int temp=arr[i];
                                   arr[i]=arr[j];
                                   arr[j]=temp;
                            }
                     }
              }
       }
           //定义冒泡排序方法
       public static void bubbleSort(int[] arr)
       {
              for(int i=0;i<arr.length-1;i++)
              {
                     for(int j=0;j<arr.length-i-1;j++)
                     {
                            if(arr[j]>arr[j+1])
                            {
                                   int temp=arr[j];
                                   arr[j]=arr[j+1];
                                   arr[j+1]=temp;
                            }
                     }
              }
       }
       //定义打印数组方法
       public static void arrayPrint(int[] arr)
       {
              System.out.print("[");
              for(int i=0;i<arr.length;i++)
              {
                     if(i!=arr.length-1)
                            System.out.print(arr[i]+", ");
                     else
                            System.out.println(arr[i]+"]");

              }
       }
a9b0

}

运行结果：



14.3、查找
对于一个有序数组，用折半查找效率更高
折半查找示例：

public class ArrayDemo4

{

         publicstatic void main(String[] args)

         {

                   int[]arr={2,4,5,6,8,9};

                   intindex=halfSearch(arr,6);

                   System.out.println("index="+index);

         }

         //定义折半查找方法

         publicstatic int halfSearch(int[] arr,int key)

         {

                   intmin=0,max=arr.length,mid;

                   while(min<=max)

                   {

                            mid=(max+min)>>1;

                            if(key>arr[mid])

                                     min=mid+1;

                            elseif(key<arr[mid])

                                     max=mid-1;

                            else

                                     returnmid;

                   }

                   return-1;

         }

}

运行结果：



15、数组中的数组（二维数组）
15.1、格式
（1）元素类型[][] 数组名＝new 元素类型[一维数组长度][二维数组长度]
示例：
int[][]  arr = new int[3][2];
说明：
－定义了名称为arr的二维数组。
－二维数组中的3个一维数组。
－每一个一维数组中有2个元素。
－一维数组的名称分别为arr[0]、arr[1]、arr[2]。
－给第一个一维数组1角标位赋值为78写法是：arr[0][1]=78。
（2）元素类型[][] 数组名＝new 元素类型[一维数组长度][]
示例：
int[][]  arr=new int[3][]
说明：
－二维数组中有3个一维数组。
－每个一维数组都有默认初始化值null。
－可以对这3个一维数组分别进行初始化：
arr[0]=newint[3];
arr[1]=newint[1];
arr[2]=newint[2];