Java基础阶段2-Java基本语法

一，Java中三种注释方式

        1，单行注释：使用“//”。

         2，多行注释：使用“/* ... */”括起来

        3，文档注释： 写在class类名前用于解释整个类："/**  ...  */ "

package com.tsm.lecture1_BasicGrammar;

/**
 *  方法三：文档注释    主要是用来进行整个文档注释
 *  目标：学会使用注释
 */
public class Node {
    public static void main(String[] args) {

        // 方法一： 双斜杠 以下是一句打印语句
        System.out.println("本节课讲Java-注释");
        /*
            方法二： 多行注释
            床前明月光
            疑是地上霜
            举头望明月
            低头思故乡
         */
    }
}

        重点知识：注释不影响程序的执行：写java程序代码Node.java文件时，所写的注释再经过javac编译成为Node,class文件后就去除掉了所有注释，这样再进行java Node.clss文件不影响程序的执行。eg：上面代码经过编译后产生的class文件如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.tsm.lecture1_BasicGrammar;

public class Node {
    public Node() {
    }

    public static void main(String[] args) {
        System.out.println("本节课讲Java-注释");
    }
}

总结：
 1，注释定义：注释是写在程序中对代码进行解释说明的文字，方便自己和别人查看，以便理解程序的
 2，注释的用法： 三种方法：单行注释    多行注释    文档注释
 3，注释的特点：，仅打印了 本节课讲Java-注释
    解释原因： 因为node.java文件中写的任何注释 ----编译--->  node.class文件
        注释不影响程序的执行： eg运行main函数时，javac编译时，就将所有注释给去掉了， 检查方法在out目录下找到node.class打开文件，查看是否有注释
 4，快捷键：
       单行注释： ctrl + /
       多行注释： ctrl + shift + /

二，常见数据在程序中的书写格式

        Java中常见数据有整数、小数、字符串、字符、布尔型、空值null。

        特别注意：1，字符:'有且仅有一个字符'；2，两个特殊字符： \n、\t

public class LiteralDemo {
    public static void main(String[] args) {
        //1,整数
        System.out.println(666);

        //2,小数
        System.out.println(95.6);

        // 3,字符 ！！！必须使用单引号括起来， 有且仅有一个字符 （must and only one）
        System.out.println('a');
        System.out.println('0');
        //System.out.println('中国'); Too many characters in character literal
        //System.out.println(''); Empty character literal
        System.out.println(' ');  //空字符

        //两个特殊字符 \n:换行  \t：相当于一个tab
        System.out.println('中');
        System.out.println('\n');   //注意，这里有换了两行哦 print\n也有一行
        System.out.println('国');
        System.out.println('\t');

        // 4,字符串 必须用双引号括起来， 内容多少，样式无要求
        System.out.println("中国我爱你 forever");

        // 5，布尔型
        System.out.println(true);
        System.out.println(false);

        // 6,空值 NULL
    }
}

三，Java中的变量

变量的定义

        1，变量的定义：变量是用来记住程序要处理的数据的
        2，为什么要使用变量：
             使用变量记住要处理的数据，编写的代码更灵活，管理代码更方便
        3，变量在计算机中的执行原理：
             变量就是内存中的一块区域， 可以理解为一个盒子，用来装一个数据的
        4，变量的特点：变量中的数据是可以变化的

注意事项：变量定义方式：数据类型 变量名 = 数据 ！！！注意 ‘=’ 在java中表示赋值的意思，而且是从右往左看！！！理解什么是从右往左赋值。

public class VariableDemo1 {
    public static void main(String[] args) {
        // 1，定义一个变量，用于记住一个整数
        //数据类型 变量名 = 数据     ！！！注意 ‘=’ 在java中表示赋值的意思，而且是从右往左看！！！
        int age = 23;
        System.out.println(age);

        // 2, 记住一个人的成绩
        double grade = 99.5;
        System.out.println(grade);

        // 3, 使用变量的好处： 便于程序的扩展和维护
        System.out.println(666);
        System.out.println(666);
        System.out.println(666);
        System.out.println(888);
        System.out.println(888);
        System.out.println(888);

        int num = 666;  //仅需要换这里即可 num = 888
        System.out.println(num);
        System.out.println(num);
        System.out.println(num);
        System.out.println(num);
        System.out.println(num);

        System.out.println("------------------------------");

        // 4,变量的特点，里面装的数据是可以替换的
        int age1 = 22;
        System.out.println(age1);
        age1 = 19;  //赋值，从右往左执行
        System.out.println(age1);

        age1 = age1 + 1;    //赋值运算：还是从右往左来：右边算完后 再将结果赋值给左边的age1变量
        System.out.println(age1);

    }
}

变量的注意事项

public class VariableDemo2 {
    public static void main(String[] args) {
        //目标：搞清楚使用变量的几点事项
        //1， 变量要先声明才能使用----------
        int age = 18;
        System.out.println(age);

        //2，变量是什么类型，就应该装什么类型的数据，否则会报错
        //age = 99.3;   Required type:  int    provided:   double


        //3，变量是在定义开始到 ‘}’ 截至的范围内有效； 且同一范围内， 定义的多个变量，不能同名
        {
            int a = 19;
            System.out.println(a);
        }
        //System.out.println(a);  //Cannot resolve symbol 'a'
        System.out.println(age);
        int a  = 20;    //注这是正确的，应该上一个a的范围已经截至了
        //int age = 16;   //Variable 'age' is already defined in the scope
        System.out.println(a);


        //4，变量在定义时可以不进行初始化， 但是在使用变量之前，变量必须有值
        int number;
        //System.out.println(number); //Variable 'number' might not have been initialized
        number = 1000;
        System.out.println(number);
    }
}

变量的基本数据类型

                整数：byte、 short、int、long

                        byte：内存占用1字节 范围：-128-127

                        short：内存占用2字节

                        int：内存占用4字节

                        long：内存占用8字节

                浮点型：float 内存占用4字节

                               double 内存占用8字节

                字符型 char 内存占用 2字节 ！！！不要以为是一字节

                布尔型 boolean 内存占用1字节

        以上称为基本数据类型，此外还有一种叫做 引用数据类型。注意事项：默认为int或double型的数据，要明确为long、或float时怎样定义

public class VariableDemo3 {
    public static void main(String[] args) {
        // 1,byte short int long
        byte a1 = -128;
        //byte a2 = 128;

        short s = 12345;
        //short s1 = 98676;  越界了

        int i = 422424; //默认为int型

        //注意：随便写一个整形字面量 默认是int类型的， 422424444444虽然没有超出long的范围，但是本身超过了int类型的范围
        // 如果希望随便写一个整形字面量默认是long类型的， 需要在数字后面加上 L / l
        //long lg = 422424444444;
        long lg = 422424444444L;


        // 2, float double
        //注意： 随便写小数字面量， 默认是double， 如果希望小数是float， 后面加上F / f
        //float f = 3.14;
        float f = 3.14F;
        double d = 543.76879;


        // 3,字符型 char ：有且仅有一个字符
        char ch = 'a';
        char ch2 = '中';


        //布尔型
        boolean flag = true;
        boolean flag2 = false;
        
        // 拓展一种 引用数据类型， 后面会使用
        // String ： 称之为字符串类型， 定义的变量可以用于记住一个字符串
        String str = "dhajhad中国";
    }
}

变量的命名法则

/**
 * 关键词：Java语言自己要用到的一些词，有特殊用途的，我们称之为关键词， 例如： public class int double
 *          注意：关键词是java用了的，我们就不能用来 做为： 类名，变量名，否则会报错
 *
 * 标识符：就是名字， 我们写程序时会起的一些名字，比如类名， 变量名等等都是标识符
 *          标识符的命名要求：
 *              基本组成：数字 字母（区分大小写） 下划线 and $
 *              强制要求：不能以数字开头， 不能用关键字作为名字，区分大小写
 *          建议规范：
 *              变量名称： 首字母小写，驼峰命名法
 *              类名称： 首字母大写，驼峰命名法
 */

四，ASCLL 与2/8/16进制数

public class ASCIIDemo {
    public static void main(String[] args) {
        //目标：掌握ASCII编码表的编码特点
        System.out.println('a' + 10);   //说明‘a’的ASCII码是 97
        System.out.println('A' + 10);   //说明‘A’的ASCII码是 65
        System.out.println('0' + 10);   //说明‘0’的ASCII码是 48

        // ！！！Java程序中支持书写二进制、八进制和十六进制 分别需要以0B或者0b、 0、 0X或者0x开头
        int a1 = 0B001101;
        System.out.println(a1);

        int a2 = 0127;
        System.out.println(a2);

        int a3 = 0xFA;
        System.out.println(a3);

        //在计算机中表示数据的最小组成单元是：字节， 1B = 8byte
        //在B的基础上，计算机发展出来了： KB，MB,GB,TB,PB、EB、ZB、YB、BB、NB、DB、CB
    }
}

五，变量的类型转换

 1, 自动类型转换
什么是自动类型转换，为什么要进行自动类型转换？
      类型范围小的变量， 可以直接赋值给类型范围大的变量。
          byte -> short -> int -> long -> float -> douhble
          char -> int

      转换机制：（高位扩展）
          byte a = 12;     //  0 000 1100
          int i = a;       // 0 000 1100 -> 0 000 0000 00000000 00000000 00001100

  2，表达式的自动类型转换
      在表达式中，小范围类型的变量， 会自动转换成表达式中较大范围的类型，再参与运算
         byte,short,char -> int -> float -> double
      注意事项：
          表达式的最终结果有表达式中的 最高数据类型决定。
          再表达式中， byte，short，char是直接转换为 int类型参与运算的 (易错点)

  3，强制类型转换
      默认情况下，大范围类型的变量直接赋值给小范围类型的变量会报错！

      可以强行将范围类型大的变量，数据 赋值给范围类型小的变量
          格式： 数据类型 变量 = （数据类型） 变量，数据
      Tips：变量自增自减时（i++,--i）这里也有个强制类型转换噢

      强势类型转换需要注意那些？
          可能会出现数据丢失
          小数强制类型转换整数，是直接截断小数保留整数

public class TypeConversion {
    public static void main(String[] args) {
        {
            //目标：理解自动类型转换机制
            byte a = 12;
            int b = a;      //发生了自动类型转换
            System.out.println(a);
            System.out.println(b);

            int c = 100;  //4字节
            double d = c;   //8字节， 发生了自动类型转换
            System.out.println(d);

            char ch = 'a';      // 'a' : 97 ==> 00000000 01100001
            int i = ch;     //发生了类型转换
            System.out.println(i);
        }

        {
            //掌握表达式的自动类型转换
            //注意事项1
            byte a = 10;
            short b = 20;
            int c = 30;
            long d = 40;
            long e = d + a + c;  //最高数据类型为long
            System.out.println(e);

            double res2 = a + b + 1.0;  //注意： 1.0是double类型噢,用int接受会报错
            System.out.println(res2);

            //注意事项2
            byte i = 2;
            short j = 20;
            //short res = j + i;    会报错噢，认真理解那句话
            int res3 = i + j;
            System.out.println(res3);

            //面试笔试
            byte b1 = 110;
            byte b2 = 80;
            int b3 = b1 + b2;   //注意 表达式中 b1 b2就以及以int类型参与运算啦
            System.out.println(b3);

        }

        {
            //掌握强制类型转换
            int a = 20;
            //byte b = a
            byte b = (byte) a;      // AIT + ENTER 强制类型转换
            System.out.println(a);
            System.out.println(b);

            int j = 1500;
            byte m = (byte) j;
            System.out.println(m);    //数据丢失
            /*
                大范围数据转小范围数据：方法：（直接） 高位截断，保留低位
             */
        }

    }
}

六，Java中的运算符

1，算术运算符

        算术运算符 有 加+、减-、乘*、除/

        注意事项：1，整数除法结果一定为整数；

                          2，'+'符号做连接符（当与字符串连用时）：一定要搞清规则：能算则算

                          3，关于变量的自增自减：++i与i++的qubie；自增自减只能在作用于变量

public class OperatorDemo1 {
    public static void main(String[] args) {

        {
            //目标： 掌握基本的算术运算符的使用
        /*
            加   +
            减   -
            乘   *
            除   /   :与数学中的除相同，但是Java中（两个整数）相除是结果为整数
            取余 %
         */
            int a = 10;
            int b = 3;
            System.out.println(a + b);
            System.out.println(a - b);
            System.out.println(a * b);
            System.out.println(a % b);
            System.out.println(a / b);


            System.out.println(5 / 2);      //两个整数相除 结果一定为整形数
            //如果影响要小数呢
            System.out.println(5.0 / 2);    //结果： 2.5

            //如果出现以下情况，但又想保留小数 怎么办
            int i = 5;  //这里不能写 5.0。 因为5.0是double型
            int j = 2;
            System.out.println(i / j);  //结果是 2
            System.out.println(1.0 * i / j);    //牛崩啊

            System.out.println(i % j);

            // ‘+’符号可以做连接符（与字符串一起时）：‘+’符号与字符串运算的时候 是用作连接符的，其结果仍然是一个字符串
            //什么时候加号什么时候链接呢：    能算则算，不能算就连接
            int res = 5;
            System.out.println("abc" + res);
            System.out.println(10 + res);
            System.out.println(res + 'a' + "tsm"); // res + 'a'能算：102， 102 + "tsm"不能算   ！！！认真分析其运行结果
        }
    }
}

        {
            //目标掌握自增自减 ++ --  ：只能操作变量， 不能直接作用于字面量上： 2++（这是错的）
            // 自增 ++ ：放在变量前面或者后面，对变量自身的内容的值加1
            // 自减 -- ：放在变量前面或者后面，对变量自身的内容的值减1

            //前后的区别
            int i = 10;
            int res1 = ++i; // ++变量：变量先自增再使用该变量
            int res2 = i++; // 变量--：变量先使用再进行自增
            System.out.println(res1);
            System.out.println(res2);   //res2分析出来了就理解了
            System.out.println(i);

            int m = 5;
            int n = 3;
            int result = ++m - --m + m-- - ++n + n-- + 3;
            System.out.println(result);
            System.out.println(m);
            System.out.println(n);


        }

赋值运算符

关系运算符

public class OperatorDemo2 {
    public static void main(String[] args) {

        {
            //1,掌握 赋值运算符 以及扩展运算符的使用
            int m = 5;
            int n = 3;
            int result = ++m - --m + m-- - ++n + n-- + 3;
            //注意 赋值运算符是从右往左看： 也就是说：
            // （算术运算是遵行加减乘除法则嘛 + 从左往右）++m - --m + m-- - ++n + n-- + 3 == 9， 然后将9赋值给result变量
            System.out.println(result);
            System.out.println(m);
            System.out.println(n);

            //扩展运算符： += -= *= /= %=
            //eg： 符号：+=     用法：a += b   作用：加后赋值(注意这里还有个强制类型转换)     底层代码形式： a = (a的数据类型)(a + b)
            double i = 600;
            double j = 520;
            i -= j;     // i = (double)(i - j)
            System.out.println(i);

            int  r = 10;
            int s = 5;
            r /= s;
            System.out.println(r);

            System.out.println("----------------------------");
            //回想之前有个问题：
            byte x = 10;
            byte y = 30;
            //x = x + y;  //Required type:byte    Provided:int: 编译报错
            //x = (byte) (x + y);     //这样是可以的
            x += y;     //等价于上一句啊，精髓理解
            System.out.println(x);
        }


        {
            //在java中判断是否相等一定要用"==",千万不能写成"="
            //目标： 掌握关系运算符的基本使用
            //关系运算符： >  <   >=  <=  ==  !=      返回值： true / false
            //eg: 符号：>=   例子：a >= b     作用：判断a是否 大于或者等于 b     结果：成立返回true，不成立返回false
            int a = 10;
            int b = 5;
            boolean res = a > b;
            System.out.println(res);

            System.out.println(a >= b);
            System.out.println(a < b);
            System.out.println(a <= b);
            System.out.println(a == b);
            System.out.println(a != b);

            System.out.println(a = b);  //看看这个是什么结果

        }

    }
}

逻辑运算符

三目运算符

public class OperatorDemo3 {
    public static void main(String[] args) {
        {
            //3,逻辑运算符： 将多个条件放在一起运算，最终返回布尔类型的值：true ， false
            /*  topic 1
            目标：掌握逻辑运算符的基本使用
                符号      叫法      例子           运算逻辑
                &       逻辑与     2>1 & 3>2
                |       逻辑或     2>1 | 3<5
                !       逻辑非     !(2>1)
                ^       逻辑异或    2>1 ^ 3>1       前后条件结果相同就直接返回false，天后条件不同则返回true（多个条件就数为真的个数）
             */
            //需求：要求手机必须满足尺寸大于等于6.98， 且内存必选大于等于8
            double size = 6.8;
            int storage = 16;
            boolean res1 = size >= 6.98 & storage >= 8;
            System.out.println(res1);

            //需求：要求手机必须满足要么尺寸大于等于6.98， 要么内存必选大于等于8
            boolean res2 = size >= 6.98 | storage >= 8;
            System.out.println(res2);

            //!取反的意思
            System.out.println(! true);
            System.out.println(! false);
            System.out.println(! (2 > 1));

            //^异或
            System.out.println(false ^ true ^ true ^ false ^true ^ false ^ false);


            /*  topic 2
            目标：掌握逻辑运算符的基本使用
                符号      叫法      例子           运算逻辑
                &&       逻辑与     2>1 & 3>2      判断结果于“&”一样，过程不一样：左边为false，右边则不执行
                ||       逻辑或     2>1 | 3<5      判断结果于“|”一样，过程不一样：左边为true，右边则不执行

                注： 在java中， “&”，“|”：无论左边是false还是true，都要计算右边
                新知识点啊，牢记。在java中双与双或的开发效率更高，因此在开发中经常被使用
             */

            //&&， 左边为false，则右边不执行
            int i = 10;
            int j = 20;
            System.out.println(i > 100 && ++j > 99);
            System.out.println(j);  //说明右边未执行

            System.out.println(i > 100 & ++j > 99);
            System.out.println(j);  //说明右边执行了

            //|| 左边是true，右边不执行
            int m = 10;
            int n = 30;
            System.out.println(m > 3 || ++n >40);
            System.out.println(n);

            System.out.println(m > 3 | ++n >40);
            System.out.println(n);

            /*  topic 3
                与 二进制/八进制/十六进制数的 集合应用

                &： 按位与
                |： 按位或

                >>(右移运算符)

                <<(左移运算符)
             */
        }

        {
            //4， 三目运算符，以及运算符优先级
            /*
                三目运算符介绍；
                    格式： 条件表达式 ？ 值1 ： 值2
                    含义：当关系表达式的结果为true时，返回值1； 否则返回值2
            */
            double score = 98.5;
            String res = score > 60 ? "成绩及格" : "成绩不及格";
            System.out.println(res);

            //找出两个整数中的较大值
            int a = 891;
            int b = 392;
            System.out.println(a > b ? a : b);

            /*
                运算符优先级！！！！从左往右优先级降低：
                    1,()    2,!,++,--     3,*,/,%
                    4,+, -  5,<<, >>, >>>(移位运算符)
                    6,<, <=, >, >=      7,== , !=(关系运算符)
                    8,&     9,^     10,|
                    11,&&   12,||   (逻辑运算符)
                    13, ? :     (三目运算符)
                    14 , = += -+ *= /= %=

               很明显：算术运算符 》 关系运算符 》 逻辑运算符
             */
            System.out.println(10 > 3 || 10 > 3 && 10 < 3);     //好好悟透吧
            System.out.println((10 > 3 || 10 > 3) && 10 < 3);
        }

    }
}

  好好吃饭好好睡觉，小飞猪！！！