何为要发明计算机：为了进行科学计算，复杂的科学计算。
人类如何和计算机沟通，去分配任务。 通过计算机语言 实现 人类和计算机的交流。

计算机语言的发展史：
    大概的经历了三个阶段
    1：机器语言：计算机可以直接识别的语言。
        计算机可以直接识别的语言是二进制的语言。
        任何的计算机系统都有自己的指令的集合。计算机只能识别自己的指令集合中的二进制指令形式。
        0101

    1 + 1
    +：1010
    1010 0001 0001
    优点：运行的效率快。
    缺点：可读性很差，编写程序的门槛很高。

    
    2：汇编语言：指令集中每一个指令都使用了一个 字符序列来代替。
    1 + 1
    ADD 0001 0001   糖语法
    优点：代码可读性增强了，指令也更容易记忆了。
    缺点：多了一个编译的过程。


    3：高级语言： c  c++  java  c#
    1 + 1
    优点：开发的效率高了，可读性好了。学习的门槛降低了。
    缺点：需要将更高级的语法转换为 机器语言的形式。（编译 or  解释）。影响了最终的效率。

1991年，Sun公司的Green项目，Oak
1995年，推出Java测试版
1996年，JDK1.0
1997年，JDK1.1
1998年，JDK1.2，大大改进了早期版本的缺陷，是一个革命性的版本，更名为Java2
1999 Java被分成J2SE、J2EE 和J2ME，JSP/Servlet技术诞生

J2SE：java 2 standard edtion。针对客户端，桌面程序开发的。标准版。
J2EE：java 2 Enterprise edtion  针对服务器端开发的。企业版。
J2ME：java 2 micro edtion 针对手持设备开发的。微型版。

2004年，J2SE 5.0 (1.5.0)  Tiger老虎.为了表示这个版本的重要性，J2SE1.5更名为J2SE5.0。 
2006年，J2SE 6.0 (1.6.0)  Mustang野马.此时，Java的各种版本被更名，取消其中的数字"2"：J2EE更名为Java EE, J2SE更名为Java SE，J2ME更名为Java ME 
2009年4月20日甲骨文收购Sun公司，交易价格达74亿美元
2011年，JavaSE7.0 
2014年，JavaSE8.0

了解
特点：

Java是简单的：
不再有#include 和#define 等预处理功能
不再有struct,union及typedef
不再有函数、
不再有指针、不再有多重继承
不再有goto      
不再有操作符重载(Operatior Overloading)
不再有全局变量           取消自动类型转换,要求强制转换
不再有手动内存管理

Java是安全的：取消了指针，自动内存回收。


Java是完全面向对象的：继承、封装、多态


Java是健壮的：Java的强制类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证


java 最大的特点和优势。
java 的跨平台。

通过 dos 窗口 编译源代码。

javac  HelloWorld.java
回车：首先会在当前目录下找javac.exe ,如果当前目录下没有，会去环境变量 配置的path 的一个目录集合中去挨个查找。

配置环境变量 path。将 javac.exe 所在的目录添加到 path 中去。


配置环境变量的作用：
建议只配置path。
为了在 cmd 窗口中可以直接使用 javac 和 java 外部命令。

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("Hello World!");
    }
}

public：java 的权限修饰符。
class：java的关键字
HelloWorld：类的名字，首字符大写。
public static void main(String[] args)：入口方法，main 方法。格式是固定的。程序开始执行的地方。
将需要执行的代码 写到 main 方法中。
System.out.println("Hello World!");
将双引号中的内容（字符串）原样输出到cmd 窗口。还输出了一个换行符。



如何配置环境变量：
我的电脑-->右键属性-->高级系统设置-->环境变量--->在path 的末尾 添加 javac 编译程序所在的 目录的 bin目录。使用 半角分号 分割不同的目录。

如何编译和运行java 程序。
在 cmd 窗口中。首先要切换到 源代码所在的目录（使用英文目录）。然后使用 在命令行输入 javac HelloWorld.java 回车。
会生成一个.class 文件。  如果编译不成功。需要修改源代码。切记保存。重新编译。javac HelloWorld.java 回车。
然后，解释执行 class   命令行：java HelloWorld  回车。

public class Introduce{
    public static void main(String[] args){
        System.out.println("我是小杨老师！~");
        System.out.println("我是沧州人士！自幼习武！中途放弃！");
        System.out.println("欢迎大家来到北京尚学堂学习！");
        System.out.println("希望大家在接下来的时间里，好好学习，天天向上！不搞对象！");
        System.out.println("将来毕业找一个满意的工作，实现人生的理想！然后迎娶白富美，走向人生的巅峰！");
    }
}

public class SystemTest{
    public static void main(String[] args){
        System.out.println(10);//直接书写一个数字，那么默认为10进制。
        System.out.println(0b1010);//二进制 高位添加 0b jdk1.7开始支持二进制
        System.out.println(012);//八进制  高位添加0
        System.out.println(0xa);//十六进制 高位添加0x
    }
}


四种进制的特点：
十进制：逢十进一，每一位上出现的数值的取值范围[0-9]
二进制：逢二进一，每一位上出现的数值的取值范围[0-1]  计算机底层使用二进制表示所有的数据。
八进制：逢八进一，每一位上出现的数值的取值范围[0-7]
十六进制：逢十六进一，每一位上出现的数值的取值范围[0-15]  必须使用一个字符表示[10-15] [a-f][A-F]

二进制：
一位二进制位 有两种状态 0、1。称之为1 bit。
1bit 是计算机中最小的存储单元了。
8 bits-->1 byte
1024 bytes--->1 KB
1024 KB--->1 MB
1024 MB--->1 GB
1024 GB--->1 TB
1024 TB--->1 PB

计算机通常使用字节为单位来处理数据。

使用四种进制来表示 0-15
二进制        八进制        十进制        十六进制
000     　　    0       　　 0     　　 　   0
001     　　    1       　　 1     　　　　  1
010     　　    2      　　  2    　　　　   2
011     　　    3      　　  3     　　　　  3
100     　　    4      　　  4      　　　　 4
101     　　    5       　　 5     　　　　  5
110     　　    6      　　  6     　　 　　 6
111     　　    7      　　  7     　　 　　 7
1000    　　    10    　　   8   　　   　　 8
1001    　　    11    　　   9   　　   　　 9
1010    　　    12     　　  10   　　      a
1011    　　    13     　　  11   　　      b
1100    　　    14     　　  12  　　       c
1101    　　    15     　　  13   　　      d
1110    　　    16      　　 14    　　     e
1111    　　    17      　　 15   　　      f

10000    　　   20      　　 16        　 　10
10001    　　   21      　　 17       　 　 11
10010    　　   22      　　 18      　　   12

1个二进制位 能表示2种状态。
2个二进制位 能表示4种状态。
3个二进制位 能表示8种状态。
4个二进制位 能表示16种状态。
n个二进制位 能表示2的n次幂种状态。

需求：使用四种进制来表示10并打印输出，并把-1的二进制字符串形式打印
    //10使用四种进制来表示输出
public class SystemTest{//18
    public static void main(String[] args){
        System.out.println(10);//直接书写一个数字，那么默认为10进制。
        System.out.println(0b1010);//二进制 高位添加 0b jdk1.7开始支持二进制
        System.out.println(012);//八进制  高位添加0
        System.out.println(0xa);//十六进制 高位添加0x
        //将-10 的二进制的字符串的形式打印
        System.out.println(Integer.toBinaryString(-1));//1111111111111111111111110110
        System.out.println(Integer.toBinaryString(-10).length());//32
    }
}

变量：Variable。
概念：变量的本质是一块内存区域，该内存区域中的值可以被修改。

局部变量：在方法内部定义的变量，称为局部变量。

局部变量定义的语法：
变量类型 变量名 = 初始值;

变量类型：java支持的任意类型。
变量名：合法的标识符

定义变量可以分为2步进行：
    变量类型 变量名;---->变量的声明
    变量名 = 初始值;---->变量的赋初值

变量的定义=======变量的声明+赋初值

局部变量的特点：
    局部变量必须先定义后使用。
    局部变量的内存在栈中分配。



//定义一个标识符，名字为 age，并给age 标识符对应的内存存一个short类型的值。
public class SimpleTypeTest{//18
    public static void main(String[] args){
        //数据的类型  标识符名字 = 初始值。
        //向jvm 申请一块内存，名字为age ，内存中的数据的类型为 short。占用2个byte。
        short age = 19;
        System.out.println(age);
        //定义标识符 用来存储 高考的分数 int 、圆周率 double 、班级中是否有女生 boolean。将内存中的数据全部依次打印。
        int score = 555;
        double pi = 3.1415926;
        boolean isGirlInClass = true;
        System.out.println(score);
        System.out.println(pi);
        System.out.println(isGirlInClass);
        
        
        //
        int weight;
        weight = 68;
        System.out.println(weight);//获取变量的值
        //weight = 70;
        weight = weight + 2;
        System.out.println(weight);//获取变量的值
        
    }
}

//变量的各种语法定义
public class VariableTest{//18
    public static void main(String[] args){
        int a1 = 10;
        int a2 = 20;
        
        int b1 = 10, b2 = 20, b3 = 10;
        
        int c1, c2, c3;
        c1 = 32;
        c2 = 45;
        c3 = 67;
        
        int d1, d2 = 34, d3;
    }
}

java 中的常量 分为两种。

1：字面常量。通过数值的字面就可以知道数值的大小。
    字面常量有默认类型，类型由 编译器 指定。
    整数的默认类型为 int。如果超过了int 的范围，需要在末尾添加 L or l 来告诉编译器 当long类型来处理。
    浮点数的默认类型为 double。如果一个浮点数常量需要当作 float 来对待，那么需要在末尾添加 F or f。
    true false，默认是 boolean
    "字符串"  ‘A‘ 字符

2：不可变的变量。使用 final 关键字 修饰。终态变量。
    在变量的类型前添加关键字 final 即可。
    特点：只能初始化一次。只有获得变量值的权利，没有修改变量值的权利。


//不可变的变量 final
public class FinalTest{//18
    public static void main(String[] args){
        final double PI = 3.14;
        System.out.println(PI);
        //pi = 4.0;
        
        final int MAX_AGE;
        MAX_AGE = 135;
    }
}

char 类型：可以当作整数来对待。 无符号的短整型。没有负数.取值范围 [0-65535].


字符集：字符的集合。字符集合中的每一个字符都对应着一个唯一的整数。

ASCII：单字节字符集。只用到了一个字节的后7位。128个字符。
    ‘0‘--->48
    ‘A‘--->65
    ‘a‘--->97

ISO8859-1: 西欧使用的字符集，单字节字符集。256个字符。兼容了ASCII。

gb2312：双字节字符集。兼容了ASCII。主要收录了中文简体。

GBK：兼容了 gb2312.增加了繁体中文，还有各个少数民族的符号。

utf-8：三字节的字符集。兼容了 ASCII。

Unicode：万国码。java 使用的字符集。jvm 使用的。保证所有的国家的符号都能识别。


转义字符：
\t：水平制表符  对应着键盘上的Tab键。
    作用：\t占用的半角的个数为[1-8].从\t包括之前的输出的内容。总共占用的半角的位数必须是8的倍数。\t用来补齐8个半角位的倍数的。
\b: 退格符：     对应着键盘上的 Backspace 键。
\r: 回车符：    让光标回到当前行的行首，后续的输出从行首输出。
\n: 换行符：    让光标去下一行。
    Enter 键对应两个字符：\r\n  让光标去到下一行的行首。

\‘ :字符单引号。
\" :字符双引号。
\\ :字符反斜杠。




//char 类型
public class CharTest{//18

    public static void main(String[] args){
        char myChar = ‘A‘+32;//65
        char myChar2 = 48;//0
        char myChar3 = ‘\u0064‘;//转义序列
        
        System.out.println(myChar);
        System.out.println(myChar2);
        System.out.println(myChar3);
        
        int age = 19;
         //字符串可以和任意类型 使用 + 连接符 将字符串和 基本数据类型的数据做连接。然后整体输出
        System.out.println("我的年龄：\t" + age);
        
        System.out.println("1234\"56789");
        System.out.println("\t123456789");//8个
        System.out.println("1\t23456789");//7个
        System.out.println("1234567\t89");//1
        System.out.println("12345678\t9");//8个
        
        System.out.println("1234\r56\n789");
        
        System.out.println(‘\‘‘);
        System.out.println(‘\\‘);
        
    }
    
}

//根据键盘输入，输入一个圆的半径，求圆的周长和面积。
//告诉编译器 Scanner 来自哪里
//java.lang 包是java 的核心包。核心包中所有的内容都是被默认导入的。
//* 代表通配符，代表所有。
import java.lang.*;// 这行代码写不写都会存在。
import java.util.Scanner;
public class ScannerTest{//18
    public static void main(String[] args){
        //使用jdk 已经定义好的类。扫描器类。
        //创建一个扫描器对象,扫描键盘输入   System.in 对应着我们的标准输入设备-->键盘
        //java.util.Scanner scanner = new java.util.Scanner(System.in);
        Scanner scanner = new Scanner(System.in);
        //提高用户体验  UE 
        System.out.println("请您输入圆的半径：");
        //使用扫描器对象去接收键盘输入的一个整数。并返回该接收到的整数。
        int radius = scanner.nextInt();//阻塞式方法。会导致程序的阻塞。解除阻塞之后，程序继续执行。
        
        // 半径、周长、面积、圆周率
        //定义变量
        //int radius = 7;
        final double PI = 3.14;
        double area;
        double length;
        
        //求圆的周长和面积
        length = 2 * PI * radius;
        area = PI * radius * radius;
        
        //最后打印输出结果
        System.out.println("半径是："+radius + "\t的圆的周长 = "+length + "\t面积 = "+area);
    }
}

java 中的注释： comment。

注释的作用：可以帮助开发者更好的理解，记忆，阅读程序代码的。

注释部分的内容，不参与编译。

给程序添加合适的注释是作为一个程序员的基本修养。

java中支持的注释的类型：
    三种：
    1：单行注释：    //后面的内容都是注释的内容。
    用法：
        1：注释的内容单独占用一行，解释下面一行的内容。
        2：在一行代码的末尾。添加注释。短注释。一般注释的内容不超过10个字符。
        3：将一行代码注释掉，让代码失效的。

    2：多行注释：    /*注释的内容*/
        用法：多行、单行、一行的一部分。

    3：文档注释：    /**注释的内容*/
        帮助我们生成代码的阅读文档的。
        

1：float 和 double 很多时候不能精确的表示一个小数。
    3.3
0b0.1--->0.5
0b0.01--->0.25
0b0.001--->0.125

小数点后的第n位上的1 对应的十进制小数的值为 1/2^n

float  和  double 不是为了精确运算而设计的。
float 和 double 很多时候只是近似表示 某个小数。


0.3F
0.0101010100000001010101

0.0101010101

1:java 程序支持哪些运算符。可以使用哪些运算符对数据进行计算。

概念：
1：操作数：参与运算的数据 称为操作数。
2：表达式：运算符和操作数的整体 称为表达式。
    单独的一个操作数也可以看作一个最简单的表达式。  int age = 1+1;
3:返回值：操作数 或者是 表达式 参与 运算的结果。

注意：参与所有运算的数据，都是操作数 或者 表达式的 返回值 参与的。

4：一元运算符：只需要一个操作数的运算符。也叫做 单目运算符。
5：二元运算符：需要两个操作数的运算符。也叫做 双目运算符。
6：三元运算符：需要三个操作数的运算符。也叫做 三目运算符。


一：算术运算符：
+
-
*
/
%
++
--


//算术运算符
public class MathTest{
    public static void main(String[] args){
        int num0 = 10, num1 = 20;
        //+  既是一个一元运算符，也是一个二元运算符。
        System.out.println(+ num0);//一元运算符
        System.out.println(num0 + num1);//二元运算符
        //-  既是一个一元运算符，也是一个二元运算符。
        System.out.println(- num0);//一元运算符
        System.out.println(num0 - num1);//二元运算符
        //*  二元运算符  两个操作数的乘积  运算的规则和数学中一样一样的。
        System.out.println(num0 * num1);//二元运算符
        System.out.println(-num0 * num1);//二元运算符
        System.out.println(num0 * -num1);//二元运算符
        System.out.println(-num0 * -num1);//二元运算符
        // / 二元运算符     两个操作数相除。运算的规则和数学中一样一样的。
        //如果两个操作数都是整数，那么结果为相除的整数部分。没有四舍五入。
        System.out.println(num0 / num1);//二元运算符
        System.out.println(-num0 / num1);//二元运算符
        System.out.println(num0 / -num1);//二元运算符
        System.out.println(-num0 / -num1);//二元运算符
        // % 二元运算符。a%b  a除以b 得到的余数  结果的符号位和左边的操作数一致。
        System.out.println(5 % 2);//1
        System.out.println(-5 % 2);//-1
        System.out.println(5 % -2);//1
        System.out.println(-5 % -2);//-1
        // / 和 % 的应用。 123.
        int num = 689;
        int unit = num % 10;
        int decade = num / 10 % 10;
        decade = num %100 / 10;
        int hundred = num / 100;
        System.out.println(num + "\t的百位：" + hundred + "\t十位：" + decade + "\t个位：" + unit);
        
        //自增运算符 ++ ：一元运算符  实现对变量自增一的操作。
        //两种模式：前缀模式  后缀模式。
        num = 0;
        num = num + 1;
        ++ num;
        num ++;
        System.out.println("num = "+num);
        //后缀模式：先返回后自增。num++ 表达式的返回值 是 num 自增之前的值。
        // num ++ 先计算了得到了返回值。自增之前的值。然后 num 做自增+1操作。然后将 num ++ 之前得到的返回值赋值给 age;
        int age = num ++;
        System.out.println("num = "+num + "\tage = "+age);
        num = 0;
        num = num ++;
        System.out.println(num ++ + num ++ + num ++);//3
        System.out.println("num = "+num);//3
        num = 0;
        //前缀模式：先自增 后返回   表达式的返回值是 自增之后的值。
        System.out.println(num++ + ++num + num ++ - ++num);//0
        
        //自减运算符： -- ：一元运算符  实现对变量的自减一 的操作。
        //后缀模式：先返回 ，后自减。。前缀模式：先自减后返回。
        
    }
}

求随机数[100-1000)
//获得随机数
public class RandomNumberTest{
    public static void main(String[] args){
        //得到区间[100-1000) 区间通常是 前闭后开的。前包含，后不包含。
        final int MIN = 100;
        final int MAX = 102;
        
        //Math.random() 同样有返回值。返回值是一个随机的double 值。[0.0~1.0)
        System.out.println(Math.random() * (MAX-MIN) + MIN);
        
        //int value = 0;
        //Math.random() * (MAX-MIN) + MIN  [100.0~ 1000.0)  去掉小数
        int value = (int)(Math.random() * (MAX-MIN) + MIN);
        
        System.out.println("value = "+value);
        
    }
}


//随机得到两个[10-20]的随机数，定义变量保存两个随机数。然后打印该随机数。
//实现交换两个变量的值。
public class ChangeValueTest{
    public static void main(String[] args){
        //定义区间
        final int MIN = 10, MAX = 21;
        
        int num1 = (int)(Math.random()*(MAX-MIN)+MIN);
        int num2 = (int)(Math.random()*(MAX-MIN)+MIN);
        
        System.out.println("num = "+num1 + "\tnum2 = "+num2);
        
        int temp = num1;
        num1 = num2;
        num2 = temp;
        
        System.out.println("num = "+num1 + "\tnum2 = "+num2);
        
        //使用异或来实现。根据异或的特点实现的。
        num1 = num1 ^ num2;
        num2 = num2 ^ num1;
        num1 = num1 ^ num2;
        System.out.println("num = "+num1 + "\tnum2 = "+num2);
        
    }
}

赋值运算符：
=：二元运算符。
赋值 操作  永远是 最后执行。
实现的功能：将右边表达式的返回值 赋值 给 左边的变量（可以是终态变量）。

= 左边 ：左值 left value
= 右边 ：右值 right value

左值：必须是变量 或者是 终态变量。
右值：可以是：
    常量 ： 1
    变量 ： age
    常量表达式：1 + 1 + 4
    变量表达式： x + y
    常量、变量表达式：1 + x;


左值的类型 要和 右值表达式的返回值的类型 要兼容。


复合赋值运算符：
+=
-=
*=
/=
%=


复合赋值运算符特点：
1：生成的字节码文件要稍微小一点点。
2：隐含了一个强制类型转换，强制转换的类型为 左边变量的类型。



//复合赋值运算符练习
public class AssignmentTest{
    public static void main(String[] args){
        
        int value = 10;
        
        //value = value + 10;
        value += 10;
        
        //value = value - 10;
        value -= 10;
        
        //value = value * 10;
        value *= 10;
        
        //value = value /10;
        value /= 10;
        
        //value = value % 10;
        value %= 10;
        
        byte age = 127;
        //age += 1;
        age = age + 1;
        
        System.out.println("age = "+age);
        
    }
}

关系运算符：表达的是 操作数之间的关系是否成立的。
    成立，关系表达式返回值为  true ，否则为 false。

6个关系运算符:
> : 大于：二元运算符。左边的操作数是否大于右边的操作数。
< ：小于：二元运算符。左边的操作数是否小于右边的操作数。
>=：大于等于：二元运算符。左边的操作数是否大于等于右边的操作数。
<=：小于等于：二元运算符。左边的操作数是否小于等于右边的操作数。
==：等于：二元运算符。左边的操作数是否等于右边的操作数。
!=：不等于：二元的。左边的操作数是否不等于右边的操作数。


>  <   >=  <= ：只适用于 数值型 包括 char 类型的数据。

==  != 适用于 java支持的所有的数据类型。


//复合赋值运算符练习
public class RelationTest{
    public static void main(String[] args){
        
        int num0 = 0;
        int num1 = 0;
        System.out.println(num0 + 1 > num1);//true
        boolean bool = num0 < ++ num0;
        System.out.println(bool);//true
        
        System.out.println(num0 == num0 ++);//true
        num0= 0;
        System.out.println(++num0 != num0 ++);//false
        
        float f1 = 11111111111111f;
        float f2 = 11111111111110f;
        System.out.println(f1);//1.11111108E13
        System.out.println(f2);//1.11111108E13
        System.out.println(f1 == f2);//true
        
    }
}

逻辑运算符：参与逻辑运算的操作数必须是 boolean 类型的数据。逻辑表达式的 返回值 也是 boolean 类型。

//逻辑运算符练习
public class LogicTest{
    public static void main(String[] args){
        // &  逻辑与 ：二元运算符。规则：有一个操作数是 false 那么结果就是false。两个都是true 的时候，结果才是 true。
        // 规律：有假 则 假 ，全真 则真。  表达的关系 是 并且的关系。
        System.out.println(true & true);//true
        System.out.println(true & false);//false
        System.out.println(false & true);//false
        System.out.println(false & false);//false
        System.out.println();
        // | 逻辑或：二元运算符。规则：有一个操作数是 true，那么结果就是 true，都是false 结果才是false。
        // 规律：有真则真，全假则假。 表达的是或者的关系。
        System.out.println(true | true);//true
        System.out.println(true | false);//true
        System.out.println(false | true);//true
        System.out.println(false | false);//false
        System.out.println();
        // ^ 逻辑异或  二元运算符  规则：两个操作数相异为 true 相同为false。
        System.out.println(true ^ true);//false
        System.out.println(true ^ false);//true
        System.out.println(false ^ true);//true
        System.out.println(false ^ false);//false
        System.out.println();
        // ! 逻辑非  逻辑取反  一元运算符。规则：true-->false  false--->true
        System.out.println(!true);//false
        System.out.println(!false);//true
        System.out.println();
        // && 短路与  条件与  
        System.out.println(true && true);//true
        System.out.println(true && false);//false
        System.out.println(false && true);//false
        System.out.println(false && false);//false
        System.out.println();
        // &  和 &&  的区别
        // &:进行逻辑与运算的所有的操作数，不管前面的操作数的返回值的结果是否是false，所有的操作数都会进行运算。然后进行逻辑运算。
        // &&: 进行 短路与运算的过程中，如果前面有操作数的返回值 是  false。
        // 那么后面的所有的操作数将不再计算，直接返回整个逻辑表达式的结果为false。
        // 短路与的效率往往高于逻辑与，所以建议使用短路与。
        int value = 0;
        System.out.println( (1>2) && (value ++ > 0));//false
        System.out.println("value = "+value);
        // | 和 || 的区别。
        // || 如果进行 短路或 运算，如果有一个操作数的结果为 true，那么后续的操作数将不再计算，而直接返回整个逻辑表达式的值 为  true.
    }
}

位运算符：
直接对底层的二进制位操作，效率相对较高。
位运算的数据的类型：整数、char。


//位运算符练习
public class BitTest{
    public static void main(String[] args){
        // &  按位与：二元运算符。 规则：低位对齐，进行按位与。 对应的位 有0则0  全1则1.
        System.out.println(3 & 5);//1
        //作用：1:可以将某个整数的某些二进制位设置为0。
        //2:可以得到某一个数的制定区间的二进制表示的数据。
        
        // | 按位或： 二元运算符。 规则： 低位对齐，进行按位或。对应的位，有1则1，全0则0
        System.out.println(3 | 5);//7
        //作用：
        //1:如果两个操作数 对应的位 上没有全1 的，那么进行按位或 和 加的效果一致。
        System.out.println(3 | 4);//7
        System.out.println(1 | 2);//3
        System.out.println(8 | 16);//24
        System.out.println(4 | 8);//12
        System.out.println(3 | 12);//15
        //让你们找10个数。20个数。使用其中的任意几个数。然后做加法。不会和其他的组合的结果重复。
        //1,2,4,8,16,32,64,128,256,
        //2: 可以让指定的某些二进制位的值设置为1.
        
        //按位异或 ^ 二元运算符。。规则：对应的位上 相异为1，相同为0.
        //特点：一个数先后和同一个数据异或两次，结果是它自身。
        System.out.println(3 ^ 4 ^ 4);//3
        //简单的加密
        char c1 = ‘我‘;
        char c2 = ‘爱‘;
        char c3 = ‘你‘;
        
        int key = 6666;
        
        c1 ^= key;
        c2 ^= key;
        c3 ^= key;
        System.out.println("密文="+c1 + c2 + c3);
        
        c1 ^= key;
        c2 ^= key;
        c3 ^= key;
        System.out.println("明文="+c1 + c2 + c3);
        
        // ~ 按位取反  一元运算符。规则：所有的二进制位0--->1  1--->0
        System.out.println(~0);//-1
        
        //移位运算符。
        // >> :带符号右移  ：低位被移走，高位空出来的补符号位，正数补0 负数补1.
        System.out.println(-1>>1);//-1
        System.out.println(35>>2);//17
        System.out.println(101>>1);//50
        System.out.println(89>>4);//5
        //应用：对于某个区间的整数，右移动n位，等价于 该数除以 2的n次幂
        
        // << 左移 ：高位被移走，包括符号位。低位补0.
        System.out.println(1<<1);//2
        System.out.println(1<<2);//4
        System.out.println(1<<3);//8
        //应用：在某些区间 左移n位等价于 乘以2的n次幂。
        System.out.println(1<<31);//8
        
        // >>> 无符号右移：低位被移走，高位补0.
        //应用：为了得到一个随机的正整数。
        final int MAX = 102, MIN = 100;
        //创建产生随机数对象ran
        java.util.Random ran = new java.util.Random();
        int value = ran.nextInt();//得到一个随机的int 类型的数据。
        System.out.println("value = "+value);
        //得到了一个随机的正整数
        value >>>= 1;
        //value = value >>> 1;
         System.out.println("value = "+value);
        value = value %(MAX-MIN) + MIN;
        System.out.println("value = "+value);
        //一句代码实现得到随机数。
        value = (ran.nextInt() >>> 1)%(MAX-MIN) + MIN;
        System.out.println("value = "+value);
    }
}

java 中唯一的三目运算符。 需要三个操作数。

语法： 表达式-1 ? 表达式-2 : 表达式-3

解释：
表达式-1：必须是一个 boolean 表达式。返回值是 boolean 值的表达式。
表达式-2、表达式-3：可以是java 支持的任意的表达式。两个表达式的返回值的类型 需要兼容。

执行过程：
    1：判断 表达式-1 的结果。如果 结果为 true，那么整个条件表达式 返回 执行 表达式-2 并返回 表达式-2 的结果。
    2：如果结果为false，那么跳过 表达式-2，执行表达式-3，并返回 表达式-3 的返回值。

// 1：得到两个随机数，一个使用Math获得，一个使用Random获得。全部打印。使用三目实现，将比较大的结果求出来。
// 2：得到一个随机数，如果奇数，打印 xxx 是奇数 如果是偶数 ，打印 xxx 是偶数
import java.util.Random;
public class ConditionTest{
    public static void main(String[] args){
        //定义区间
        final int MIN = 10, MAX = 111;
        
        int num1 = (int)(Math.random()*(MAX-MIN)+MIN);
        //创建获得随机数的对象
        Random ran = new Random();
        int num2 = (ran.nextInt()>>>1)%(MAX-MIN)+MIN;
        
        int num3 = (int)(Math.random()*(MAX-MIN)+MIN);
        
        System.out.println("num = "+num1 + "\tnum2 = "+num2+ "\tnum3 = "+num3);
        
        int max = num1 > num2 ? num1 : num2;
        max = max > num3 ? max : num3;
        
        //嵌套的三目
        int max1 = num1 > num2 ? (num1 > num3 ? num1 : num3) : (num2 > num3 ? num2 : num3);
        
        System.out.println("max = "+max);
        System.out.println("max1 = "+max1);
        
        //
        String str = max % 2 == 0 ? "偶数" : "奇数";
        //(max & 1) == 0 成立，说明 max 的二进制形式的最末位是0
        str = (max & 1) == 0 ? "偶数" : "奇数";
        System.out.println(max + "\t是"+str);
        
    }
}

类型转换：
    java 不支持 不同类型之间的运算。
    如果有不同类型之间的数据做运算的话，那么首先第一步做同类型转换。编译器来完成这种转换的。自动的完成的。
    转换的规则：

    1：如果参与运算的操作数的类型是如下的类型中的：byte  char short int ，所有的类型都自动转换为 int 然后再做运算。
        结果也是 int。
    2：如果参与运算的操作数的类型是如下的类型中的：byte  char short int ，而且一定包含 long 类型。所有的类型都自动转换为 long类型。然后再做运算。
        结果也是 long。
    3：如果参与运算的操作数的类型是如下的类型中的：byte  char short int long，而且一定包含 float类型。所有的类型都自动转换为 float类型。然后再做运算。
        结果也是 float。
    4：如果参与运算的操作数的类型是如下的类型中的：byte  char short int long float，而且一定包含 double类型。所有的类型都自动转换为 double类型。然后再做运算。
        结果也是 double。


    上述的转换都是 编译器 来完成的。自动完成的。在编译期完成类型的转换，也就是将小类型的数据 当作大类型的数据来使用（如果需要）。

    注意：第一种 和 第二种 自动转换 是 绝对安全的。 三四种 有可能存在精度的损失。java 允许这么做。

规则：
    小类型：表示的数值的范围比较小的。
    大类型：表示的数值的范围比较大的。

可以直接把一个小类型的数据 赋值 给一个 大类型的变量。

引用数据类型的转换：
老虎当动物用。 自动转换。

强制类型转换。

如果有将大类型的数据当作小类型的数据来使用的时候，就需要强制类型的转换。
大类型--强制-->小类型  不安全的。   

语法：
(强制转换为的类型)(被转换的数据);
int x = 2;
byte b1 = (byte)(x+1);
b1 = (byte)x;

强制转换的规则：


//强制类型转换
public class PowerChangeTypeTest{
    public static void main(String[] args){
        //整数之间的强制转换:
        //只保留 低n位的二进制，直接将多余的高位砍掉。不考虑符号位。只保留低位的数值位。
        int i1 = 254;
        System.out.println(Integer.toBinaryString(i1));
        
        byte b1 = (byte)(i1+1);
        System.out.println(b1);//-1
        
        //浮点数向整数的强制转换：
        //1:没有超过整数的范围，那么直接去掉小数点部分。
        //2：如果被转换的数据超过了整数的最大值，那么结果为最接近该浮点数的整数
        System.out.println((int)1.1);//1
        System.out.println((int)1.1E20);//2147483647
        
        //double 强制转换为 float
        //1 : 没有超过被强转的类型，那么小数部分直接被截断。
        //2 : 超过了被强转的类型。结果为 Infinity
        System.out.println((float)1.111111111111111111111111111111111111);//1.111112 
        System.out.println((float)1.1E100);//Infinity  无穷大

        b1 = 127;
        b1 ++;
        System.out.println(b1);//-128  可以认为隐含了一个强制类型转换，转换的类型为 b1的类型。
        
        //b1 = b1 + 1;
        b1 = 127;
        b1 += 1;//隐含了一个强制类型转换，强制转换的类型为 左边变量的类型。
        System.out.println(b1);//-128 
    }
} 

//得到一个随机字符[A-Z]or[a-z] （大小写也要随机），并打印.
import java.util.Random;
public class RandomCharTest{
    public static void main(String[] args){
        final int MAX = ‘Z‘+1;
        final int MIN = ‘A‘;
        //得到随机的大写字符
        char ranChar = (char)(Math.random()*(MAX-MIN)+MIN);
        System.out.println("随机的大写字符：" + ranChar);
        
        Random random = new Random();
        //大小写的随机
        boolean isUpperCase = random.nextBoolean();
        
        ranChar = isUpperCase ? ranChar : (char)(ranChar + 32);
        
        System.out.println("得到的随机字符为：" + ranChar);
    }
}

java 的代码的执行的路径的选择的种类。

1：顺序执行。
    从上到下依次执行
2：分支选择：
    根据条件来选择执行某些代码，跳过某些代码。
3：循环：
    反复的执行某些代码。

if 语句： 单分支 选择。

if 是java 的关键字。

if 语句 的 语法：
if(条件){
    //if 代码块
}
//

解释：
    条件：必须是一个 boolean 表达式。返回值为 boolean 值的表达式。
    if 代码块：一个使用{} 封闭的代码块。里面的内容可以是java 支持的任意行数的代码。


执行过程：
    1：首先计算条件 的返回值。如果是 返回值 为 true。那么执行 if 代码块中所有的内容。
    2：如果条件的返回值 为 false。那么就跳过所有的 if 代码块中的内容。

注意：
    1：如果if 代码块中的内容为一行 代码，那么大括号可以省略。建议添加大括号，即使是一条java 代码。
    2：不要在 条件小括号后 添加 分号。一个单独的分号是一条完整的java 语句。空语句。

//求两个随机数的最大值  范围[0-20].
//需求：产生一个随机数，范围[0-20]. 来代表一个年龄 age，
//使用if 语句，如果 age [0-3] 输出 还没有上学 [4-6] 幼儿园小朋友  [7-12] 小学生 [13-15] 中学生 [16-18]  高中生 [19-22] 大学生。
public class IfTest{
    public static void main(String[] args){
        final int MAX = 21, MIN = 0;
        //求两个随机数
        int num0 = (int)(Math.random()*(MAX-MIN)+MIN);
        int num1 = (int)(Math.random()*(MAX-MIN)+MIN);
        System.out.println("两个随机数为："+num0 + "\t\t"+num1);
        int max = num1;
        if(num0 > num1){
            max = num0;
        }
        System.out.println("max = "+max);
        // if(num1 >= num0){
            // max = num1;
        // }
        //产生一个随机的年龄
        int age = (int)(Math.random()*(MAX-MIN)+MIN);
        System.out.println("age = "+age);
        if(age >=0 && age <=3){
            System.out.println("还没有上学！");
        }
        if(age >=4 && age <=6){
            System.out.println("幼儿园小朋友！");
        }
        if(age >=13 && age <=15){
            System.out.println("初中生！");
        }
        if(age >=7 && age <=12){
            System.out.println("小学生！");
        }
        if(age >=16 && age <=18){
            System.out.println("高中生！");
        }
        if(age >=19 && age <=22){
            System.out.println("大学生！！");
        }
    }
}