《java入门如此简单》——语句，函数和数组

 1.语句

循环结构

• while循环

​
while( 布尔表达式 ) {
  //循环内容
}

　　

• do...while循环

　　对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。　

do {
       //代码语句
}while(布尔表达式);

• for循环

　　for循环执行的次数是在执行前就确定的

　　语法格式如下：

​
for(初始化; 布尔表达式; 更新) {
    //代码语句
}

break和continue关键字：

break

　　break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

　　break 跳出最里层的循环，并且继续执行该循环下面的语句。

continue

　　continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

　　在 for 循环中，continue 语句使程序立即跳转到更新语句。

　　在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。​

举例：　　

/**
 * @ClassName: ForLoop
 * @Description: TODO
 * @Author: benjamin
 * @Date: 2019/3/22 10:32
 * @Version: 1.0
 */
public class ForLoop {
    public static void main(String[]args){
        //for循环break
        int [] numbers = {10,20,30,40,50};
​
        for (int x: numbers){
//            //x等于30跳出
//            if(x == 30){
//                break;
//            }
            if(x ==30){
                continue; //让程序立刻跳转到下一次循环的迭代。
            }
            System.out.println(x);
            System.out.println("
");
        }
    }
}

条件语句

    if...else...

语法
if…else 的用法如下：
​
if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}
​
if...else 语法格式如下:
​
if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

switch case语句

2. 函数

定义：在类中的具有特定功能的一段独立小程序，也叫方法；

• 将代码封装，进行功能复用

• 只有调用后才能被执行，执行完这个函数就当成垃圾回收了；

• 函数的出现提高了代码的复用性

格式：修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2， ){ 执行语句; return 返回值;}

• 特殊情况：功能没有具体的返回值,这时return 的后面直接用分号结束；返回值类型用一个关键字void进行表示；

注意：

1. 如果返回值类型是void,则函数中的return语句可以省略不写；

2. 函数中只能调用函数，不能在函数内部调用函数

3. 定义函数时，函数的结果应该返回给调用者，交由调用者处理；

public class FunctionDemo {
    // 函数的定义
    public static void main(String[]args){
        myPrint();
    }
    
    public static void myPrint(){
        //定义一个输出helloworld的函数；
        System.out.println("Hello world!");
    }
}
​
public class FunctionDemo {
    // 函数的定义
    public static void main(String[]args){
​
        int a = 3;
        int b = 4;
//        int c;
//        c = aAddb(a,b); //应该将函数的返回值返回给调用者；
//        System.out.println(c);
        aAddb(a,b);//这样做不对；
    }
​
    //定义a+b的函数；
//    public static int aAddb(int a,int b){
//        return a+b;
//    };
    public static void aAddb(int a, int b){
        System.out.println(a+b);
    }
}

　　如何来编写一个函数？

需求：

定义一个功能：完成两个整数的和的获取

思路：既然定义功能，就是可以用函数来实现；

​ 如何定义一个函数呢？

​ 通过两个明确来完成

明确1：这个功能的结果是什么？

​ 是和，是功能的结果，所以该功能的返回值类型是int;

​ 其实就是在明确函数式的返回值类型。

明确2：这个功能的实现过程中是否需要未知的参数参与运算？

​ 有，加数和被加数，这就是函数的参数列表（参数的个数，参数的类型）

​ 其实就是明确参数列表；

注意： 返回值类型和参数类型没有直接关系；

函数的执行过程：

函数的重载：

　　在同一个类中，允许存在一个以上的同名函数，只要参数个数或参数类型不同即可；

• java虚拟机自动去找对应的函数；

• 功能相同，用参数列表进行区分；

• 函数重载和返回值类型无关；

​

/**
 * @ClassName: FunctionDemo3
 * @Description: 函数overload
 * @Author: benjamin
 * @Date: 2019/3/22 17:22
 * @Version: 1.0
 */
public class FunctionDemo3 {
    public static void main(String[] args) {
​
        System.out.println("Hello World");
        System.out.println(addNums(2,3));
        System.out.println(addNums(2.5,3.6));
        System.out.println(addNums(2,3,3));
    }
    /*
    * 函数的重载：
    * 1. 同一个类
    * 2. 同名函数；
    * 3. 参数个数不同或参数类型不同
    * */
    //两个数相加，整数
    public static int addNums(int a,int b){
        return a + b;
    }
    // 两个数相加，double
    public static double addNums(double a,double b){
        return a+b;
    }
    // 三个数相加，整数
    public static int addNums(int a,int b, int c){
        return a+b+c;
    }
​
    //报错；
//    public static double addNums(int a, int b){
//        return a+b;
//    }
//
​

}

　　函数重载的练习：

/**
 * @ClassName: FunctionDemo4
 * @Description: 打印99乘法表
 * @Author: benjamin
 * @Date: 2019/3/22 17:35
 * @Version: 1.0
 */
public class FunctionDemo4 {
    public static void main(String[] args) {
​
        System.out.println("Hello World");
​
        multiTable(5);
        multiTable();
    }
    public static void multiTable(int num){
        //打印任意的乘法表
        int i,j;
        for(i=1;i<=num;i++){
            for(j=1;j<=i;j++){
                System.out.printf("%d * %d = %d;",i,i,i*j);
            }
            System.out.println();
        }
    }
    public static void multiTable(){
        //打印99乘法表，函数调用的方式
        multiTable(9);
    }
​
}

3.数组

数组的定义：同一种类型数据的集合。一个容器

元素从0开始编号；

格式：

​ 　　元素类型[ ] 数组名 = new 元素类型[元素个数或数组长度]；

​　　 int [ ] arr = new int [3];

​ 　　//声明了一个int类型的数组，名称为arr,右边是new创建一个数组实体，该数组中元素是int类型，长度是3

​ 　　元素类型[ ] 数组名 = new 元素类型[] {元素，元素，...}

​ 　　int [ ] arr = new int [ ] {1,2,3,4};

​　　 int [ ] arr = {1,2,3,4};

/**
 * @ClassName: ArrayDemo
 * @Description: TODO
 * @Author: benjamin
 * @Date: 2019/3/23 9:33
 * @Version: 1.0
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //定义数组
        //元素类型 [] 数组名 = new 元素类型 [元素个数或数组长度];
        int [] array = new int[5];
​
        for(int i = 0; i < 5;i++){
            System.out.println(array[i]); //数组中元素的值默认为0；
        }
    }
}

/**
 * @ClassName: ArrayDemo3
 * @Description: TODO
 * @Author: benjamin
 * @Date: 2019/3/23 11:21
 * @Version: 1.0
 */
public class ArrayDemo3 {
    public static void main(String[] args) {
​
        // 格式1：需要一个容器，但是不明确容器的具体数据
        int [] arr0 = new int[3];
​
        // 格式2：需要一个容器，存储已知的具体数据；
        // 元素类型 [] 数组名 = new 元素类型 [] {元素1,元素2...}
        int [] arr = new int[]{1,2,3,4};
        int [] arr1 = {1,2,3,4};
​
​
        System.out.println("Hello World");
    }
​
}

数组的内存分配及特点

​ 　　内存的划分：

1. 寄存器

2. 本地方法区

3. 方法区

4. 栈内存

  　　存储的都是局部变量，而且变量所属的作用域一旦结束，该变量就自动释放；

　　  注意：局部代码块，限定局部变量的生命周期；

5. 堆内存

        存储的是数组和对象（其实数组就是对象），凡是new建立的都在堆里；

　　  特点：

1. 每一个实体都有首地址值；

2. 堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同，整数是0，小数是0.0或者0.0f，boolean false，char 'u0000'。

3. 垃圾回收机制；

堆内存和栈内存的图示：

　　

数组的实际应用

进制转换：

/**
 * @ClassName: ArrayTest2
 * @Description:进制转换
 * @Author: benjamin
 * @Date: 2019/3/25 9:48
 * @Version: 1.0
 */
public class ArrayTest2 {
    public static void main(String[] args) {
        toBinary(60);
        toHex(60);
        toOctal(60);

        System.out.println(Integer.toBinaryString(60));

        System.out.println(" ");
    }

    public static void toHex(int num){
        /**
        * @Description:  十进制到十六进制
        * @Param: [num]
        * @return: void
        * @Author: benjamin
        * @Date: 2019/3/25
        */
        trans(num,15,4);
    }

    public static void toBinary(int num){
        /**
        * @Description:  十进制-二进制
        * @Param: [num]
        * @return: void
        * @Author: benjamin
        * @Date: 2019/3/25
        */
        trans(num,1,1);
    }

    public static void toOctal(int num){

        /**
        * @Description:  十进制到八进制；
        * @Param: [num:要转换的数字]
        * @return: void
        * @Author: benjamin
        * @Date: 2019/3/25
        */
        trans(num,7,3);
    }

    public static void trans(int num,int base,int offset){
        /**
         * @Description: 任意进制的转换
         * @Param:  num:传入的数字；base:进制；offset:偏移
         * @return: void
         * @Author: benjamin
         * @Date: 2019/3/25
         */
        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;//二进制是1，十进制是9，八进制是7；十六进制是15；
            arr[--pos] = chs[temp];//从数组最后一位移位
            num = num >>> offset; //num右移offset位；
        }

        System.out.println("pos = "+pos);//当前数组指针的位置；
        for(int x= pos;x<arr.length;x++){
            //循环打印输出新的数组元素；
            System.out.print(arr[x]);//
        }
        System.out.println(" ");
    }
}

查表法的实际应用：

/**
 * @ClassName: ArrayTest3
 * @Description:
 * @Author: benjamin
 * @Date: 2019/3/25 10:12
 * @Version: 1.0
 */
public class ArrayTest3 {
    public static void main(String[] args) {

        String week = getWeek(6);
        System.out.println(week);
    }
    public static String getWeek(int num){
        /**
        * @Description:
        * @Param: [num:输入的星期几]
        * @return: String 字符串
        * @Author: benjamin
        * @Date: 2019/3/25
        */
        if (num > 7 || num < 1){
            //如果不满足1~7，则返回提示
            System.out.println("错误的输入");
        }
        String[] weeks = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"};

        return weeks[num-1];//数组是从0开始的；
    }

}

二维数组(数组中的数组):

定义二维数组有两种格式：

格式1： int[] [] arr =  new int[3][2]; // 明确了二维数组的长度为3，一维数组的长度为2
    定义了一个名为arr的二维数组;
    二维数组中有3个一维数组；
    每一个一维数组中有2个元素；
    一维数组的名称分别为： arr[0],arr[1],arr[2]
    给第一个一维数组1脚标位赋值为78的写法为：arr0 = 78;
格式2：int[] [] arr = new int[3][];//只明确了二维数组的长度为3；
    二维数组中有三个一维数组；
    每个一维数组都是默认初始化值null；
    可以对这三个一维数组分别进行初始化；
    arr[0] = new int[3];
    arr[1] = new int[1];
    arr[2] = new int[2];

/**
 * @ClassName: Array2Demo
 * @Description:
 * @Author: benjamin
 * @Date: 2019/3/25 11:04
 * @Version: 1.0
 */
public class Array2Demo {
    public static void main(String[] args) {
​
        //一维数组
        int[] array = new int[3];
        System.out.println(array);//[I@1b6d3586
​
        //二维数组，该数组有3个一维数组，每一个一维数组中有2个元素；
        int[][] arr = new int[3][2];
​
        System.out.println(arr);//直接打印二维数组[[I@4554617c
        System.out.println(arr[0]);//直接打印二维数组中角标为0的一维数组[I@74a14482
        System.out.println(arr[0][0]);//直接打印二维数组中角标为0的一维数组中的第一个元素0
​
        int[][] arr2 = new int[3][];
​
        arr2[0] = new int[2];
​
        System.out.println(arr2); //[[I@1540e19d
        System.out.println(arr2[0]); //[I@677327b6
        System.out.println(arr2[1]); //null
        System.out.println(arr2[0][0]);//0 默认值；
//        System.out.println(arr2[1][0]); //报错，java.lang.NullPointerException
        System.out.println(" ");
    }
​
}

二维数组的基本操作：

/**
 * @ClassName: Array2Demo2
 * @Description: 打印二维数组的长度，求二维数组中元素的和；
 * @Author: benjamin
 * @Date: 2019/3/25 11:16
 * @Version: 1.0
 */
public class Array2Demo2 {
    public static void main(String[] args) {

        int[][] array = new int[3][2];

        System.out.println(array.length);//打印二维数组的长度，其实就是一维数组对的个数
        System.out.println(array[1].length);//打印二维数组中角标为1的一维数组的长度

        int sum = 0;
        int [][] arr = {{1,2,3},{2,3,4},{3,4,5}};//定义一个二维数组

        for(int i=0;i<arr.length;i++){
            //arr.length代表二维数组的长度
            for(int j=0;j<arr[i].length;j++){
                // arr[i].length 表示第i个一维数组的长度；
                System.out.print(arr[i][j]+",");
                sum += arr[i][j];
            }
        }
        System.out.println(" ");
        System.out.println(sum);
    }
}