Java核心编程-第一卷:基础知识

public static void main(String[] args) {
        BigInteger bigInteger1 = BigInteger.probablePrime(20, new Random());
        Boolean aBoolean = Boolean.valueOf(1 << 20 < 20);
        System.out.println(aBoolean);
    }

1. Java 区分大小写。
2. 关键字 public 称为访问修饰符（access modifier), 这些修饰符用于控制程序的其他部分对这段代码的访问级別
3. 关键字 class 表明 Java 程序中的全部内容都包含在类中
4. 类作为一个加载程序逻辑的容器，程序逻辑定义了应用程序的行为
5. Java 中定义类名的规则很宽松。名字必须以字母开头，后面可以跟字母和数字的任意组合。长度基本上没有限制。但是不能使用 Java 保留字（例如，public 或 class) 作为类名（保留字列表)。

6. abstract 抽象类或方法 5
   assert 用来查找内部程序错误 7
   boolean 布尔类型 3
   break 跳出一个 switch 或循环( for )3
   byte 8 位整数类型 3
   case switch 的一个分支 3
   catch 捕获异常的 try 块子句 7
   char Unicode 字符类型 3
   class 定义一个类类型 4
   const 未使用 没用到
   continue 在循环末尾继续 3
   default switch 的缺省子句 3, 6
   do do/while 循环最前面的语句 3
   double 双精度浮点数类型 3
   else if 语句的 else 子句 3
   enum 枚举类型 3
   extends 定义一个类的父类 4
   final 一个常量，或不能覆盖的一个类或方法 5
   finally try 块中总会执行的部分 7
   float 单精度浮点数类型 3
   for 一种循环类型 3
   goto 未使用
   if 一个条件语句 3
   implements 定义一个类实现的接口 6
   import 导入一个包 4
   instanceof 测试一个对象是否为一个类的实例 5
   int 32 位整数类型 3
   interface —种抽象类型， 其中包含可以由类实现的方法 6
   long 64 位长整数类型 3
   native 由宿主系统实现的一个方法 12 (卷 n )
   new 分配一个新对象或数组 3
   null 一个空引用（需要说明， mill 从技术上讲是一个直接量， 而不是关键字） 3
   package 包含类的一个包 4private 这个特性只能由该类的方法访问 4
   protected 这个特性只能由该类、 其子类以及同一个包中的其他类的方法访问 5
   public 这个特性可以由所有类的方法访问 4
   return 从一个方法返回 3
   short 16 位整数类型 3
   static 这个特性是这个类特有的， 而不属于这个类的对象 3, 6
   strictfp 对浮点数计算使用严格的规则 2
   super 超类对象或构造函数 5
   switch 一个选择语句 3
   synchronized 对线程而言是原子的方法或代码块 14
   this 当前类的一个方法或构造函数的隐含参数 4
   throw 抛出一个异常 7
   throws 一个方法可能拋出的异常 11
   transient 标志非永久的数据 2 (卷 n )
   try 捕获异常的代码块 7
   void 指示一个方法不返回任何值 3
   volatile 确保一个字段可以由多个线程访问 14
   while 一种循环 3

7. 标准的命名规范为：
   类：CamelCase    例如 EmployeeSalary，GoodsPriceEnum
   
   再次提醒大家注意，大小写是非常重要的， 千万不能写成 firstsample.java
8. 运行已编译的程序时，Java 虚拟机将从指定类中的 main 方法开始执行（这里的“ 方法”
   就是 Java 中所说的“ 函数”），因此为了代码能够执行，在类的源文件中必须包含一个 main
   方法。当然，也可以将用户自定义的方法添加到类中，并且在 main 方法中调用它们

　　  9. 注释：// 单行  /**/ 多行  /***/ 文档注释

数 据 类 型

1. 1. 1. 八种基本类型：分为四类分别为
         4 种整型、2 种浮点类型、 1 种用于表示 Unicode 编码的字符单元的字符类型 char (请参见论述 char 类型的章节） 和 1 种用于表示真值的 boolean 类型。
         

         

         0X八进制数字 源码例子：

         HashTable:
         
         public synchronized boolean containsKey(Object key) {
             Entry<?,?> tab[] = table;
             int hash = key.hashCode();
             int index = (hash & 0x7FFFFFFF) % tab.length;
             for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
                 if ((e.hash == hash) && e.key.equals(key)) {
                     return true;
                 }
             }
             return false;
         }
         Integer:
         
         public static final int   MIN_VALUE = 0x80000000;

         在 Java 中， 所有

         的数值类型所占据的字节数量与平台无关。

         注意， Java 没有任何无符号（unsigned) 形式的 int、 long、short 或 byte 类型。

         

         所有的浮点数值计算都遵循 IEEE 754 规范。具体来说，下面是用于表示溢出和出错情况

         的三个特殊的浮点数值：

         •正无穷大

         •负无穷大

         •NaN (不是一个数字）

         例如， 一 正整数除以 0 的结果为正无穷大。计算 0/0 或者负数的平方根结果为 NaN。

         

         小米面试题：
         　　1.0 - 0.9 等于多少？：因为二进制系统中无法精确标识分数1/10，好比十进制无法精确标识分数1/3 一样 ，如果计算中不允许有任何射入误差，就应该使用BigDecimal类
         

         变量
         

         声明一个变量之后，必须用赋值语句对变量进行显式初始化， 千万不要使用未初始化的

         变量。例如， Java 编译器认为下面的语句序列是错误的：

         int vacationDays;

         System.out.println(vacationDays): // ERROR variable not initialized

         要想对一个已经声明过的变量进行赋值， 就需要将变量名放在等号（=) 左侧， 相应取值

         的 Java 表达式放在等号的右侧。 

          

         C++ 注释：C 和 C++ 区分变量的声明与定义。例如：

         int i = 10;

         是一个定义， 而

         extern int i;

         是一个声明。在 Java 中， 不区分变量的声明与定义。

          

         关键字 final 表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了。习惯上,

         常量名使用全大写。

         

         运 算 符

         在 Java 中，使用算术运算符 +、-、 *、/ 表示加、减、 乘、除运算。 当参与 / 运算的两个

         操作数都是整数时， 表示整数除法；否则， 表示浮点除法。 整数的求余操作（有时称为取模)

         用 ％ 表示。例如，15/2 等于 ，7 15%2 等于 1 , 15.0/2 等于 7.50

         需要注意， 整数被 0 除将会产生一个异常， 而浮点数被 0 除将会得到无穷大或 NaN 结果。

         strictfp ：这个类中的所有方法都要使用严格的浮点计算。 为啥呢

         很多 Intel 处理器计算 x * y/z，并且将结果存储在 80 位的寄存器(操作系统)中， 再除以 z 并将结

         果截断为 64 位„ 这样可以得到一个更加精确的计算结果，并且还能够避免产生指数溢

         出

         public static strictfp void main(String[] args) {
             double x = 1.23d;
             double y = 2.46d;
             double z = 1.23d;
             System.out.println(x * y / z);
         }