回顾：
Java ：虚拟机  sandbox
jre  ：jvm +核心类库
jdk     ：jre + 工具 ，javac  java

设置变量： java_home
path=搜索顺序。例如（notepad calc mapaint binary)

classpath=java搜索类的顺序。
Java -classpa 目录（d:\java;d:\;.)

关键字
------------
    被Java语言赋予特殊含义的单词。（所有字母为小写）
    如：class interface byte return.....

    byte     //字节
    short     //短整型    2 bytes
    int     //整型        4 bytes
    long    //长整型    8 bytes
    float     //浮点型
    double     //双精度浮点型
    [访问权控制]
    private      //私有的
    protected    //受保护的
    public        //公共的

    ｛class function modifier｝尝试
    abstract         //抽象
    final            //最终的
    static            //静态的    
    synchronized    //同步
    extends         //扩展（应用于class中）
    implements        //实现（实现于class中）
    new                //创建
    this            //当前
    super            //超类，父类
    instanceof        //是否是xxx实例（对象）
    try                //尝试
    catch            //捕获
    finally            //最终
    throw            //抛出
    throws            //定义类声明时，抛出异常。
    package            //包
    import            //导入  <--> export
    native            //本地的
    transient        //暂时的，瞬时，临时  <--> persistent
    assert            //断言

标识符（名称)
----------------
    英文字母
    数字
    _   $

    严格区分大小写

    命名格式：

    包名： aaa.bbb.ccc.ddd(文件层级关系)
    类名和借口名  ：首字母大写（驼峰命名法）XxxYyyZzz
    变量和函数 ：convertStr2Int(第一个单词首字母小写，以后的单词首字母大写)
    常量：  final String BRAND ="benz"    XXX_YYY_ZZZ(全部大写)
    注释： 单行  //        (sql 注释 --)
           多行  /* */
           文档注释(javadoc 提取所有文档注释)
           /**
           *
           */

    常量：Java中的常量的分类
        1.所有整数
            byte short int long  默认是int
        2.所有小数
            float  double    默认 double
        3.布尔(boolean)型常量，
        4.字符常量   ( '')
            char
        5.字符串常量 ( "")
        6.null 常量：只有一个数值 ： null

        整数的四种表现形式：
            二进制： 0 1  满2进1
            八进制： 0-7  满8进1  用0开头（一般不用，表示方法容易混淆)
            十进制： 0-9  满10进1.
            十六进制：0-9，a-f  满16进1 用0X开头表示

        2^10=1024(byte)=1K
        2^20=1024k=1M
        2^30=1024M=1G
        2^40=1024G=1T

        负数采用补码方式存储：正数取反+1；
        原理：正负数相加等于0 。把第9位的1 溢出
        例如：
                0000 0101
                1111 1011

        例如 -6  一个字节的表现形式：
            0000 0110 （6）
                    ^
            1111 1001
                    + 1
            1111 1010(-6)    

            -1 取反  求+6(验证正数：利用负数 -1  取反)
            1111 1010（-6）
                    -1
            1111 1001
                    ^
            0000 0110(6)

            -1 的表现形式：
            0000 0001 （1）
                    ^
            1111 1110
                    + 1
            1111 1111(-1)

            -128  表现形式

            1000 0000 （128）
                    ^
            0111 1111
                    +1
            1000 0000    (-128)
Java中基本数据类型（primitive)
    默认的整数int  默认浮点数 double
    升格 自动转换    隐士转换
    降格 强制转换     显示转换

    表达式的数据类型自动提升
        所有byte 型，short 型和char型的值将被提升到int型
        如果一个操作数是long型，计算结果就是long型
        如果一个操作数是float型，计算结果就是float型
        如果一个操作数是double型，计算结果就是double型

    例子：
    class TypeDemo{
    public static void main(String [] args){
        int i = 128;
        byte b3 = (byte)i;//这里不强制转换。编译提示缺失精度。
        //结果是-128？？？
        System.out.println(b3);
        }

    }
    以上用到2个知识点：
        1：b3的类型是byte 是1个字节。 i 的类型是int 是4个字节。
        将i 赋值给 b3 需要强制转换。
        2：强转后的精度缺失。
        int  i ：      0000 0000   0000 0000   0000 0000   1000 0000    （整型128）
        byte b3:                                           1000 0000    （-128）

        截取了剩下： 1个字节即    1000 0000    
        1000 0000 数值=？
        1000 0000
                ^
        0111 1111
                +1
        1000 0000 (-128)
    算术运算符：注意问题。
        1.取模： %    5%-2 = 1；（对负数取模，模数负号忽略不计)
        2."/"除号,它的整数除和小数除是有区别的：整数间做除法：保留整数部分舍弃小数部分。
            例如：int x = 3510; x = x/1000*1000; x 结果：3000；
        3."+"除字符串想加功能外，还能把非字符串转换成字符串。
            System.out.println("5+5="+5+5)//打印结果是？
            5+5=55
    short s = 3;
    s = s +3;//编译通不过，需类型转换
    s+=3; //可以通过，有内置的类型机制

    &&  ||  存在短路现象 。boolean1 &&(||) boolean2  如果boolean1  满足条件，boolean2 不参与运算

    ^ :boolean1 ^ boolean2   true ^ false   true
    ! : !boolean 取反操作。
    ~ ： 按位取反。

    注意：Java中不可以 写成 3<x<6  ,应该写成  x>3 & x<6;

    "&" 和 "&&" 的区别：
    单& 时，左边无论真假，右边都进行运算。
    双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
    "|"和"||"的区别同理，双或时，左边为真，右边不参与运算。
    异或(^)与或(|)的不同之处是：当左右都为true时，结果为false。


    &运算 权限的分配：   1111 & 0100     1111 & 1000      1111 & 0010    1111 & 0001

    逻辑运算不存在短路的理由：
        一般用于权限中：用最大权限(是(|)或运算而不是简单相加：避免重复。) & 单个权限。如果为true（真）则有权限。如果为false（假）没有权限。
        无论。有没有权限，两边都参与运算。
    位运算 对二进制的操作。

判断结构：if else
    switch
        支持的类型 byte short int char
        结束：遇到break; 或者 程序运行到switch结尾。
    简写案例：（需求判断 月份属于那个季节）

class SeasonDemo
{
    public static void main(String[] args)
    {
        int x = 7;
        switch (x)
        {
            case 12://System.out.println("冬季");可以省略
            case 1://System.out.println("冬季");可以省略
            case 2:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("不存在的月份");
        
        }
    }
}
这里使用一个简单的算法进一步简化算法：如下
    int x = 12;
        if(x <1 | x>12){
            System.out.println("不存在的月份");
            return;
        }
        int y = (x+2) /3;//精华部分算法。
        System.out.println(y);
        switch(y){
            case 1:
                System.out.println("1季度");
                break;
            case 2:
                System.out.println("2季度");
                break;
            case 3:
                System.out.println("3季度");
                break;
            case 4:
                System.out.println("4季度");
                break;
            default:
                System.out.println("计算不到值");
        }
//int y = (x+2) /3;//精华算法?

循环
    while(){}    VS   do{}while();(先执行一次在判断条件)

    for(初始化表达式;循环条件表达式;循环后的操作表达式)
    {
        执行语句; (循环体)
    }

    while 和for 可以互换，区别在于for 为了循环而定义的变量在for循环结束时就在内存中释放，
                                  while 循环使用的变量结束后还可以继续使用。
练习用2中循环打印99

class SeasonDemo
{
    public static void main(String[] args)
    {
        for(int i = 1;i<10;i++){
            for(int j =1;j<=i;j++){
                System.out.print(j+"x"+i+"="+j*i+"\t");
            }
            System.out.println();
        }
        int a=1;
        while(a<10){
            int b =1;//位置很重要，第一次和int a= 1 写到了一起。结果：每次都是b ==a  没有循环。
                    //为了循环每次都需要初始化b 的值，才可以从1开始循环，不然永远都是 b ==a ;
            while(b<=a){
                
                System.out.print(a+"x"+b+"="+a*b+"\t");
                b++;
            }
            
            System.out.println();
            a++;
        }
    }
}

函数：（function）
    1.一段独立的程序
    2.修饰符  返回值 函数名(参数类型1 参数名称1,参数类型2 参数名称2,.....){
            函数body;
            return ; //只有void 类型 的返回值才可以不写 return
        }
    3.形参只是在函数内有效（类似 for）
    注意：函数中只能调用函数，不可以在函数内部定义函数。（ 不可以嵌套）
        定义函数时，函数的结果应该返回给调用者，交由调用者处理。

函数的重载（overload）
    在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
    返回值类型无要求，只看类型。