当你对 Java语言有了一些了解后，你就可以开始着手学习Java了。

作为你的Java 学习第一天，所需掌握内容如下述目录：

当然！前提是我们都安装好了 JDK，并测试完成了 HelloWorld 的编写编译和运行，那我们只需要随意选择一个自己顺手的编辑器，便可以对以下内容的学习进行聚焦。

---

1. 注释

在程序员实际工作当中，会编写大量符合逻辑的代码以至到达完成程序设计目的为止。
如果你脑袋里目前还没有大量代码的想象画面，可以想象成一大坨的HelloWorld，然而过多的HelloWorld在追忆其作用时会大大增加你的时间，降低你的工作效率。所以你可以用注释将其进行说明，哪怕时间过于长久，也可以迅速反应其代码的实质功能。

那到底什么是注释？
与大多数程序设计语言一样，Java中的注释也不会出现在可执行程序当中，
也就是说，程序在执行过程当中会忽略注释的定义。

1. 三种注释

Java中的注释分为三种：

1.1 单行注释

最常用简介的叫做单行注释，如果用HelloWorld代码作为事例，如：

public class HelloWorld{
	public static void main(String args[]){
		// 一个简单的输出语句
		System.out.println("Hello!!!~World");
	}
}

1.2 多行注释

当然，如果你需要说明的内容更多时，也可以用多行注释，如：

/*
public 是权限修饰符，用于控制该代码在其程序中被访问的权限

class 是类的关键字，在Java中，所有的代码都定义在一个类中

HelloWorld 是该类的名称，要注意的是该名称需与其文件名称一致

{} 相当于标准语法，Java是强类型语言，一定要注意语法规范

static void 暂时不需顾虑，面向对象章节会详细介绍

main 是主方法，该文件在被虚拟机执行时，虚拟机会根据main来执行器内部内容

System.out System系统下的out对象，然后通过.调用 println 方法

; 分号是逐行结束必须要写的规范
*/
public class HelloWorld{
	public static void main(String args[]){
		System.out.println("Hello!!!~World");
	}
}

1.3 文档注释

其实多行注释不用写的如上那么清晰，只是多于单行注释内容的基础上说明程序就可以了。如果说明的像上述那么清晰，更应该采用文档注释，因为它可以帮助你生成文档。

文档注释 以 /** 开头，*/结束。且每句的空行都有一个 * 如下：

/**
 *public 是权限修饰符，用于控制该代码在其程序中被访问的权限

 *class 是类的关键字，在Java中，所有的代码都定义在一个类中

 *HelloWorld 是该类的名称，要注意的是该名称需与其文件名称一致

 *{} 相当于标准语法，Java是强类型语言，一定要注意语法规范

 *static void 暂时不需顾虑，面向对象章节会详细介绍

 *main 是主方法，该文件在被虚拟机执行时，虚拟机会根据main来执行器内部内容

 *System.out System系统下的out对象，然后通过.调用 println 方法

 *; 分号是逐行结束必须要写的规范
*/
public class HelloWorld{
	public static void main(String args[]){
		System.out.println("Hello!!!~World");
	}
}

现在你已经了解了三种注释如何使用，这里我们暂时不说明如何自动生成文档，
因为我们的学习动机是快些搞清楚 三种注释是怎么一回事。

---

2. 标识符和关键字

标识符和关键字两个概念本身是有区别的，千万不要混淆。

2.1 标识符的组成：

标识符由：字母、数字、_(下划线)、$(美元符号)，组成。
其中不能以数字开头，不能是 Java语言本身使用的关键字。
.
注意！Java语言本身严格区分大小写。

2.2 那到底什么是标识符呢？

关键字是指官方定义的名称，也就是Java语言本身的开发者，在开发语言时定义的名称。比如 public 和 class 就是关键字。

所以标识符可以理解成是我们自己在编码过程中定义的名称。

如果作为小白，还不是很理解，那我们可以写一个代码段加以说明：

这里不得不提起一个有意思的小插曲帮助你消化理解，Java语言在中国市场大火以后，在JDK 1.7之后加入了对中国语言的支持。

我们就用中文定义标识符来帮助消化：

//这里我们将类的标识符定义为了你好
public class 你好{
	public static void main(String args[]){
		System.out.println("Hello!!! ~World");
	}
}

---

3. 数据类型划分

任何程序严格来讲都属于一个数据的处理游戏。所以对于数据的保存必须有严格的限制，这些限制就体现在了数据类型的划分上，即：不同的数据类型可以保存不同的数据内容。
.
注：Java 是强类型语言，这意味着必须为每一个变量声明一种类型。

在编程的学习过程中，总会后知后觉，即便现在不理解某些概念，我也一定要告诉你：
Java的数据类型分为：基本数据类型、引用数据类型，两种！

基本数据类型包括：byte、short、int、long、float、double、char、boolean
而引用数据类的概念为：在操作的时候必须要进行内存的开辟。

也就是说基本数据类型不会涉及到对内存空间的开辟，而引用数据类型的使用需要开发者为其分配空间，而后在进行关系的匹配。

此外，java的基本数据类型主要以数值的方式进行定义，这些基本数据类型的保存数据范围与默认值如表：

No.	数据类型	大小/位	可表示的数据范围	默认值
1	byte（字节）	8	-128 ~ 127	0
2	short（短整型）	16	-32768 ~ 32767	0
3	int（整型）	32	-2147483648 ~ 2147483647	0
4	long(长整型)	64	-9223372036854775808 ~ 9223372036854775807	0
5	float（单精度）	32	-3.4E38(-3.410^38) ~ 3.4E38(3.410^38)	0.0
6	double（双精度）	64	-1.7E308(-1.710^308) ~ 1.7E308(1.710^308)	0.0
7	char（字符）	16	0 ~ 255	‘\u0000’
8	boolean（布尔型）	-	true 或 false	false

上述表格当中的内容除了数据范围都是你一定要记住的，但是 byte字节的取值范围也最好记住！

表格当中数据类型的所占大小用到的单位是：位，在计算机当中 1字节等于8位

对数据类型和数据类型划分有了相对了解后，
我们开始逐个解析！

3.1 数据类型的逐个解析：

3.2 整数类型：

3.2.1. int

任何一个数字常量如：10、30、50、90…在 Java 中都属于 int 数据类型。
即：在 java中所有设置的整数内容默认都为 int 型数据。

public class TestintDemo {
    public static void main(String args[]){
        //语法：数据类型 变量名称 = 变量;
        int num = 10;  // 10 是常量，常量的默认值是int
        int result = num * 2; //变量num的值乘以2，计算结果存于变量result当中
        System.out.println(result); // 输出打印 result
    }
}

如果你现在不了解变量和常量的概念先姑且搁置，我们会在下个知识点进行讨论。

TestintDemo 代码片段说明：

这是我们第一次在文章中嵌入带有些许逻辑的代码，所以顾及新手村的朋友，进行详细说明：
本程序首先定义了一个 数据类型为int的 num 变量，然后给其赋予一个常量值：10，
接着我们又定义了第二个变量：result，同样也为int数据类型，然后给其赋值并不是固定的常量值，而是四则运算当中的乘法运算。最后输出语句输出的也是result变量，可想而知其值为多少？

我们这里只演示了一个简单的乘法运算，当然！如果用户需要，也可以是四则运算当中任意一个！(加法+、减法-、乘法*、除法)

接下来还要强调一下取值范围的重要性！

3.3 取值范围重要性！

回想一下上面的表格！对就是数据类型介绍的那个表格！
如果程序超出了取值范围会出现什么现象呢？

我们用int类型来做个测试：

public class TestintOutDemo {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE; //取最大值
        int min = Integer.MIN_VALUE; //取最小值

        //查看int类型取值范围的最大值和最小值
        System.out.println(max); //控制台的输出结果：2147483647
        System.out.println(min); //控制台的输出结果：-2147483648

        //给最大值做加法
        // 预计结果：2147483647 +1
        System.out.println("最大值+1后："+(max+1));
        //给最小值做减法
        // 预计结果：-2147483648 -1
        System.out.println("最小值-1后："+(min-1));
    }
}

我们看一下程序的运行结果：

这是怎么一回事？
最大值 +1后变成了负数，最小值-1后居然变成了正数！?

该计算超过了其数据类型本身的取值范围就会出现一个循环的操作，最大值如果继续增加就变为最小值，随后一直向其次的最小值进行循环，反之最小值减1就变为最大值，此种现象称为溢出。
.
在计算机中二进制是基本的组成单元，而 int 型数据一共占 32位长度，也就是说第一位是符号位，其余的31位都是数据位。当然数据已经是该数据类型保存的最大值时，如果继续进行+1的操作就会造成符号位的变更，最后就会形成这种数据溢出的问题。

一般针对这种问题，其实只要合理选用数据类型即可，比如你要存储年龄相关的数据可以使用int类型，int类型的取值范围已经足够作为存储年龄使用了，毕竟年龄不会超过 int 类型的取值范围吧？难道你…

或者你还可以转型，你别忘了整数类型有 byte short int long 四个呢！

3.4 什么叫转型？

整数类型一共有四个：byte short int long
它们其中的每一个都有自己所占内存空间的大小，根据它们之间的大小来排列它们的大小，自小向大：byte short int long。自大向小：long int short byte。
内存所占较小的转向大的一方叫做自动转换，内存空间所占较大转向小的一方叫做强制转换。

那这个demo我们如何转？

3.2.2 long（自动类型转换说明）

我们可以让int类型实现自动类型转换为字节空间所占更大的long类型。

public class TestintTolongDemo {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE; //取出最大值
        int min = Integer.MIN_VALUE; //取出最小值

        System.out.println("输出向上转型后的最大值："+(max+1L));
        System.out.println("输出向上转型后的最小值："+(min-1L));
    }
}

转型的实现方法：

在转型过程中，将参与运算的其中一个值转向较大类型，其结果的数据类型也会自动转向为较大类型，而不在是整数类型的默认 int。

转型的方法只要加上特定语句便可轻松实现：

如：

int num1 = 10; //int类型
int num2 = 20; //int类型
System.out.println((long)num1 + num2); //long 可以加给参与运算的任意一个变量

如：
如果参与运算的并不是两个变量：例，一个常量、一个变量

int num1 = 10;
System.out.println(num1 + 20L); //可以直接给常量加上L，将其转型为不是默认int的long
System.out.println((long)num1 + 20); //或者还是将变量的存储方转为long

3.5 强制类型转换说明

我们已经知道了内存空间所占较小的一方转向较大的一方如何实现。
下面来说明内存空间所占较大的一方转向较小的一方如何实现。

long num = 1000;
int x = (int)num; //强制类型转换的语法为：
		//在转型方的前面加上优先级运算符()，然后在符号内填写所转换的目标数据类型
System.out.println(x);

虽然程序支持我们做强制类型转换，但是一定要注意程序溢出造成的数据丢失问题！

3.6 更合理的类型转换图：

3.2.3 byte

整数类型中还有另外两个数据类型没有介绍到，那就是 byte 和 short！

byte 数据类型的取值范围： -128 ~ 127 这一点要牢记！

public class TestbyteDemo {
    public static void main(String[] args) {
        byte num = (byte) 130; //由于：默认的int整数130 超过了byte数据范围，
        					//需要做强制类型转换
        					
        System.out.println(num); //程序运行结果为：-126
                                //强制类型转换造成了数据丢失
    }
}

选用一个超过取值范围的例子是想告诉大家一个概念：

java 为 byte类型改善了自动类型转换

public class TestbyteDemo {
    public static void main(String[] args) {
        byte num = 127; //127默认为int类型，这里没有做强制类型转换！
        			//因为：没有超过byte数据类型的取值范围！
        System.out.println(num); 
                                
    }
}

3.6 关于数据类型的默认值

我们知道每个数据类型都有其默认值，但是在jdk1.4版本之前需要格外注意的是：类中的变量可以暂时不指定其默认值，而方法中的变量一定要指定默认值，否则会编译报错！

例：

public class TestintDemo{
	static int num;
	public static void main(String args[]){
		System.out.println(num);
	}
}

则：

public class TestintDemo{
	public static void main(String args[]){
		int num;
		num = 0; //但是此编码形式在 jdk 1.4 及之前会报错
				// 必须写为：int num = 0;
		System.out.println(num);
	}
}

当然。此一节点只是作为补充说明！

3.7 浮点类型

浮点类型就是数学中的小数类型，整数的默认类型为 int，而小数的默认类型则为 double（‘该类型是保存数据范围最广的’）。
在 java中表示小数类型的数据类型有两个，一个是float，一个是double，而double的存储数据范围恰好又是float的两倍，固而又都称double为双精度数值。

3.7.1 double

先来看一下如何使用 double来定义小数。

public class TestdoubleDemo {
    public static void main(String[] args) {
        double num = 10.2;
        System.out.println(num * 2); //这里包含一个自动类型转换
            //因为 double的内存空间所占大于int数据类型，
            //固较小的int类型会自动转换为较大的double类型
    }
}

look 程序的执行结果：

3.7.2 float

由于小数的默认类型为double类型，如果想使用float类型则需要做强制类型转换。转换的方式有两种：变量 使用字母 “F” 或 “f” ； 常量则是在常量值前加上括号，括号内填写 float。

public class TestfloatDemo {
    public static void main(String[] args) {
        float num1 = 10.2F;
        float num2 = 10.2f;
        float num3 = (float)10.2;
        System.out.println(num1 + num2 + num3);
    }
}

程序的最终执行结果应该为：30.6，我们运行查看一下：

居然不是期待的 30.6！？
这是源于 Java本身的BUG，这个问题光靠计算本身是无法解决的，需要运用我们后期将会学习的 BigDecimal类 或是 Math 两个工具类来解决。

3.8 只有 double 或 float 才可以保存小数

int x = 9;
int y = 5;
System.out.println(x / y);

该段代码的运行结果自动省略了小数！

源于使用 两个int类型进行定义，想改变其结果可以将其任意一方进行转型。

int x = 9;
int y = 5;
System.out.println(x / (double)y);
// System.out.println(x / (float)y);

在来看一下程序转型之后的运行结果：

3.9 字符型

3.9.1 char

byte 属于字节，按照传统概念来讲：一个字符 等于 两个字节(一个char等于两个byte)。
下面示例代码我们会演示 char 与 int 变量的转换。
在计算机世界中，一切都是以编码形式体现的，而 Java使用 UNICODE 编码格式。

unicode编码格式包含了 ASCII 码的部分编码，其中英文字母的范围如下：

• 大写字母： 65 ~ 90
• 小写字母： 97 ~ 122

大写字母和小写字母之间的编码范围相差了 32。
在 Java中，"双引号"的使用表示字符串，而字符则使用 '单引号’表示。

look Code：

public class TestcharDemo {
    public static void main(String[] args) {
        char a = 'A';
        int num = a;
        System.out.println("测试的字符为："+a);
        System.out.println("该测试字符所对应码点为："+num);
    }
}

码点：

一个编码中的某个字符所对应的代码值，称为码点。

写好了代码，补充了码点的概念，我们该来看一下程序的执行结果了：

3.10 常用的编码范围

‘A’（65）~ ‘Z’（90）;
‘a’（97）~‘z’（122）;
‘0’（48）~‘9’（57）;

3.11 利用编码范围转换字母大小写

public class TestcharToBig {
    public static void main(String[] args) {
        char letter = 'A';
        int num = letter + 32;
        letter = (char) num;
        System.out.println(letter);
    }
}

//程序的最后输出结果一定为字符：'a'

3.12 布尔型

布尔两个字源于一个数学家的名字：乔治·布尔(George Boole)。
布尔型是一种逻辑结果，它主要保存 true、false两类数据。

boolean值的使用：

public class TestbooleanDemo {
    public static void main(String[] args) {
        boolean flag = false;
		//利用if语句判断条件是否成立
			//if语句会在后续内容中进行介绍
        if (!flag){
            System.out.println("Hello!!!~World");
        }
    }
}

一定要记住 boolean常用于逻辑判断且它只有两个值！：true、false。
整型值和boolean型之间无法进行转换。
在许多其他编程语言中，如：C++，数值甚至指针可以代替boolean值，值0相当于布尔值false，非0值则相当于boolean的true值。而在Java中不允许使用0或1来代替布尔值。

---

4. 变量和常量

与所有程序设计语言一样，Java 也使用变量来存储值。常量就是值不变的量。

一直，我们都没有明确陈述过变量和常量的概念，
在此一小节，我们详细说明：

4.1 声明变量

其语法为：

//声明变量
数据类型 变量名称;

//声明并赋值
数据类型 变量名称 = 常量值;

// 你甚至可以同时声明多个变量
数据类型 变量名称1,变量名称2,变量名称3;

4.2 变量初始化

直接使用未经过初始化的变量，编译器会报错！

int num;
System.out.println(num);

变量初始化操作是针对这一问题的最好解决办法！
所谓初始化，其实也就是…

int num = 0; //赋值....赋初始值
System.out.println(num); //然后就可以正常使用了！

而且初始化方式有两种，其一就是像上述那样直接写在一行。
第二中方式：

int num; //这种写法只是在声明

//使用时做初始化操作
num = 0; //这样写是在赋值
System.out.println(num);

//而第一种写法是声明并赋值

4.3 变量 and 常量

上面的内容我们只是陈述了变量的声明和使用。那到底什么是常量和变量？

常量：

你可以理解成固定不变的值，不管是整数还是浮点数，只要是固定值，它就称为常量。

变量：

而变量需要先进行声明。如 int num; 虽然还没有赋值，如果你进行赋值如：
int num = 10; 这里就是声明了一个变量，该变量为int类型，其名称为 num。
然后赋值了一个常量10。其实也就是变量里存了一个值，这个值是一个常量。

但其实常量的使用是这样的：

public class TestDemo{
	final static int num = 0;
	//经 final 修饰符修饰后，只能赋值一次且值永远不可改变。
}

---

5. 运算符

当运算符这三个字出现在我的脑袋里时，我的第一反应就是数学当中运算符概念。就像四则运算总是离不开 ‘+’、‘-’、‘*’、‘/’、‘%’。而计算机编程语言当中也有运算符的概念。
更叹为惊奇的是编程语言当中的运算符还有类别划分，其中包括：关系运算符，数学运算符，三目运算符，逻辑运算符，位运算符。

下面进行逐个解析：

我们就先从关系运算符开始玩！

5.1 关系运算符

主要功能就是进行数据的大小关系比较，返回的结果是 boolean 型数据(只有true、false 两种取值)，常用的关系运算符有：
大于 >
大于等于 >=
小于 <
小于等于 <=
等等于 ==
不等于 !=

代码演示：

package TestOperator;

public class TestRelation {
    public static void main(String[] args) {
        System.out.println("大于："+ (3 > 1));
        System.out.println("大于等于："+(3 >= 1));
        System.out.println("小于："+ (3 < 1));
        System.out.println("小于等于："+(3 <= 1));
        System.out.println("等等于："+ (3 == 1));
        System.out.println("不等于："+(3 != 1));
    }
}

我们知道关系运算符只有两种结果值：true 或是 false，程序的运行结果也可想而知

5.2 数学运算符

数学运算符在实际开发中也经常用到，其内容主要有：四则运算，取模，自增等。

5.2.1 四则运算 code 示例

四则运算：加、减、乘、除

int numA = 10;
int numB = 20;

System.out.println("加法计算：" +(numA + numB));
System.out.println("减法计算：" +(numA - numB));
System.out.println("乘法计算：" +(numA * numB));
System.out.println("除法计算：" +(numA / numB));

我们看一下四则运算的测试结果：

哦！触发计算的结果居然为零！？
不为正确结果值的0.5是因为两个int类型进行计算，舍掉了小数部分。

你可以在输入时对其转型，如：

System.out.println("除法计算：" +((double)numA / numB));

这次的结果就没有出现问题了！

可是除法计算中有余数怎么办？

如有除法算式中有除不尽的余数，我们可以利用取模运算符来得到余数

如：

int numA = 10;
int numB = 3;

System.out.ptintln(numA % numB);

如果你不能感受到取模运算符的神奇之处，那么利用它判断奇数偶数如何？

5.2.2 利用取模运算符判断奇数偶数

int num = 10;

if(num % 2 ==0){
	System.out.println("您选择的数字是一个偶数！");
}else{
	System.out.println("您选择了一个奇数~");
}

这里用到的if分支语句，我们会在后续进行详细介绍！
先来看一下程序的执行结果吧：

5.3 简化运算符

简化运算符是为了简化用户的编写，其中包括：*=、/=、+=、-=、%=、++、–

5.3.1 四则运算的简化运算符

//设置变量
int numA = 10;

System.out.println("乘等于："+(numA*=2));

用于其使用方法大同小异，我们在代码处只演示了乘法的简化运算符。待看完执行结果直接跳到更为重要的自增自减运算符。

5.3.2 自增自减运算符

++ 、 --，称为自增和自减。该运算符的设置位置不同，执行的顺序也不同。

以 自增运算符为例：

我们将自增运算符设置在变量后：

int num =1;
num++;
System.out.println(num);

这里设置了一个变量，然后让该变量实现自增操作，最后打印该变量，其结果为2，因为自增1。

可你知道该变量是怎么什么时候自增的吗？
我将代码改动一下，以便更好的说明：

int num =1;

System.out.println(num++);
System.out.println(num);

变量的初始值设置为1，在第一条打印数据出虽然定义了++操作，但是输出时并没有将值进行++，因为将++写在变量的后面时++的操作也是在语句执行完成之后才进行的。你可以看一下程序的执行结果。

程序结果执行图：

那如果将运算符写在变量之前呢？

我们在用自减运算符进行测试：

int num = 5;
--num;
System.out.println(num);

程序执行结果为：

那它是在什么时候完成自减动作的呢？

//同上述自增测试思路相同
int num = 5;

System.out.println(--num);
System.out.println(num);

原来是在语句执行时已经完成了自减动作。

5.4 三元运算符

三元运算符，也有人称其为三目运算符。它是一种赋值形式，执行该运算符时候可以以一个布尔表达式的结果进行赋值。

基本语法：

数据类型 变量 = 布尔表达 ? 设置满足条件所执行的内容 : 设置不满足条件时所执行的内容;

具体示例如下：

//定义变量，存储整数
int numA = 10;
//定义变量，存储第二个整数
int numB = 20;

//定义三目运算符，条件设置为 两个变量的大小比较
	//如果第一个变量的值大于第二个变量，则输出第一个变量存储的值
	//否则，与其相反。切记还要定义变量进行接收。
int max = numA > numB ? numA : numB;
//输出存储三元运算符表达式的变量
System.out.println(max);

其结果显示为：

5.5 逻辑运算符

逻辑运算一共包含三种：
与(多个条件一起满足)
或(多个条件只有一个满足)
非(使用 “!” 操作，可以实现取反值的效果)

5.5.1 使用 ‘!’

取反值的效果，如：结果为true时，得到的是一个false。结果为false时，得到的是一个true。

boolean flag = true; //第一个标志为true值
System.out.println(!flag); //输出时利用 '!' 进行取反

程序执行结果：

5.5.2 普通 ‘&’ 和 短路’&&’

普通与和短路与，其语法形式上的区别是普通与编写一个&，而短路与需要编写两个&&。而真正意义上的作用区别我们在下述代码示例中进行演示。

普通 &：

if ((1 == 2) & (10 / 0 == 0)){
    System.out.println("HelloWorld!");
}

程序执行结果：

程序执行后出现了错误信息，我们知道在数学中，零不可以作为除数，因为没有意义。更重要的是！：我们用了普通与进行运算的连接，当第一个条件直接结果为false时，并没有出现短路效果，而是继续执行后面的条件语句。使用普通与将设置的所有条件语句都执行完成后才返回结果！没错这就是普通与！
.
即： 一个条件值为false时，其结果已经为false。但不具备短路效果，而是将所设置的条件语句都执行完成后，才返回结果。

具备短路效果的工作由短路与负责：

if ((1 == 2) && (10 / 0 == 0)){
     System.out.println("HelloWorld!");
}

虽然没有输出任何结果，但也没有报错信息。因为第一个结果为 false时，结果注定为false，后面的语句将短路。

5.5.3 或

或操作是若干个条件一起进行判断，其中有一个结果值返回为 true，则结果为 true。只有所有结果都为 false时候，才会返回false。
或也有两种 单| 和 双 ||

普通或：

if ((1 == 1) | (10 / 0 == 0)){
	System.out.println("HelloWorld!");
}

执行结果：

虽然普通或的作用是：一个为 ture，结果为true。条件都为 false时，结果才为 false，但程序又出现了错误，可想而知，其效果与普通与一样，不具备短路效果。

反观短路或：

if ((1 == 1) || (10 / 0 == 0)){
	System.out.println("HelloWorld!");
}

好神奇！！居然输出了 HelloWorld！

看来短路与和短路或都具备短路效果，而普通与和普通或都不具备短路效果。
虽然短路与的作用是所有条件都为 true时结果才为true。
而短路或作用则是所有条件中一个为true时，结果就返回为 true。都为false才会返回为false。

5.6 位运算符

位运算符操作的是底层二进制数据，位运算符包括：&、|、^、>>、<<、>>>

由于这里的内容触碰底层，如果用文字讲述清楚需要大量翻阅书籍能容才能转述清楚。
所以这里只说明一个示例。

如果需求让你以最快速度计算 2 * 2 * 2 的值。你会怎么做？
直接Sysmte.out.println(2 * 2 * 2); ？ No!!! 那样计算机还需要先将 十进制的2转换为2进制进行计算，计算之后在将结果转换为十进制进行输出！别忘了计算机的世界是二进制语言。
如果想采用更快的方式实现，你可以利用 位运算符

int num = 2;
System.out.println(num <<2); 

这段代码利用计算机按位存储数据的机制，直接在位上动手脚，向左移动2，位上的数据，结果为：8。效率其高在于：舍去了进制之间的转换，直接移动位上的数据，然后输出结果。

程序执行结果：