本章讲述的内容可以分为注释、数据内容、运算符三大块，文章结构大致如下图所示：

• 注释
  • 单行、多行注释
  • 文档注释以及javadoc命令

• 数据类型

  • 基本数据类型
    • 分类
      • 整形(byte、short、int、long)
      • 字符型(char)
      • 浮点型(float)
      • 布尔型(boolean)
    • 类型转换
      • 自动类型转换
      • 强制类型转换

• 运算符

  • 算数运算符(+、-、*、/、%、++、–)
  • 赋值运算符(=)
  • 位运算符(&、|、~、^、<<、>>、>>>)
  • 比较运算符(>、>=、<、<=、==、!=)
  • 逻辑运算符(&&、&、||、|、!、^)
  • 三目运算符(? :)

首先，先来看第一部分——注释：

一、注释

注释是给人看的，因此不会被计算机所识别和执行，根据不同的需要，分类如下：

1）单行注释和多行注释：

不多讲，看下面片段：

public class CommentTest{/*这里面的内容都是多行注释的内容，不会被执行*/public static void main(String[] args){//这是单行注释System.out.println("Hello world!");//System.out.println("这行代码被注释了，不会被执行");}
}

2）文档注释：

Java基础类库中有成千上万的类，开发者不可能全部记住它们，那么就需要有一份说明性的文档，把这些类，以及类中方法的用途记录下来，以便查阅。对于Java 8 ，可以在Oracle官网下载页，将滚动条滚动到下方，如图：

下载到Java 8的API说明文档。下载成功后会得到一个jdk-8u65-docs-all.zip文件，将它解压后，会得到一个jdk-8u65-docs-all文件夹，在文件夹下的docs/api目录下，打开index.html，就可以看到Java 8 的API说明文档，如下图所示：

这是打开index.html后，访问到的Java 8 API文档首页：

说了这么多，跟文档注释有什么关系呢？其实，如此庞大的Java API说明文档，就是文档注释+javadoc的杰作！这里先说说文档注释。文档注释，顾名思义，就是”用来生成API文档的注释“，例如：

public class DocCommentTest{private String comment;/*** 这里是文档注释，用于生成可阅读的文档*/public String getComment(){return comment;}
}

由上面的代码片段可见，所谓文档注释，在格式上，只是比多行注释在开头处多了一个星号。

那么，仅仅因为多了一个星号，就多出了一种注释的方式吗？不是的，文档注释还要配合javadoc工具，才能体现出它的价值来。那么javadoc又是干什么的呢？javadoc和javac、java一样，是一个exe文件，它的功能是识别java源文件中的文档注释，并按照一定规则将文档注释提取出来，生成一份可读性好的API文档。语言是苍白的，下面做一个小例子来加以说明：

首先，写两个类：

package lee;
public class JavaDocTest{/*** 简单测试成员变量*/protected String name;/*** main方法*/public static void main(String[] args){System.out.println("Hello world!");}
}

package yeeku;
public class Test{/*** 简单测试成员变量*/public int age;/*** Test类的测试构造器*/public Test(){}
}

备注：上面的两个类分别在JavaDocTest.java文件和Test.java文件中，在cmd命令行输入命令，如下所示：

执行命令后，源文件父目录下多出了一个apidoc文件夹，如图所示：

进入apidoc文件夹中，如图所示：

打开Index.html文件，可以看到，两个java源文件中的类的文档注释，已经被成功提取成为一份API文档，下图中标示了javadoc命令各项参数的效果：

在左下角区域选择Test类，可以看到，在Test.java中为Test类的成员变量age，以及为Test的构造器所做的文档注释，如下图所示：

注释的内容就介绍到这里。

二、数据类型

1）基本数据类型：

1.分类：

a）整形：

各种整型的表示范围如下表：

类型	位数	字节数	大小	最高位
byte	8	1	-2^7 ~ 2^7 - 1	符号位
short	16	2	-2^15 ~ 2^15 - 1	符号位
int	32	4	-2^31 ~ 2^31 - 1	符号位
long	64	8	-2^63 ~ 2^63 - 1	符号位

其中，int是最常用的类型。

对于整型系列，有几点比较特殊的地方：

1、对于一个在byte类型范围的整型值，可以直接赋给byte类型的变量：

public static void main(String[] args){//允许，虽然23默认是int类型，但因为其值比较小，//赋给byte类型变量bValue时，把它当成byte类型byte bValue = 23;//在byte范围内，正常byte bValue1 = 1213;//超出byte范围，错误//同样地，以二进制数表示的整型，如果是在byte范围内，//也可以直接复制给byte变量byte binValue = 0b01101001;//在byte范围内，正常byte binValue1 = 0b11101111;//超出byte范围，错误
}

2、对于一个超过了int类型范围的整型值，不可以赋给long类型的变量：

public static void main(String[] args){//下面代码错误，系统不会把99999999999999当成long类型，//而会认为99999999999999超出了int类型最大表示范围，//从而报错long bigValue = 99999999999999;//为了使得上面的赋值操作可以实现，需要将int类型升级为long类型//通过在数值后加上一个"L"，指明该数值是long类型直接量long bigValue1 = 99999999999999L;
}

3、整型值的4种表示方式：

a）十进制：十进制想必没有什么好说的了，大家日常每天都在用

b）二进制：

以0B开头，每一位可取的值只有0、1，例如：

public static void main(String[] args){//定义2个8位的二进制整数int binVal1 = 0b11010100;int binVal2 = 0b01101001;System.out.println("binVal1:" + binVal1);//212System.out.println("binVal2:" + binVal2);//105
}

下面我们来计算一下binVal1和binVal2是不是分别等于212和105：

首先，计算binVal1(0b11010100)：

1.最高位是符号位，是1，所以binVal1是一个负数

2.将剩下的数值位转化为十进制数，得到84

3.于是binVal1 = -84

咦？怎么不是212，不但数值不对，正负号都搞错了！！！

这里涉及到几个问题：

q1：哪一位是最高位？是左手边数起第一位吗？如果不是，那是哪一位？

q2：我们人看到的实际数字，和计算机保存的数字是同一个数字吗？

我们可以注意到，binVal1的类型是int，那么意味着它的位数是32位，而我们赋给binVal1的数值是一个8位的整数，那这时系统发现位数不够，于是把它前面的32 - 8 = 24个位都补上0，此时

binVal1=0b00000000000000000000000011010100

此时再看，binVal1最高位已经变成0，再将其他位作为数值位，进行转换，得到数值——212

这回终于对了！前面提出的问题q1可以回答了——要看变量的类型来具体判定最高位是哪一位。同个道理，binVal2的值也可以计算得出。但是，问题q2怎么好像没有体现到？且看下面这段程序：

public static void main(String[] args){//定义32位二进制整数int binVal3 = 0b10000000000000000000000000000011; System.out.println("binVal3:" + binVal3);//-2147483645
}

嘿嘿，这回binVal3的值正好是32位的，我们发现最高位是1，数值位是3，结果想当然的是-3，但是真正的结果是-2147483645，这回真的是差了十万八千里了！

怎么回事呢？原来，正如上面的q2问题，答案是否定的——计算机中存的数，其实跟我们看到的数不是同一回事，计算机是把所有的数都转换成补码存了起来，而当被读取的时候，又把补码转换为原码，呈现在人们面前。那么问题来了——什么是原码？补码又是什么？

原码是计算机为了在系统中表示正负号，在原来的数字的数值部分的前面，增加一位作为符号位，形成的新数。例如：-8要存进计算机里，就要转换成二进制的表示，数值部分的8好转，直接就是1000，那负号怎么办呢？计算机只认识0和1呀！于是原码来了——在数值位前面增加1位作为符号位，于是-8就是11000，可是Java中没有5位的整型类型呀，那么我们就假设这个-8是个byte类型的吧，byte是8位，那么它的符号位1就应该在左手边第一位，所以十进制的-8转换成二进制byte型就应该是10001000——这就是-8的原码。

现在计算机认识-8了，可是为什么又有一个补码的概念呢？简单的来说，补码是为了计算机更方便地进行运算——在运算的时候，可以将符号位视为数值位，一起参与运算，而不必担心结果出错。因此，计算机以原码到补码转换过程的开销，换取了节省计算过程中区分符号位与数值位的开销的便利。

原码转换为补码的步骤是这样子的：

当原码是正数时：不用转化，原码与补码相等

当原码是负数时：

1.获得反码——符号位不变，数值位取反

2.获得补码——反码+1

当我们使用二进制的时候，计算机默认把二进制数当成补码，直接存到变量里面；而当我们使用十进制的时候，计算机是把十进制数当成原码，再将原码转为补码，再存入到变量中。而等到打印输出的时候，计算机又把存在变量里的补码，统统转换成原码，展现在我们面前。

因此binVal3 = 0b10000000000000000000000000000011，这个数其实是一个补码，那么必须将它转换为原码，才是打印输出的结果。补码转换为原码的步骤与原码转为补码的步骤互逆：

当补码是负数时：

1.获得反码——补码 - 1(0b10000000000000000000000000000010)；

2.获得原码——符号位不变，数值位取反(0b11111111111111111111111111111101)

当补码是正数时，补码和原码相等。

于是，binVal3的原码是：0b11111111111111111111111111111101，转为十进制，就是-2147483645

假如binVal3使用十进制数存进去，例如binVal3 = -3，那么计算机会将-3视为原码（而不是补码），并将它转换为补码存到内存中，当打印输出时，又会将-3从补码形式转回原码形式，于是一来一回，相当于没转，于是打印输出还是-3.

c）八进制：

八进制数以0打头，如下所示：

public static void main(String[] args){//8进制数，0打头int octalValue = 013;System.out.println("octalValue :" + octalValue);//输出11
}

d）十六进制：

16进制数用0x打头，如下所示：

public static void main(String[] args){//16进制数，0x打头int hexValue1 = 0x13;int hexValue2 = 0xaF;System.out.println("hexValue1 :" + hexValue1);//输出19System.out.println("hexValue2 :" + hexValue2);//输出175
}

4、溢出：

i）什么叫溢出：

溢出，其实有很多种语义场景，比如说，内存溢出、缓冲溢出等等。然而，无论是什么类型的溢出，都是因为同一个原因——装不下了，那怎么办呢，硬塞呗——结果就是在这个“硬塞”的过程中，我们损失了一些东西。

我们这里的溢出，指的是变量代表的那一块小内存，装不下我们人为地想要装进去的数值，那么我们就把这个大数进行一下强制类型转换（关于强转，本文后面会讲到），然后硬塞进去，结果出问题了——实际存进变量的值，跟我们放进去的，不是同一个数值。也就是说，原来的大数，在强转的过程当中，出现了损失，因而变成了另外一个数。

ii）溢出举例：

public static void main(String[] args){/*定义1个8位二进制数，但它实际上占了32位，因此虽然左手边起第8位是1，但它经过位数扩展之后，仍然是一个正数0b0000_0000_0000_0000_0000_0000_1110_1001，也就是233，但是已经超过了byte的范围，现在要把它赋给一个byte类型的变量，必须进行强转，强转的结果是0b1110_1001，也就是不要前面的24位，因为现在最高位是1，是负数，将补码转为原码，得到0b1001_0111,也就是-23，而这就产生了溢出*/byte bValue = (byte)0b11101001;//这里的二进制数是补码System.out.println("bValue :" + bValue);//-23
}

结果：

5、新特性：

为了方便程序员看清位数较多的数值，在Java7之后，允许在数值中的数位之间添加分隔号”_”，例如：

public static void main(String[] args){int iValue = 0b0000_0001_0001_1101_0010_0101_0011_1111;double dValue1 = 3.14_15_92_63;
}

b）字符型：

1）字符集：

计算机保存字符的时候，实际上是把该字符对应的编号，转化为二进制代码，保存到计算机中。因此，需要为每个字符，编上一个编号，有多少个字符，就编多少个号，形成很多个”字符<–>编号“这种一一对应的映射关系，这些映射关系，就组成了所谓的字符集。

例如，ASCII字符集只给英文字母、数字、标点符号编码，总共加起来不超过100个，于是ASCII字符集只用了一个字节（最多可表示256个字符）来编码。然而到了后来，随着世界各地各种语言的假如，字符越来越多，于是采用两个字节编码的Unicode字符集又应运而生了。

总而言之，字符集的出现，是为了解决计算机不认识人类世界的符号，又必须要保存这些符号的矛盾。

2）表示法：

Java中表示单个字符，可以有以下三种形式：

a）直接法：直接用单引号括住字符，例如 ‘a’表示字符a

b）转义法：一些特殊字符，必须通过转义普通字符来表示，例如： ‘\r’表示”回车“字符， ‘\n’表示”换行“字符

c）Unicode法：用Unicode值来表示，形如： ‘\uXXXX’，其中 ‘XXXX’代表一个16进制的数

3）与int类型的关系：

把一个int类型的值赋给一个char类型的变量，系统会认为该int值是char字符的编码，例如：char c = 97 ，当输出c的值时，会发现是字符 ‘a’

4）示例程序：

public static void main(String[] args){//直接指定单个字符作为字符值char aChar = 'a';System.out.println("aChar:" + aChar);//输出a//使用转义字符作为字符值char enterChar = '\n';System.out.print("enterChar:" + enterChar);//输出一个回车符//使用Unicode编码值来指定字符值char ch = '\u9999';System.out.println("ch:" + ch);//输出中文"香"字char zhong = '疯';System.out.println("zhong:" + zhong);//输出中文"疯"int zhongVal = zhong;System.out.println("zhongVal:" + zhongVal);//输出中文"疯"的unicode值char c = 97;System.out.println("c:" + c);//输出字符'a'}

结果如下所示：

c）浮点型：

1）分类：

1.float：单精度，长度32位 = 1位符号+8位指数+23位尾数

2.double：双精度，长度64位 = 1位符号+11位指数+52位尾数

2）特殊值：

1.POSITIVE_INFINITY：正无穷

2.NEGATIVE_INFINITY：负无穷

3.NAN：非数

3）示例程序：

public static void main(String[] args){//下面输出的af并不精确，原因是Java使用二进制的科学计数法表示//浮点数float af = 5.2345556f;System.out.println("af:" + af);double a = 0.0; double b = Double.NEGATIVE_INFINITY;float d = Float.NEGATIVE_INFINITY;//double中的负无穷和float的负无穷是相等的System.out.println("b == d : " + (b == d));//0.0/0.0得到非数System.out.println("0.0 / 0,0: " + (0.0/0.0));//非数之间不相等System.out.println("a / a == Float.Nan : " + (a / a == Float.NaN));//正无穷之间是相等的System.out.println("6.0 / 0.0 == 342.0 / 0.0 : " + (6.0 / 0.0 == 342.0 / 0.0));//下面将抛出“除数不能为0”的异常//System.out.println(0 / 0);}

结果如下所示：

d）布尔型：

布尔型只有一个boolean类型，而且取值只能是true或者false，而且不能像在C语言中一样，用非0的数代替true，用0代替false

2.类型转换

1）自动类型转换

指的是一种基本类型的值，可以直接赋给另一种基本类型的变量，而不加任何限制条件，简称“小转大”。

Java的自动类型转换分为以下两种：

1、小数值类型—>大数值类型(存在两条类型提升线路)

byte–>short–>int–>long–>float–>double

char–>int–>long–>float–>double

2、非String类型—>String类型

示例程序：

public static void main(String[] args){int a = 6;//int类型自动转换为floatfloat f = a;//将输出6.0System.out.println("f : " + f);//定义bytebyte b = 9;//byte无法自动转型为char//char c = b;//byte可以自动转型为doubledouble d = b;//将输出9.0System.out.println("d：" + d);//int、float、double与String使用“+”连接时//统统自动转化为StringString s = "Hello" + 10 + 1.3f + 3.2;System.out.println("s : " + s);//输出Hello101.33.2}   

2）强制类型转换

指的是一种基本类型的值，不能直接赋值给另一种基本类型的变量，必须将该值的类型强制转为目标变量的类型，然后才能进行赋值操作。强制类型转换的格式形如：(TargetType)value，一般都是把类型较大的value强制转为类型较小的TargetType，简称“大转小”，容易产生溢出（关于溢出，已经在前面介绍）

示例程序：

public static void main(String[] args){int iValue = 233;//将int类型的值强制转换为byte，发生溢出byte bValue = (byte)iValue; //输出bValueSystem.out.println("bValue:" + bValue);//输出-23double dValue = 4.44;//将double类型的值强制转换为intint iValue2 = (int)dValue;//输出iValue2System.out.println("iValue2: " + iValue2);//输出4}

3）表达式类型自动提升

所谓的表达式类型自动提升，有两方面的意义：

1、byte、short、char，这几个类型中的一种或多种在一个表达式中出现时，该表达式最后的类型都是int

示例程序：

public static void main(String[] args){byte bValue = 1;short sValue = 2;char cValue = 3;byte bResult = bValue + bValue;short sResult = sValue + bValue;char cResult = cValue * cValue;
}

执行效果：

可见，byte、short、char在进行运算的时候，自动提升为了int

2、在一个表达式中，如果有多种数据类型的变量（或常量）存在，那么该表达式中的其他变量（或常量）的类型将被提升到该表达式中最高等级操作数相同的类型，从而使整个表达式的类型与最高等级操作数的类型相同。简单地来说，就是最高类型决定了该表达式的最终类型。

示例程序：

public static void main(String[] args){//定义一个short类型的变量short sValue = 5;//下面语句将发生错误，因为=右边最大的数据类型是int类型，//所以右边整体是int类型，而int类型无法自动转换为short类型sValue = sValue - 9;byte b = 40;char c = 'a';int i = 23;double d = .231;//=右边最高类型是double，所以应该赋给一个double类型的变量double result = b + c + d * i;//result的类型是doubleSystem.out.println("result : " + result);}

三、运算符

1、算术运算符：

算术运算符包括加(+)、减(-)、乘(*)、除(/)、取余(%)，其中，加减乘三种运算，需要注意的是确保运算结果不超过赋值目标的类型大小。而除法和取余则需要考虑到更多的问题，见如下示例程序：

public static void main(String args){double d1 = 5.5;double d2 = 4.6;double div = d1 / d2;//输出d1 / d2的结果：1.1956521739130437System.out.println("d1 / d2 :" + (d1 / d2));//输出正无穷大 InfinitySystem.out.println("5.0 / 0 :" + (5.0 / 0));//输出负无穷大：-InfinitySystem.out.println("-5.0 / 0 :" + (- 5.0 / 0));//输出非数：NaNSystem.out.println("0.0 / 0: " + (0.0 / 0));    //抛“除数不能为0”异常System.out.println("5 / 0" + (5 / 0));
}

效果如图：

2、赋值运算符：赋值运算符”=”比较简单，过程就是将”=”右边的数值赋给左边的变量，此处不再解释

3、位运算符：

位运算符针对的对象是整型变量或直接量，可分为以下几组：

1）&、|、^：

这一组分别是按位与、按位或、按位异或，操作的类型的都是整型的变量或直接量。进行操作时，将操作符两边的操作数都表示为二进制，对应的每一位按照下表的规则进行匹配运算：

操作数1	操作数2	按位与(&)	按位或(|)	按位异或(^)
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

示例程序：

    public static void main(String[] args){//5的二进制表示是：0000_0000_0000_0000_0000_0000_0000_0101//9的二进制表示是：0000_0000_0000_0000_0000_0000_0000_1001//按位与，结果是0000_0000_0000_0000_0000_0000_0000_0001，,也就是1System.out.println("5 & 9 :" + (5 & 9));//按位或，结果是0000_0000_0000_0000_0000_0000_0000_1101，,也就是13System.out.println("5 | 9 :" + (5 | 9));//按位异或，结果是0000_0000_0000_0000_0000_0000_0000_1100,也就是12System.out.println("5 ^ 9 :" + (5 ^ 9));}

结果如下：

2）~：

这一组只有一个操作符——按位非。为什么把它单独放在第二组呢，因为它是位操作符中唯一的一个单目运算符（即只有一个操作数的运算符），它的运算规则是：将操作数的每一位（包括符号位）进行取反操作，即遇1则0，遇0则1

示例程序：

public static void main(String[] args){//5的二进制表示是：0000_0000_0000_0000_0000_0000_0000_0101//-5的二进制表示是：1111_1111_1111_1111_1111_1111_1111_1011（补码）//5取反就是：1111_1111_1111_1111_1111_1111_1111_1010（补码）//转换成原码就是：1000_0000_0000_0000_0000_0000_0000_0110，也就是-6System.out.println("~5 :" + (~5));//-5取反就是：0000_0000_0000_0000_0000_0000_0000_0100（补码），也就是4（正数的补码和原码相同）System.out.println("~-5 :" + (~-5));//-5取反
}

结果如下：

3）<<、>>、>>>：

这一组操作符的功能都是对源操作数进行移位。其中：

<<：左移运算符，x << y，将x向左移动y位，右边出来的空位补0

>>：右移运算符，x >> y，将x向右移动y位，左边多出来的位数补上符号位

>>>：无符号右移运算符，x >>> y，将x向右移动y位，左边多出来的位数补上符号位

示例程序：

public static void main(String[] args){//-5的二进制表示是：1111_1111_1111_1111_1111_1111_1111_1011（补码）//-5左移1位，结果是1111_1111_1111_1111_1111_1111_1111_0110（补码）//转换成原码：1000_0000_0000_0000_0000_0000_0000_1010，也就是-10System.out.println("-5 << 1:" + (-5 << 1));//-5右移1位，结果是1111_1111_1111_1111_1111_1111_1111_1101（补码）//转换成原码：1000_0000_0000_0000_0000_0000_0000_0011，也就是-3System.out.println("-5 >> 1:" + (-5 >> 1));//-5右移1位//-5无符号右移1位，结果是0111_1111_1111_1111_1111_1111_1111_1101（正数的原码和补码相同），即2147483645System.out.println("-5 >>> 1:" + (-5 >>> 1));//-5无符号右移1位
}

结果：

移位操作符的注意点：

1.低于int类型的类型（byte、short、char）在运算的时候，统统先转化为int（这一点和算术运算符相同）

证明：

public static void main(String[] args){byte bValue = 10;short sValue = 300;char cValue = 'a';byte bResult = bValue << 2;short sResult = sValue >> 2;char cResult = cValue >>> 1;}

结果：

由上图可知，各种整型经移位操作后，都转化成了int类型

2.当移位的位数超过被移位对象本身的类型的位数，例如 32 >> 100，我们知道32是int类型，它的位数是32，但现在要向右移动100位，这时就需要将移动的位数换成100 % 32 = 4位，即新移动位数 = 原移动位数 % 被移动类型位数，所以32 >> 100 与 32 >> 4 是一样的

证明：

    public static void main(String[] args){byte bValue = 10;int result1 = bValue << 66;int result2 = bValue << 2;System.out.println("result1 : " + result1);System.out.println("result2 : " + result2);}

结果：

由上图可知，将bValue左移66位和左移2位是一样的，因为根据新移动位数 = 原移动位数 % 被移动类型位数，2 = 66 % 8

4、比较运算符：

比较运算符包括大于（>）、大于等于（>=）、小于（<）、小于等于（<=）、是否等于（==）、是否不等于（!=），运算结果为布尔类型，若为真则返回true，否则返回false，由于比较运算符比较简单，此处不再赘述。

5、逻辑运算符：

逻辑运算符用于操作两个boolean类型的变量或常量。我把它分为以下几类：

1）与系：

包括&&（短路与）和&（非短路与）

共同点：两真才真——操作符两边都必须为true，结果才为true

不同点：

&&是左假即为假——&&左边的操作数如果为false，立即终止计算，返回false

&是左假看右边——&左边的操作数为false时，并不立即返回false，还要再看右边的操作数，然后再返回false

示例程序：

public static void main(String[] args){int iValue1 = 10;int iValue2 = 1;//短路与，左边"iValue1 > 10"为false，右边"iValue2++ >= 1"不执行if((iValue1 > 10) && (iValue2++ >= 1)){iValue1 = 0;    }System.out.println("iValue1 :" + iValue1);System.out.println("iValue2 :" + iValue2);System.out.println();//非短路与，两边都会执行if((iValue1 > 10) & (iValue2++ >= 1)){iValue1 = 0;    }System.out.println("iValue1 :" + iValue1);System.out.println("iValue2 :" + iValue2);}

效果：

2）或系：

包括短路或（||）和非短路或（|），共同点与不同点和与系完全类似：

共同点：两真才真——操作符两边都必须为true，结果才为true

不同点：

||是左真即为真——||左边的操作数如果为true，立即终止计算，返回true

|是左真看右边——&左边的操作数为true时，并不立即返回true，还要再看右边的操作数，然后再返回true

示例程序：

public static void main(String[] args){int iValue1 = 10;int iValue2 = 1;//短路或，左边"iValue1 <= 10"为true，右边iValue2++ >= 1不执行if((iValue1 <= 10) || (iValue2++ >= 1)){iValue1 = 0;    }System.out.println("iValue1 :" + iValue1);System.out.println("iValue2 :" + iValue2);System.out.println();//非短路或，两边都要执行if((iValue1 <= 10) | (iValue2++ >= 1)){iValue1 = 0;    }System.out.println("iValue1 :" + iValue1);System.out.println("iValue2 :" + iValue2);}

效果：

3）其他：

包括！（非)、^（异或），前者是一个单目运算符，运算规则是——遇true则false，遇false则true，后者是一个双目运算符，运算规则是——不同则true，相同则false

6、三目运算符：

Java中唯一的一个三目运算符是：

[expression]？if-true-statement：if-false-statement

其中，expression是一个结果为boolean类型的表达式，如果结果为true，则返回if-true-statement，否则返回if-false-statement

示例程序：

public static void main(String[] args){int iValue = 10;//[expression]部分为false，返回if-false-statementSystem.out.println(iValue > 10 ? "汪峰": "章子怡");//[expression]部分为true，返回if-true-statementSystem.out.println(iValue != 1 ? "汪峰" : "章子怡");}

效果：

《疯狂Java讲义》第3章——数据类型和运算符相关推荐

1. 《Java疯狂讲义》第3章(数据类型和运算符)：博主李俊德的阅读笔记与知识拓展

   一.问题背景 博主在准备应聘的笔试.面试时,再次采用了多年以来的Java工具书<Java疯狂讲义>,并决定在每章详细复习后都要在博客中写下详细的阅读笔记. 二.阅读笔记与知识拓展--< ...

2. 疯狂java讲义第五章课后习题答案

   1.编写一个学生类,提供name.age.gender.phone.address.cmail成员变量,且为每个成员变量提供 seter.geter方法.为学生类提供默认的构造器和带所有成员变量的构造 ...

3. 疯狂java讲义第四章习题答案

   1.使用循环输出九九乘法表. 疯狂java讲义第四章课后习题第1题答案 2.根据给定的层数,使用循环输出等腰三角形. 疯狂java讲义第四章课后习题第2题答案 3.给定半径输出圆形. 需要注意的是,计 ...

4. 疯狂java讲义第17章网络编程课后习题答案

   课后习题p845 练习书上的例子并且说出他们的用意 补充习题 1.说出nio的非阻塞式网络通信和aio的异步网络通信的含义和区别联系. 2.URL和Socket的区别和使用场景是什么?tcp和udp的 ...

5. 疯狂java的第四章答案_疯狂java讲义第四章第一题

   package chapter04; /**** * 本帖最后由 kongyeeku 于 2012-3-11 23:02 编辑 看到有一些读者询问关于该题的解题思路,其实这个题是有一些很绕的地方. 大 ...

6. 疯狂java讲义第七章补充习题第12题答案

   12.使用Calendar的各种方法 变量 ALL_STYLES AM AM_PM APRIL areFieldsSet AUGUST DECEMBER DST_OFFSET ERA FEBRUARY ...

7. java疯狂讲义第四版第五章答案_疯狂java讲义第五章笔记

   1 定义类,成员变量和方法 类和对象 定义类 java的类名由一个或者多个有意义的单词组合而成,每个单词的首字母大写,其他的全部消协,并且单词之间没有分隔符. 成员变量:用于定义该类或者实例的所包含的 ...

8. 疯狂java讲义第六章课后第4题答案

   4.定义一个类,该类用于封装一桌梭哈游戏,这个类应该包含桌上剩下的牌的信息,并包含5个玩家的状态信息:他们各自的位置.游戏状态(正在游戏或已放弃).手上已有的牌等信息.如果有可能,这个类还应该实现发牌 ...

9. 疯狂java讲义第16章多线程课后习题答案

   课后习题p779 1. 2. 练习书上例子并说明它的用意 补充习题 1.尝试使用Android Studio的单步调试功能. 2.说出线程池和连接池的区别和联系 3.使用继承Thread的方法创建两个 ...

10. 【疯狂Java讲义】第二章 理解面向对象

最新文章

1. 导师发现我刷短视频，给我发了一条链接
2. mysql5.0入门_MySQL 5.0基础的基本内容的介绍
3. samll note
4. 成都（10月24日时代广场）Windows 7社区发布活动
5. volatile 使用说明
6. 用python语言调试程序你用的平台是_Python 程序如何高效地调试？
7. 关于linux挂载windows共享文件夹的试验
8. Android localsocket 的基础和使用实践: 01
9. wpf messagebox.show()点击其他地方会闪烁_定时、童锁、故障查询，线控器上的这些功能你会用吗？...
10. 遍历~筛选~eq()；filter();first();last();has();is();map();slice()
11. 华为u8825d解锁工具_黔隆科技刷机教程VIVOY55L.PD1613忘记密码刷机解锁降级救砖解屏幕锁账户锁教程...
12. 2021电子设计竞赛题目_艾孜尔江
13. 关于学历与面试的一些看法
14. px像素和dp像素密度区别
15. codevs 2806 红与黑
16. gif太大了怎么压缩？教你一招轻松压缩gif大小
17. 【技术贴】全盘文件夹快捷方式 杀毒后快捷方式消失，但文件夹打不开。重装系统后还是快捷方式的解决办法。...
18. SpringBoot+Vue项目校园综合管理系统
19. MVG（second）学习笔记- 三角形法
20. BGP-边际网关路由协议简记

热门文章

1. 《黑色沙漠》游戏分析与拆解
2. 中美科学家造出“人-猴胚胎”，这会是魔幻剧情的开端吗？
3. 电脑连wifi老是断断续续的怎么回事
4. 物理计算机主机ip在哪,查看电脑的物理地址_查看电脑的物理ip地址
5. 布局 - 收藏集 - 掘金
6. IDE也卷了，微软杀入嵌入式IDE
7. VMware Workstation中安装系统和VMware tools
8. 裸辞之后自己在家接单是什么体验？
9. 安卓-几种查看SHA1和MD5的方法
10. 查看电脑开关机时间和记录