Java基础

Java是一门面向对象编程语言，是sun公司开发的，目前被Oracle公司收购。
Java编程语言具有以下特点：
简单性、面向对象、分布式、健壮性、安全性、体系结构中立、可移植性、解释型、高性能、多线程、动态性。

HelloWorld程序

前面已经成功的安装了JDK，下面看一个简单的Java程序：

  1 public class HelloWorld {
  2     public static void main(String[] args){
  3         System.out.println("Hello,World!");
  4     }
  5  }

Java区分大小写，如果出现了大小写的拼写错误（main写成了Main），程序将无法运行。
关键字public称为访问修饰符，关键字class表明Java程序中的全部内容都包含在类中，关键字class后面紧跟类名（HelloWorld）。
Java中定义类的名字必须以字母开头，后面可以跟字母和数字的任意组合，长度基本上没有限制，但是不能使用Java的保留字（关键字）作为类名。
标准的命名规范是以大写字母开头的名词，如果名字由多个单词组成，每个单词的第一个字母都应该大写（此称为驼峰命名法，例如：HelloWorld）。
源代码的文件名必须与公共类的名字相同，并使用.java作为扩展名，因此存储这段代码的文件必须命名为HelloWorld.java。
每个Java程序必须要有一个main方法。一对大括号表示方法的开始与结束。整个方法中只包含了一条语句，功能是打印一条语句“Hello,World!”。

注释

在Java程序中，有三种标记注释的方式，注释中的内容不会执行。
1.单行注释可以使用“//”，当需要注释多行时，也可以在注释内容的每行前使用“//”。
2.多行注释也可以使用“/*”和“*/”将注释括起来。
3.多行注释还可以使用“/**”开头“*/”结束。，这种注释可以用来自动的生成文档。

  1 //第一行注释内容
  2 //第二行注释内容
  3 
  4 /*
  5 注释内容第一行
  6 注释内容第二行
  7 */
  8 
  9 /**
 10 注释内容第一行
 11  注释内容第二行
 12 */

数据类型

Java是一种强类型语言，意味着必须为每一个变量声明一种类型，在Java中一共有8中基本类型：
4种整型、2种浮点型、1种用于表示Unicode编码的字符单元的字符类型char和1种表示真值的boolean类型。
整型用于表示没有小数部分的数值，它允许是负数，4种整型：int、short、long、byte。
浮点类型用于表示有小数部分的数值。2种浮点类型：float、double。其中double表示这种类型的数值精度是float的两倍（双精度数值）。在很多情况下，float类型的精度很难满足需求，所以只有很少的情况适合使用float类型。
float类型的数值有一个后缀F或f（0.1F或0.1f），没有F后缀的浮点数值默认为double类型，也可以在浮点数值后面添加后缀D或d。
char类型用于表示单个字符，其字面量值需要使用单引号括起来（'A'）。
boolean类型有两个值：false和true，用来判定逻辑条件。整型值和布尔值之间不能进行转换。
变量
在Java中，每个变量都有一个类型，在声明变量时，变量的类型位于变量名之前。

  1 int a;
  2 boolean done;

Java中完整的语句以分号“;”结束，由于声明是一条完整的语句，所以声明都以分号结束。不能使用Java的保留字作为变量名。
变量初始化
声明一个变量之后，必须用赋值语句对变量进行显式的初始化，不能使用未初始化的变量。

  1 int a = 1;

常量
在Java中，利用关键字final指示常量。

  1 final double XER = 3.5;

关键字final表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了，习惯上，常量名使用全大写。
在Java中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量，可以使用关键字static final设置一个类常量。

  1 public static final double XER = 3.5;

运算符

在Java中，使用运算符“+”、“-”、“*”、“/”表示加、减、乘、除运算。当参与“/”运算的两个操作数都是整数时，表示整数除法；否则表示浮点数除法。整数的求余操作（取模）用“%”表示。
$color{red}{注意：整数被0除将会产生一个异常，而浮点数被0除将会得到无穷大或NaN结果。}$
数值类型之间的转换

经常需要将一种数值类型转换为另一种数值类型。上图所示6个实心箭头表示转换时没有数据丢失；3个虚线箭头，表示转换时有可能损失精度。
强制类型转换
当需要将double类型转换成int类型时，有可能会丢失一些信息，在这种情况下就需要使用强制转换来实现这个操作。
强制转换的语法格式时在圆括号中给出想要转换的目标类型，后面紧跟待转换的变量名。

  1 double x = 3.55;
  2 int nx = (int) x;

此时变量nx的值为3。
如果想对浮点数进行舍入运算，以便得到最接近的整数，则需要使用Math.round方法：

  1 double x = 3.55;
  2 int nx = (int) Math.round(x);

现在变量nx的值为4。
当调用round方法时，仍需要使用强制类型转换(int)，是因为round方法返回的结果是long类型，由于存在信息丢失的可能性，所以只有使用显式的强制类型转换才能够将long类型转换成int类型。
结合赋值和运算符
可以在赋值中使用二元运算符，这是一种很方便的简写形式：

  1 x += 4; //等价于 x  =  x + 4;

自增与自减运算符

  1 int a = 10;
  2 a++;

a++将a的值更改为11。由于这些运算符会改变变量的值，所以它们的操作数不能是数值，10++就不是一个合法的语句。
上面是运算符放在操作数后面的“后缀”形式，但是花有一种是“前缀”形式：++a。
后缀和前缀都会使变量值加1，但用在表达式中时，二者就有区别了。前缀形式会先完成加1；而后缀形式会使用变量原来的值，再加1。
关系运算符和boolean运算符
Java包含的关系运算符：==（检测相等性）、!=（检测不相等）、<（小于）、>（大于）、<=（小于等于）、>=（大于等于）。
此外：!表示逻辑“非”运算符；&&表示逻辑“与”运算符；||表示逻辑“或”运算符。
&&和||运算符时按照“短路”方式来求值的：如果第一个操作数已经能够确定表达式的值，第二个操作数就不必计算了。

  1 x != 0 && 1 / x > x + y;

如果x等于0，那么第二部分就不会计算，也就不会计算1/x，这样除以0的错误就不会出现。

  1 x != 0 || x > y;

如果x不等于0，则条件一为true，那么第二部分就不会判断了。
Java支持三元操作符?:。

  1 x > y ? x : y;

如果x大于y，返回x，否则返回y，即判断条件之后，返回两个数值中较大的一个数值。
位运算符
处理整型类型时，可以直接对组成整型数值的各个位完成操作。位运算符包括：
&（“and”）、|（“or”）、^（“xor”）、~（“not”）、>>（左移）、<<（右移）、>>>（使用符号位填充高位，不存在<<<运算符）。
括号于运算符级别
下面按照从前到后，运算级别由高到低，同级参看结合性。

运算符	结合性
[].()（方法调用）	从左向右
!、~、++、--、+、-、()（概括号为强制类型转换）、new	从右向左
*、/、%	从左向右
+、-	从左向右
<<、>>、>>>	从左向右
<、<=、>、>=、instanceof	从左向右
==、!=	从左向右
&	从左向右
^	从左向右
\|	从左向右
&&	从左向右
\|\|	从左向右
?:	从右向左
=、+=、-=、*=、/=、%=、&=、\|=、^=、<<=、>>=、>>>=	从右向左

枚举类型
有时候，变量的值只在一个有限的集合内，为了避免保存值错误，可以自定义枚举类型。枚举类型包括有限个命名的值。

  1 enum Size{SMALL,MEDIUM,LARGE}
  2 Size s = Size.SMALL;//声明枚举类型的变量

Size类型的变量只能存储这个类型声明中给定的某个枚举值，或者null值，null表示这个变量没有设置任何值。
字符串
从概念上讲，Java字符串就是Unicode字符序列。
Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义类，即String。每个用双引号括起来的字符串都是String类的一个实例。

  1 String a = "";//空String
  2 String b = "Hello";

子串
String类的substring方法可以从一个较大的字符串提取出一个子串。

  1 String b = "Hello";
  2 String s = b.substring(0,3);

则创建了一个由字符“Hel”组成的子串。substring方法的第二个参数是不想复制的第一个位置。即示例代码复制不包括3。
拼接
Java中允许使用+号来拼接两个字符串。

  1 String a = "Hello";
  2 String b = "World";
  3 String c = a + b;

示例代码将“HelloWorld”赋给变量c（拼接的两个字符串之间没有空格）。如果b是其他Java对象，例如b是int类型的数值2，则b将被转换成字符串，c为“Hello2”，任何的Java对象都可以被转换成字符串。
不可变字符串
String类没有提供用于*修改*字符串的方法，所以String类对象称为*不可变字符串*。
检测字符串是否相等
使用equals方法检测两个字符串是否相等：

  1 String a = "Hello";
  2 String b = "Hello";
  3 System.out.println(a.equals(b));
  4 System.out.println("Helloc".equals(b));

如果字符串a于b相等，返回true，否则返回false。字符串字面量比较也是合法的，例如："Helloc".equals(b)。
空串与Null串
空串""是长度为0的字符串，是一个Java对象，有自己的串长度（0）和内容（空）。判断一个字符串是否为空使用如下代码语句：

  1 if(str.length() == 0){}
  2 if(str.equals("")){}

String变量还可以存放一个特殊值null，表示目前没有任何对象与该变量关联。判断一个字符串是否是null使用如下代码语句：

  1 if(str == null){}

要判断一个字符串既不是null也不为空串，使用如下代码语句：

  1 if(str != null && str.length() != 0){}

注意：必须先判断str不为null。

控制流程

块作用域
块（即复合语句）是指由一对大括号括起来的若干条简单的Java语句。块确定了变量的作用域。一个块可以嵌套在另一个块中。
条件语句
条件语句的格式为：

  1 if(条件语句) {
  2     执行语句1；
  3     执行语句2；
  4 ...
  5 } else {
  6     执行语句3；
  7     执行语句4；
  8 ...
  9 }

else部分是可选的，else子句与最邻近的if过构成一组。
循环
当条件为true时，while循环执行一条语句（也可以是一个语句块）；如果开始循环条件的值就为false，则while循环体一次也不执行。格式如下：

  1 while(条件语句) {
  2     执行语句1;
  3     执行语句2;
  4 }

do...while
do…while循环语句和while循环语句功能类似，格式如下：

  1 do {
  2      执行语句1;
  3      执行语句2;
  4 } while(条件语句);

关键字do后面{}中的执行语句是循环体。
do…while循环语句将循环条件放在了循环体的后面。这也就意味着，循环体会无条件执行一次，然后再根据循环条件来决定是否继续执行。
确定循环
for循环语句时支持迭代的一种通用结构，利用每次迭代之后更新的计数器或类似的变量来控制迭代次数。
for语句的第1部分通常用于对计数器初始化；第2部分给出每次新一轮循环执行前要检测的循环条件；第3部分指示如何更新计数器。

  1 for(int i = 0;i<10;i++){
  2     System.out.println("i的值为：" + i);
  3 }

当for语句的第1部分中声明了一个变量之后，这个变量的作用域就为for循环的整个循环体。整个定义在for语句内部的变量就不能在循环体之外使用。所以可以在各自独立的不同的for循环中定义同名的变量。
多重选择语句
switch语句将从与选项值相匹配的case标签处开始执行直到遇到break语句，或者执行到switch语句的结束处
为止。如果没有相匹配的case标签，而有default子句，就执行这个子句。
case标签可以是：
1.类型为char、byte、short或int的常量表达式。
2.枚举常量。
3.字符串字面量。

  1 enum Size{SMALL,MEDIUM,LARGE}
  2  public static void main(String[] args){
  3      Size s = Size.SMALL;
  4      switch (s){
  5          case SMALL:
  6              System.out.println(s);
  7              break;
  8          case LARGE:
  9              System.out.println(s);
 10              break;
 11          case MEDIUM:
 12              System.out.println(s);
 13              break;
 14          default:
 15              System.out.println("无符合条件值");
 16 
 17          }
 18     }

中断控制流程语句
break语句，用于退出循环语句，上面switch语句中也有使用。
Java还提供了一种带标签的break语句，用于跳出多重循环的嵌套语句。

  1 write:
  2 while(条件语句1){
  3     for(int i = 0;i<10;i++){
  4         if(条件语句3){
  5             执行语句；
  6             break write;
  7         }
  8     }
  9 }

write:就是一个标签，标签必须放在希望跳出的最外层循环之前，并且必须紧跟一个冒号。
continue语句将控制转移到最内层循环的首部。

  1 public static void main(String[] args){
  2     Scanner in = new Scanner(System.in);
  3     int sum = 1;
  4     int goal = 10;
  5     while(sum < goal){
  6         System.out.println("Please enter a number: ");
  7         int n = in.nextInt();
  8         if(n < 0){
  9             System.out.println("执行continue语句");
 10             continue;
 11         }
 12         System.out.println(sum += goal);
 13     }
 14 }

当n < 0时，continue语句越过了当前循环体的剩余部分，立刻跳到while循环首部。
如果continue语句用在for循环中，则直接跳到for循环的“更新”部分（例如：条件语句中的i++）。

大数值

如果基本的整数和浮点数精度不能够满足需求，可以使用java.math包中的两个类：BigInterger和BigDecimal。这两个类可以处理包含任意长度数字序列的数值。BigInterger实现了任意精度的整数运算，BigDecimal实现了任意精度的浮点数运算。