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

 1.语句

循环结构

  • while循环

?
1
2
3
4
​
while( 布尔表达式 ) {
  //循环内容
}

　　

  • do...while循环

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

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

  • for循环

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

　　语法格式如下：

?
1
2
3
4
​
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("\n");
        }
    }
}
复制代码

条件语句

    if...else...

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
语法
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. 定义函数时，函数的结果应该返回给调用者，交由调用者处理；

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<br>需求：
 
定义一个功能：完成两个整数的和的获取
 
思路：既然定义功能，就是可以用函数来实现；
 
​ 如何定义一个函数呢？
 
​ 通过两个明确来完成
 
明确1：这个功能的结果是什么？
 
​ 是和，是功能的结果，所以该功能的返回值类型是int;
 
​ 其实就是在明确函数式的返回值类型。
 
明确2：这个功能的实现过程中是否需要未知的参数参与运算？
 
​ 有，加数和被加数，这就是函数的参数列表（参数的个数，参数的类型）
 
​ 其实就是明确参数列表；
 
注意： 返回值类型和参数类型没有直接关系；

函数的执行过程：

 

函数的重载：

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

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

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

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

​
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
 * @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;
//    }
//
​
 
}

　　函数重载的练习：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
 * @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};

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
 * @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. 栈内存

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

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

  1. 堆内存

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

　　  特点：

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

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

  3. 垃圾回收机制；

堆内存和栈内存的图示：

　　

数组的实际应用

进制转换：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
/**
 * @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(" ");
    }
}

查表法的实际应用：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
 * @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
2
3
4
5
6
7
8
9
10
11
12
13
格式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];

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
 * @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(" ");
    }
​
}

二维数组的基本操作：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 * @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);
    }
}

　

本文作者：benjieqiang

本文链接：https://www.cnblogs.com/benjieqiang/p/10594369.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   benjieqiang  阅读(163)  评论(0)  编辑  收藏  举报
点击右上角即可分享
微信分享提示
💬
评论
📌
收藏
💗
关注
👍
推荐
🚀
回顶
➖
收起
🔑
  1. 1 蒹葭（古筝版） 徐潮城
蒹葭（古筝版） - 徐潮城
00:00 / 00:00
An audio error has occurred.

作词 : 诗经

作曲 : 徐潮城

蒹葭-徐潮城

编：刘文

蒹葭苍苍白露为霜

所谓伊人在水一方

溯洄从之道阻且长

溯游水中央

蒹葭萋萋白露未晞

伊人在水湄

溯洄从之道阻且跻

溯游水中坻

蒹葭苍苍白露为霜

所谓伊人在水涘

伊人在水一方

蒹葭采采白露未已

溯洄从之道阻且右

溯游水中沚

蒹葭萋萋白露未晞

伊人在水湄

溯洄从之道阻且跻

溯游水中坻

蒹葭苍苍白露为霜

所谓伊人在水涘

伊人在水一方

蒹葭采采白露未已

溯洄从之道阻且右

溯游水中沚

蒹葭苍苍白露为霜

所谓伊人在水涘

伊人在水一方

蒹葭采采白露未已

溯洄从之道阻且右

溯游水中沚