第02章(基本语法)

 

/*****************
***第二章基本语法
*******知识点:
**************1.注释
******************1.1 单行注释
******************1.2 多行注释
**************2.标识符、关键字
**************3.基本数据类型
******************3.1 整型
******************3.2 浮点型
******************3.3 字符型
******************3.4 布尔型
**************4.基本运算符
******************4.1 赋值运算符
******************4.2 算术运算符
******************4.3 自增自减运算符
******************4.4 逻辑运算符
******************4.5 比较运算符
******************4.6 三目运算符
******************4.7 位运算符
**************5.语句结构
******************5.1 顺序结构
******************5.2 分支结构
**************************5.2.1 if结构
**************************5.2.2 if-else结构
**************************5.2.3 if-else if-else结构
**************************5.2.4 switch结构
******************5.3 循环结构
**************************5.3.1 while结构
**************************5.3.2 do - while结构
**************************5.3.3 for结构
**************************5.3.4 foreach结构
******************5.4 跳出结构
**************************5.4.1 break
**************************5.4.2 continue
**************************5.4.3 return
**************6.数组
******************6.1 一维数组
******************6.2 二维数组
******************6.3 多维数组
*****************/
import java.util.Arrays;  //因为使用到API数组排序  需要导入包   import语句必须在最前面不能在class代码内

public class test2{
    public static void main(String[] args){
        showDemo("1.注释");
        demoNote();//演示1.注释
        
        showDemo("2.标识符、关键字");
        demoKeyWord();//演示2.标识符、关键字
        
        showDemo("3.基本数据类型");
        demoDataSort();//演示3.基本数据类型
        
        showDemo("4.基本运算符");
        demoCalcSymbol();//演示4.基本运算符
        
        showDemo("5.语句结构");
        demoStatementStruct();//演示5.语句结构
        
        showDemo("6.数组");
        demoArray();//演示6.数组
        
        
    }
    
    /*
    *    抽取打印演示函数  用于打印演示功能提示
    */    
    public static void showDemo(String demoStr){
        System.out.println("演示:" + demoStr);
    }
    
    /*
    * 1.注释演示
    */
    public static void demoNote(){
        //1.1单行注释   这是单行注释
        
        /* 1.2多行注释
        *    我
        *   是
        *    华
        *    丽
        *    的
        *    注
        *    释
        *    行
        */
    }

    /*
    *2.标识符、关键字
    */
    public static void demoKeyWord(){
        int $a,a_a,a2; //其中int为java关键字  $a,a_a,a2;为标识符
    }
    
    /*
    *3.基本数据类型(四类八种)  
    *  其中注意数据类型的强转换问题、字符类型可以存中文字符
    */
    public static void demoDataSort(){
        /*
        *3.1整型  
        *需注意：低范围赋值给高范围时无问题.高范围赋值给低范围时会截取,当超过范围时溢出。
        *其中byte 1个字节  short 2个字节  int 4个字节  long 8个字节
        */
        byte b_; short s_; int i_; long l_;
        b_ = -128 ;
        l_ = b_;
        System.out.println("l_:" + l_); //l_可以存储-128 所以此时打印-128
        i_ = 32768;
        s_ = (short) i_;
        System.out.println("s_:" + s_); //s_不可以存储32768，所以出现溢出 打印-32768
        
        /*
        *3.2 浮点型
        *其中float 4个字节  double 8个字节
        */
        float f_; double d_;
        
        /*
        *3.3 字符型
        *其中char 2个字节
        */
        char c_;
        
        c_ = '黄' ;//汉字为两个字节  需跟string区别  char类型为单引号 string为双引号
        System.out.println("c_:" + c_);
        
        /*
        *3.4 布尔型
        *其中boolean 1个字节
        */
        boolean b_l;
        b_l = true ; //布尔型 取值为 true / false
        System.out.println("b_l:" + b_l);
        
    }
    
    /*
    *4.基本运算符 
    ************4.1 赋值运算符
    ************4.2 算术运算符
    ************4.3 自增自减运算符
    ************4.4 逻辑运算符
    ************4.5 比较运算符
    ************4.6 三目运算符
    ************4.7 位运算符
    ************4.8 移位运算符
    */
    public static void demoCalcSymbol(){
        /*
        *4.1 赋值运算符
        */
        byte b_a=1,b_b; //java可以在声明变量时直接对变量初始化(即赋值)
        b_b = b_a; //将b_a的值赋值给b_b  此时b_b也为1;
        System.out.println("i_b:" + b_b);
        
        /*
        *4.2 算术运算符
        *需注意:算数运算符的优先级
        */
        short s_a=1,s_b; //java可以在声明变量时直接对变量初始化(即赋值)
        s_b = (byte)(s_a  +  s_a * 5); //因为s_a * 5得到的是一个int型的数据。故需要将其强转为byte
        System.out.println("s_b:" + s_b);
        
        
        /*
        *4.3 自增自减运算符
        *需注意:a++ ++a 和 a--  --a的区别
        *(真实工作中不推荐这样的写法，可读性相对比较差)
        */
        int i_a=1,i_b,i_c; //java可以在声明变量时直接对变量初始化(即赋值)
        i_b = i_a++ ; //先赋值i_b ，i_a本身+1 此时i_b为1 i_a为2
        System.out.println("i_a:" + i_a);
        System.out.println("i_b:" + i_b);
        
        i_c = ++i_a; //i_a本身+1 再赋值  此时i_a、i_c均为 3
        System.out.println("i_a:" + i_a);
        System.out.println("i_c:" + i_c);
        /****a-- 和 --a 也一样  这里就不演示了****/
        
        /*
        *4.4 逻辑运算符
        * 与 && 或 || 非 !
        */
        boolean b_t =  true , b_f = false ;
        System.out.println("b_t 与 b_f:" + (b_t && b_f));//与
        System.out.println("b_t 或 b_f:" + (b_t || b_f));//或
        System.out.println("非b_t:" + (!b_t));//非
        
        
        /*
        *4.5 比较运算符
        * >大于、>=不小于、<小于、 <=不大于 、== 等于 、!= 不等于
        *较简单不演示
        */
        
        
        /*
        *4.6 三目运算符
        * 需注意: a?b:c  a为真执行b。否则执行c 其中b、c可再多重嵌套如a?(a?b:c):(a?b:c)
        */
        int i_d = (b_t && b_f) ? 1 : 0; //(b_t && b_f)为真时 赋值1  否则 0 
        int i_e = (b_t || b_f) ? 1 : 0; //(b_t || b_f)为真时 赋值1  否则 0
        System.out.println("i_d:" + i_d + "      " + "i_e:" + i_e);
        
        /*
        *4.7 位运算符
        *位与运算符用符号&、位或运算符用符号|、位非运算符用符号~、位异或运算符^(相同等于0  不同等于1) 
        *需注意:这里的与或非不同于逻辑运算符的与或非。这里的与或非运算的是位而不是表达式或变量
        */
        int i_f = 1, i_g = 0 ; 
        System.out.println("i_f位与i_g：" + (i_f & i_g));//001 & 000  -> 000 -> 0
        System.out.println("i_f位或i_g：" + (i_f | i_g));//001 | 000  -> 001 -> 1
        System.out.println("位非i_f：" + (~i_f)); //!001 -> 110 -> 负(010) -> -2  
        System.out.println("i_f位异或i_g：" + (i_f ^ i_g));//^(001 | 000) -> 001 ->1  
        
        /*
        *4.8 移位运算符
        *>>有符号右移、<<有符号左移和>>>无符号右移
        */
        int i_h = -2 , i_i = 2, i_j = 8;
        System.out.println("i_h >>> 1：" + (i_h >>> 1));//无符号最高位补0
        System.out.println("i_i << 2：" + (i_i << 2)); //相当于 * 2的2次方
        System.out.println("i_h >> 1：" + (i_j >> 3)); //相当于 / 2的3次方
        
    }
    
    /*5.语句结构
    **************5.1 顺序结构
    **************5.2 分支结构
    **********************5.2.1 if结构
    **********************5.2.2 if-else结构
    **********************5.2.3 if-else if-else结构
    **********************5.2.4 switch结构
    **************5.3 循环结构
    **********************5.3.1 while结构
    **********************5.3.2 do - while结构
    **********************5.3.3 for结构
    **********************5.3.4 foreach结构
    **************5.4 跳出结构
    **********************5.4.1 break
    **********************5.4.2 continue
    **********************5.4.3 return
    */
    public static void demoStatementStruct(){
        /*
        *5.1 顺序结构(一个接着一个 too easy 妈妈再也不用担心我的编程了)
        */
        System.out.println("按顺序来,这是第一条，接下来是第二条");
        System.out.println("按顺序来,这是第二条，接下来是第三条......");
        
        /*
        *5.2 分支结构
        */
        /****5.2.1 if结构*****/
        boolean b_a =  true ;
        if(b_a){
            System.out.println("这是if结构!");
        }
        
        /****5.2.2 if-else结构*****/
        boolean b_b =  false ;
        if(b_b){
            System.out.println("这是if - else结构中的if!");
        }else{
            System.out.println("这是if - else结构中的else!");
        }
        
        /****5.2.3 if-else if-else结构*****/
        int i_a = 3;
        if(i_a == 1){
           System.out.println("这是if-else if-else结构中的if!");
        }else if(i_a == 2){
            System.out.println("这是if-else if-else结构中的第一个else if!");
            
        }else if(i_a == 3){
            System.out.println("这是if-else if-else结构中的第二个else if!");
        }else{
            System.out.println("这是if-else if-else结构中的else!");
        }
        
        /****5.2.4 switch结构*****/
        /*
        *需注意有break和没有break的区别
        */
        int i_b = 5;
        switch(i_b){
            case 0:
            System.out.println("这是switch结构中的0!");
            break;
            case 1:
            System.out.println("这是switch结构中的1!");
            case 2:
            System.out.println("这是switch结构中的2!");
            case 3:
            System.out.println("这是switch结构中的3!");
            case 4:
            System.out.println("这是switch结构中的4!");
            case 5:
            System.out.println("这是switch结构中的5!");
            case 6:
            System.out.println("这是switch结构中的6!");
            break;
            default:
            System.out.println("这是switch结构中的defalut!");
            break;
        }
        
        /*
        *5.3 循环结构
        */
        
        /****5.3.1 do -  while结构(至少执行1次,先执行再判断条件)*****/
        int i_c = 1,i=0;
        do{
            i++;
            System.out.println("这是do-while执行的第" + i + "次");
        }while(i_c > 1);
        
        /****5.3.2 while结构(有可能不执行 先判断再执行)*****/
        i = 0;
        while(i_c > 1){
            i++;
            System.out.println("这是while执行的第" + i + "次");
        }
        
        /****5.3.3 for结构*****/
        for(i = 0;i < 2 ;i++){
            System.out.println("这是for执行的第" + (i+1) + "次");
        }
        
        int[]a = {0,1,2,3};
        /****5.3.4 foreach结构(语法格式比较坑爹  居然用的是for)*****/
        for(int b :a){
            System.out.println("这是foreach执行的第" + (b+1) + "次");
        }
        
        //结论：
            /*for跟foreach
            *1.均可遍历数组或集合
            *2.使用for时可以读写数据,而使用foreach只能读取
            *3.foreach可防止访问数组越界问题
            *4.foreach是for的简化版本，若数据仅仅是读取时推荐使用foreach。它会比for速度快一点
            */
        
        /*
        *5.4 跳出结构
        */
        
        /****5.4.1 break结构*****/
        /*
        *break关键字  跳出循环往下执行相关语句
        *如  while(i > 5){
                   i++;
                    if(i ==3){
                        break;
                    }
                    b = b + i;
             }
             i = i + 5;
             当 i = 3时 调出循环,执行 i = i + 5;
        */
        
        /****5.4.2 continue结构*****/    
        /*
        *continue关键字  执行下次循环相关语句
        *如  while(i > 5){
                   i++;
                    if(i ==3){
                        continue;
                    }
                    b = b + i;
             }
             i = i + 5;
             当 i = 3时 执行下次循环,此时不会执行b = b + i;
        */
        
        /****5.4.3 return结构*****/
        /*
        *return关键字  执行下次循环相关语句
        *如  while(i > 5){
                   i++;
                    if(i ==3){
                        return;
                    }
                    b = b + i;
             }
             i = i + 5;
             当 i = 3时 跳出函数,此时不会执行i = i + 5;
        */
    }
    
    /*6.数组
    **************6.1 一维数组
    **************6.2 二维数组
    **************6.3 多维数组
    */
    public static void demoArray(){
        /*
        *6.1 一维数组
        */
        
        /*三种不同定义数组方式*/
        byte[] b = new byte[10]; //推荐这种  因为更能直接看懂数据类型
        int a[] = new int[10]; //C语言写法
        double d[] = {0.1,0.3,0.2,0.4,0.21};//定义时直接初始化
        
        /*根据数组长度遍历数组*/
        demoShowArray(d);
        
        /*调用API类对数组进行升序排序*/
        showDemo("数组升序排序");
        Arrays.sort(d);//注意需要导入相关工具包  且只能对数据进行升序排序
        demoShowArray(d);
        
        /*调用API类对数组进行降序排序*/
        showDemo("数组降序排序");
        Arrays.sort(d);
        double[] d1 = demoRevArray(d);//反转
        demoShowArray(d1);
        
        /*
        *6.2 二维数组
        */
        
        /*多种定义方式 每个维度元素数量不一定一致*/
        double[][] dd = new double[2][3];
        double dd1[][] = {{1,2,3},{4,5,6}};
        double dd2[][] = {{1},{3,2},{4,3,6},{7,8,9,10}}; //定义并初始化
        
        double[][] dd3 =  demoRevArray(dd1);//数组行列转换        
        
        demoShowArray("dd",dd);
        demoShowArray("dd1",dd1);
        demoShowArray("dd2",dd2);
        demoShowArray("dd3",dd3);
    
        /*
        *6.3 多维数组  (二维数组扩展  可自行体会)
        */
        
        int[][][] i_ar = {{{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}}
                          };
        demoShowArray("i_ar",i_ar);
        
    }
    
    /*
    *抽取遍历一维数组方法
    */
    public static void demoShowArray(double d[]){
        for(int i = 0 ; i < d.length ; i++){
            System.out.println("数组d第" + (i+1) + "个元素为：" + d[i]);
        }
        
    }
    
    /*
    *抽取遍历二维数组方法
    */
    public static void demoShowArray(String strArray,double d[][]){
        for(int i = 0 ; i < d.length ; i++){
            for(int j = 0; j < d[i].length ; j++){
               System.out.println("数组"+strArray+"第" + (i+1)+"行第"+ (j+1)+ "个元素为：" + d[i][j]);
            }
        }
    }
    
    /*
    *抽取遍历三维数组方法
    */
    public static void demoShowArray(String strArray,int i_ar[][][]){
        for(int i = 0 ; i < i_ar.length ; i++){
            for(int j = 0; j < i_ar[i].length ; j++){
                for(int k = 0; k < i_ar[i][j].length ; k++){
                    System.out.println("数组"+strArray+"第" + (i+1)+"行第"+ (j+1)+ "列第"+(k+1)+"个元素为：" + i_ar[i][j][k]);
                }
            }
        }
    }
    
    /*
    *实现一维数组反转
    */
    public static double[] demoRevArray(double d[]){
        int temp;
        double[] tmp =  new double[d.length];
        for(int i = 0; i < d.length/2 + 1; i++){
            tmp[d.length - i - 1] = d[i];
            tmp[i] = d[d.length - i - 1];
        }
        return tmp;
        
    }
    
    /*
    *实现二维数组反转
    */
    public static double[][] demoRevArray(double d[][]){
        int temp;
        double[][] tmp =  new double[d[0].length][d.length];
        for(int i = 0; i < d.length ; i++){
            for(int j = 0 ; j < d[i].length; j++){
                tmp[j][i] = d[i][j]; 
            }
        }
        return tmp;
        
    }
    
}