Bigdata Development Java_Guidance_01

代码的执行

    /*class （类）：是程序的基础组成部分，一个又一个的类组成了完整的软件。
    每个类完成一个单独的功能，多个类组装在一起完成整个软件的功能。
    Demo1：类的名字，方便使用。
    { }：作用域，只有写在这组{ }内的代码才能生效被执行。*/

基本数据类型

/*八大基本数据类型。 
    整数类型  byte  short   int  long
    浮点型   float  double
    字符类型  char
    布尔类型 boolean

    byte         1字节               -128——127
     short  2 字节        -32768 -- 32767
    int         4 字节        -21亿 -- 21亿
    long        8 字节        很大的数字              

    1字节 = 8位 = 2的8次方个数字 = 256个数字。
    计算机是二进制，以为能够表示两个数字，0和1。
    第一位是符号位，剩下的才是表示数字的值。
                long a = 31l;    不加L，当数值超过int时会报错。
*/

                System.out.println(Byte.MAX_VALUE);
                System.out.println(Short.MAX_VALUE);
                System.out.println(Integer.MAX_VALUE);
                System.out.println(Long.MAX_VALUE);

/*
    小数类型/浮点型；float和double.
    float   4字节   单精度
    double  8字节   双精度  更准确
*/

                float f = 1.1f;
                double h = 2.3;

    //char表示一个字符，使用''单引号包裹。
                char a = 'a';
                char b ='1';


/*
    boolean 类型只有两个值，true或者false。
*/


                boolean flag1 = 10>5;
                System.out.println(flag1);
                boolean flag2 = 10 < 5;
                System.out.println(flag2);

常用逻辑运算符

        // 逻辑运算符：
        // > < >= <=
        // == 等于
        // != 不等于
        // ! 对结果进行取反，true 变为 false，false 变为 true。
        // && 并且 AND，用来链接多个逻辑运算，必须满足所有的条件才为 true。
        // || 或者 OR，用来链接多个逻辑运算，只要满足任一条件就为 true。

常用算数运算符

        // 算数运算符：
        // + - * / ()
        // % 取两个数相除的余数。
        // += -= *= /= 在自身的数值基础上 增加/减去/乘以/除去 多少。
        // ++ -- 在自身的数值基础上 增加/减少 1。


        //只有整数参与计算，得到的结果也是整数，除法的话就取整数部分。

        //如果有小数参与计算，得到的结果必定是一个小数。


        double c1 = 2.5;
        int c2 = 4;

        // 计算结果是小数，不能使用 int 类型表示。
        //int c3 = c1 * c2;

        double c3 = c1 * c2;

        int h1 = 100;

        h1++;// h1 += 1; h1 = h1 + 1;

        System.out.println(h1);

        h1--;// h1 -= 1; h1 = h1 - 1;

        System.out.println(h1);

        // 单独使用和上边效果是一样的。
        ++h1;

        System.out.println(h1);

        --h1;

        System.out.println(h1);

        // 如果不单独使用，就有区别
        int i1 = 100;
        int i2 = 100;

        // i++ 先用后加
        // ++i 先加后用
        int i3 = i1++;// 等价于 int i3 = i1; i1 = i1 + 1;
        int i4 = ++i2;// 等价于 i2 = i2 + 1; int i4 = i2;

        System.out.println(i3);
        System.out.println(i4);

        System.out.println(i1);
        System.out.println(i2);

        // 为了防止混淆，出现错误，一般代码中 i++ 和 ++i 都是单独写一行。

判断语句

        // if 用来表示判断。
        // if (条件) { 满足条件后执行的代码 }
        // 条件 == 逻辑表达式。

        int score = 52;

        /*
        if (score >= 60) {

            // 只有满足条件了，才执行这里的代码。
            // 只有逻辑表达式为 true，才执行这里的代码。
            System.out.println("考试及格了");
        }

        System.out.println("程序执行完毕");
        */


        // 如果满足条件做...否则做...
        // if (条件) { 满足条件执行的代码 } else { 不满足条件要执行的代码}



        int month = 7;
        int year = 2017;

        // 输出这个月有多少天。
        if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {

            System.out.println("31 天");
        }else if (month == 4 || month == 6 || month == 9 || month == 11) {

            System.out.println("30 天");
        }else {

            // 能否被 4 整，使用 % 进行一个取余操作，余数为 0 能够被整除，否则不能
            if (year % 4 == 0) {

                System.out.println("29 天");
            }else {

                System.out.println("28 天");
            }
        }



        //使用swith-case简化if==的判断。
        //拿着swith 中的key和case中value进行比较。
        //如果相等执行case中的内容，如果所有case没有匹配上，执行default。

        //break;结束swicth-case代码的执行。
        switch (month) {
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                case 12:{
                    System.out.println("31 天");
                }
                break;

                case 4:
                case 6:
                case 9:
                case 11: {
                    System.out.println("30 天");
                }
                break;

                default:
                    break;
                }


        // 三目运算符：判断条件 ? 满足条件执行的代码 : 不满足条件执行的代码;
        // if...else 的简写。
        c = a > b ? a : b;

        System.out.println(c);

循环语句

        // for循环 让一段代码重复执行。

        // for (控制循环次数) { 需要重复执行的代码 }
        // A：int i = 0; 设置变量 i 用来控制循环多少次，赋予初始值 0。
        // B：i < 10; 设置循环执行的条件，只要满足这个条件，代码就重复执行，否则结束循环。
        // C：i++ 使用变量 i 不断的变化，控制循环次数。       
        // D：System.out.println("hello, world"); 需要重复执行的代码。
        // A -> B -> D -> C -> B -> .... -> B -> 循环结束。

        for (int i = 0; i < 10; i++) {

            // 0 - 9
            System.out.println("hello, world");
        }



        //break和continue。
        for (int i = 0; i < 10; i++) {

            if (i == 5) {

                // 结束当前这次循环，开始下一次循环。
                // 后边的代码都不执行，直接执行 i++。
                continue;
            }

            System.out.print(i + " ");
        }

        System.out.println();

        for (int i = 0; i < 10; i++) {

            if (i == 5) {

                // 终止循环，后边的代码和后续的循环都不执行。
                break;
            }

            System.out.print(i + " ");
        }



        while循环
                // while 循环只有一个条件，满足条件就会一直循环下去。
        // for 循环有固定的次数。

        /*
        while (条件) {

            需要重复执行的代码
        }
        */

        int i = 10;

        while (i < 20) {

            System.out.println(i);

            i++;
        }


        // 月薪 9000，每年增长 15%，多少年能超过到月薪 20000。
        // 只要月薪小于 20000，每年都增长 15%。

        double salary = 9000;

        int year = 0;

        while (salary < 20000) {

            salary = salary + salary * 0.15;

            year++;
        }

        System.out.println("需要：" + year + " 年");

        // 条件 == 逻辑表达式，true 满足条件 false 不满足条件。

        while (true) {

            // 让一段代码无限循环。

            // continue; // 跳过当前这次循环，开始下次循环。

            break; // 跳出循环

            // while (true) 通常要和 break 进行配合使用，否则后续代码永远也执行不到。
        }

        // Unreachable code
        int j = 10;

        // 先判断，后执行。
        while (j < 5) {

            System.out.println(j);
        }

        // 先执行，后判断。do{}while()语句至少执行一次。
        do {

            System.out.println("do-while：" + j);

        } while (j < 5);

方法

/*
    class是程序基础组成部分，不同class拥有不同功能。
    Scanner类允许我闷通过控制台向程序输入一些数据。
    Jaca中提供的类有上万个，使用的时候有一些统一的格式。

    动态方法。  类名  变量名= new  类名();
    调用 变量名.方法
    静态方法  
    直接类名.方法名

    通过方法名()调用方法，会让方法中的所有代码都执行。

    1.方法只能定义在类的作用域范围内，不能在一个方法内部再定义新的方法。
    2.一个类中可以定义任意多个方法，没有限制。
    3.修饰词 返回值  方法名(参数){方法体：需要执行的代码}

    public static void main(String[] args) {}   
    这是一个main方法。

    修饰词：限定方法的使用范围，增加一个特殊的标记说明方法的类型，任意个。
    public static

    返回值：输出的数据。
    void：没有返回值，不需要输出任何数据。
    int/String：返回数据的类型，一个方法只能返回一个数据。

    方法名：给代码起的名字。

    参数：输入的数据。
    如果不需要输入数据，空着既可。()不可以省略。
    参数之前以,分隔。

    方法体：代码实现全些在{}中。
    如果有返回值，必须通过return指定返回值的数据。

*/

    public static void method2() {

        // 在方法内部定义的变量，在方法执行完毕后就会被销毁
        // 下次再调用方法的时候，会创建一个新的变量 i = 10
        int i = 10;

        i += 20;

        System.out.println("i：" + i);
    }

    // 有些时候方法实现的功能需要外部提供一些数据，
    // 这些数据通过参数的形式提供给方法使用
    // 拥有一个 String 类型，名字叫做 name 的参数
    public static void method3(String name) {

        // 参数可以在方法实现的时候，当作一个变量来使用
        // 参数变量的值需要我们调用方法的时候，进行设置
        System.out.println("制作：" + name + "粥");
    }

    // 返回值：方法传递给外部的一个数据，供后续的其它步骤使用
    // 返回值类型 = 返回数据的类型
    // 返回值只能有一个
    // 在方法结束的时候使用 return 关键字返回一个数据
    public static double method6(double a, double b) {

        // This method must return a result of type double
        // 声明的时候有返回值，必须在方法体中返回一个数据
        return a + b;

        // Type mismatch: cannot convert from String to double
        // return "abcd";
        // 代码执行到 return 的时候就会跳出方法，后续代码都不执行

        // Unreachable code
        // System.out.println("=====");
    }



**封装**

    // 尽量把重复的代码写为方法，重复的代码改为方法调用
    // 将来功能有变的时候只需要修改方法中的代码，
    // 就可以实现所有调用方法的地方统一改变

    // 写方法
    // 1. 消除重复的代码就是封装
    // 2. 把大段的代码拆分为多段小的方法，由几个方法调用组成完整的功能