第二章 程序基础概念

通过本节需要达到：掌握Java中标识符的定义，掌握Java中注释的作用以及三种注释的区别，掌握Java中数据类型的划分以及基本数据类型的使用原则，掌握字符串与字符的区别，可以使用String类的类型定义字符串并进行字符串内容的修改，掌握Java中运算符的使用。

2.1 程序注释

        在程序中，由于其基本组成都是代码，所以考虑到程序的可维护性的特点，在编写代码的之后都要在每段代码上增加若干说明文字，即注释。注释本身不需被编译器编译，Java一共分为三种形式。
//注释：单行注释
/*...*/:多行注释
/**..*/:文档注释

提示：关于几种注释的选择：
一般而言，在开发中往往会接触一些开发工具，如果使用Eclipse或IDEA这样的开发工具，建议使用单行注释，这样即使格式化多行代码时也不会造成代码的混乱。而对于文档注释，也往往会介个开发工具编写，
范例：定义单行注释
public class JavaDemo
{
public static void main(String args[])
{
System.out.println("qqqq");
}
}
本程序的功能是在屏幕上进行信息输出，在注释信息追加之后就可以明确获取代码的作用，使得代码的可读性与维护性大大加强。
范例：定义多行注释
多行注释利用/*..*/进行定义，而后每行注释使用*作为标记
        文档注释是以单斜杠加两个星型标记(/**)开头，并以一个星型标记加单斜杠(*/)结束。用这种方法注释的内容会被解释成程序的正式文档，并能包含进如javadoc之类的工具生成的文档，用以说明该程序的层次结构及其方法。
范例：使用文档注释
/**
*该类的作用主要是在屏幕上输出信息。
*@author李兴华
*/
public class JavaDemo
{
public static void main()
{
System.out.println("111");
}
}
在文档注释中提供了许多类似于“@author”这样的标记，例如，参数类型、返回值、方法说明等，而对于初学者而言，重点掌握单行注释和多行注释。
提示：文档注释在开发中使用较多
在进行软件开发的过程中，开发的技术文档是每一位开发人员都必须配置的重要工具之一，对于每一个操作的功能都会在文档中进行详细的描述，所以建议读者养成编写文档注释的习惯。

2.2 标识符与关键字

        程序本质上就是一个逻辑结构的综合体，在Java语言里面有不同的结构，例如，类、方法、变量结构等，那么对于不同的结构一定要有不同的说明。这些说明在程序中被称为标识符，所以在进行标识符定义的时候一般要求采用有意义的名称。
        在Java中的标识定义的何新华原则如下：由字母、数字、_、$所组成，其中不能使用数字开头，不能使用Java中的保留字
提示：随着编程经验的累积，对于标识符一般都会有自己的原则,建议如下：
在编写的时候尽量不要使用使用数字，例如i1、i2
命名尽量有意义，不要使用类似a,b等的简单字符，而要使用Student、Math等单词，因为这类单词都属于有益的单子
Java中标识符是区分大小写的，例如，mldn、Mldn标识两个不同的标识符。
$符号由特殊意义，不要使用(会在内部类中进行讲解)
可以利用中文标识符，
在定义标识符中另外一个重要的概念就是避免使用关键字。所谓的关键字，指的就是具备由特殊要求的含义的字母，例如public、class、static这些都属于关键字，关键字全部用小写字母的姓氏标识：
 

abstruct	assert	boolen	break	byte	case	catch	char
class	continue	const	default	do	double	else	extends
enum	final	finally	float	for	goto	if	implements
import	instanceof	int	interface	long	native	new	null
package	private	protected	public	return	short	static	synchronized
super	strictfp	switch	this	throw	throws	transient	try
void	volatile	var	while

对于所有给出的关键字有几点需要注意
Java有两个未使用到的关键字：goto(在其他语言中表示无条件的跳转)、const(在其他语言中表示常亮)
jdk1.4之后增加了assert关键字
jdk1.5之后增加了enum关键字
Java有3个特殊含义的标记(严格来说不会是关键字)：true、false、null
在JDK1.10之后追加了var关键字，用于实现动态变量声明
提示：不需要死记硬背Java中的关键字
对于初学者而言，如果要全部记住以上关键字是一件比较麻烦的事情，但是熟练运用学过的知识可以进行总结：
访问控制：public、protected、private
类、方法、变量修饰符：abstact、class、extends、final、implements、interface、naive、new、static、strictfp、synchronized、transient、volatile、void、enum

2.3 数据类型划分

任何程序严格来说都属于一个数据的处理游戏。所有对于数据的保存必须有严格的限制，具体体现在数据类型的划分上，即不同的数据类型可以保存不同的数据内容。Java的数据类型可分为基本数据类型与引用数据类型两大类型。其中基本数据类型包括了基本的byte、short、int、long、float等。另一种为引用数据类型(类似于C、C++语言的指针)，这类数据在操作时必须进行内存的开辟。
        提示：本章将重点讲解基本数据
基本数据类型不牵扯到内存分配的问题，而引用数据类型需要由开发者为其分配内存空间，而后进行关系的匹配。Java的基本数据类型主要以数值的方式进行，这些基本数据类型的保存数据单位与默认值如下：
long保存的整数范围是最大的，double保存的浮点数范围也是最大的。下面分享一些基本数据类型的选取经验
1 表示整数就用int(例如，表示一个人的年龄)，设计小数就用double(例如，表示一个人的成绩或者工资)
2 描述日期时间数字、文件、内存大小(程序中是以字节为单位统计大小的)使用long，而较大的数据(超过了int范围，例如，数据库之中的自动增长列)长度也是用long
3 实现内容传递(I/O操作、网络编程)或者编码转换时使用byte
实现逻辑控制，可以使用boolen描述
4 使用中文时使用char可以避免乱码问题。
由于现在的计算机硬件不断升级，对于数据类型的选择也不想早期编程那样收到严格控制，short、float等数据类型已经很少使用了。
        有了数据类型的划分后就可以进行变量的定义与赋值处理操作，考虑到程序语法的严谨性，Java需要为每一个变量进行数据类型的定义，这样才方便进行内存空间的开辟，同时在进行变量定义的时候可以通过=为变量设置初始化的内容。
可以从上表可以发现不同的数据类型均有对应的默认值，但是这些默认值只在定义类结构的过程中起作用，如果在进行方法定义时都需要进行明确的初始化内容。关于类与方法的定义，可以在后续进行完整学习。
        另外，考虑到对不同JDK版本的支持，需要对赋值使用做出两个区分：在JDK1.4以及以前的版本中方法定义的变量要求赋值，而从JDK1.5后开始方法中定义的变量可以在声明时不赋值。
范例：JDK1.5后的变量声明与赋值支持
public class JavaDemo{
public static void main(String args[])
{
int num;
num=10;
System.out.println(num);
}
}

同样地程序代码，如果放在JDK1.4以及以前版本就会出现错误，所有的版本：
public class JavaDemo
{
public static void main(String args[])
{
int num=10;
System.out.println(num);
}
}
在进行变量定义的时候，建议为每个变量设置默认值，且Java中的变量也有明确的命名要求：第一个单词的首字母小写，随后每个单词的首字母大写，如studentName、mldnInfo。

2.3.1 整型

整形数据一共有四种类型，按照保存的范围由小到大分别为byte、short、int、long，在java里面任何一个整形常量(例如30、100这样的数字)，其默认的类型都是int型
范例：定义int型变量
public class JavaDemo
{
public static void main(String args[])
{
int x = 10 ;
System.out.println(x*x);
}
}
在本程序中定义了一个整型变量x，并且在声明变量时为其赋值为数字10.由于变量x属于int型，所以计算之后的x*x也是int类型。

注意：保持良好的编程习惯
        以上程序是一个相对而言比较同意理解的代码，在实际的开发中，除了保证代码的正确性外，也需要拥有良好的变成习惯，在编写代码“int x = 10 ;”时，每一个操作之中都加上一个空格，这样做的目的是为了避免由于编译器bug所造成的非正常性语法的编译错误。
提问：变量和常量的区别是什么
本章中一直强调的变量和常亮有什么区别，如何区分
回答：所谓常亮，指的就是一个个具体的内容，例如，一个数字10，内容始终是无法改变的，这样的内容就被称为常亮。
变量一般都需要定义相应的数据类型。而且这个变量一般都可以保存不同的内容，既然内容可变那么就被称为变量。

范例：理解变量和常量
public class JavaDemo
{
public static void main(String [] args)
{
int num = 10 ;
num = 20 ;
System.out.println(num*num);
}
}

程序执行结果：
400
在本程序中的数字10和20就属于一个常亮，这些内容永远不会改变，而num内容可以改变就被称为变量。
任何数据类型都有对应的数据保存范围，但是在一些特殊的情况下有可能计算结果会超过这个限定的范围，就可能会造成数据的溢出问题。

范例：观察数据溢出
public class JavaDemo
{
public static void main()
{
int max=2147483647;
int min=-2147483648;
System.out.println(max+1);
System.out.println(max+2);
System.out.println(min-1);
}
}

程序执行结果：
-2147483648(max+1语句执行结果）
-2147483647(max+2语句执行结果)
2147483647(min-1语句执行结果)
本程序中定义了两个表变量：max(保存int最大值)、min(保存int最小值)，由于int型变量与int型常亮计算后的数据类型依然是int型，所以此时出现了数据的溢出问题

提示：关于数据类型的溢出问题的揭示
如果学习过汇编语言的学者就会发现，在计算机中二进制是基本组成单元，而int型数据一共占据32位的长度，也就是说第1位都是数据位，当已经是该数据类型保存的最大值时，如果继续进行‘+1’的操作就会造成符号位的变更，最终会造成数据溢出的问题。但不必要过于担心开发过程中出现的数据溢出问题，只要控制得当并且合乎逻辑(例如求一个人的年龄问题㐊绝对不会出现数据溢出问题)。
        如果要想解决这种溢出的问题，就只能够通过扩大数据范围的方式来实现，比int范围更大的long数据类型。而要将int型的变量或常亮变为long数据类型有以下两种形式
形式1：int型变量转换为long型变量，使用数字‘L’，数字l完成。
形式2：int型变量转换为long型变量，使用(long) 变量名称。实际上可以用此类方法实现各种数据类型的转换，例如，如果将int类型变量变为double型变量，可以使用(double) 变量名称，即数据类型转换为通用格式“(目标数据类型) 变量”
范例：解决数据溢出(在操作时需要预估数据范围，如果发现数据保存范围不够就是用更大范围的数据类型):
public class JavaDemo{
public static void main(String args[])
{
long max=2147483647;
long min=-2147483648;
//long型数据+int型数据=long型数据
System.out.println(max+1);
System.out.println(max+2);
System.out.println(min-1);
}
}

程序执行结果：
2147483648(max+1的执行结果)
2147483649(max+1的执行结果)
-2147483649(max-1的执行结果)
        本程序为了获取争取的计算结果使用了long类型定义了max和min两个变量，这样计算的数据即使超过了int数据范围(但没有超过long数据类型)也可以获得正确的计算结果。
提示：另一种解决数据溢出问题
对于数据溢出问题除了以上的处理方式之外，也可以计算时进行强制类型转换。
public class JavaDemo
{
public static void main(String args[])
{
int max=2147483647; //获取int的最大值
int min=-2147483648;//获取int的最小值
//int 型变量+long型变量=long型变量
System.out.println(max+1l);
System.out.println(max+2l);
//long型变量-int型变量=long型计算结果
System.out.println((long)min-1);
}
}
程序执行结果：
2147483648；(max+1l语句执行结果)
2147483649;(max+2l语句执行结果)
-2147483649((long)min-1);
不同的数据类型之间是可以黄钻换的，即范围小的数据类型可以自动转化为范围大的数据结构，但是如果反过来，范围大的数据类型要转化为范围小的数据类型，就必须采用强制性的处理模式，同时还需要考虑可能带来的数据溢出。

范例：强制类型转换
public class JavaDemo
{
public static void main(String args[])
{
long num = 2147483649L;
int temp=(int)num ;
System.out.println(temp);
 }
}
程序执行结果：
-2147483647(数据溢出)
本程序定义了一个超过int范围的long变量，所以在进行强制类型转换时就出现了数据溢出问题，字节是一种定义了一个超过int范围的long变量，所以在进行强制类型转换时就出现了数据溢出问题。字节是一种存储容量的基本单位，在Java中使用关键字byte进行定义，而且byte也属于整形定义，其保存的范围是-128-127.
范例：定义byte变量
public class JavaDemo
{
public static void main(String args[])
{
byte num = 20 ;
System.out.println(num);
}
}

本程序定义了byte变量num，并且其设置的数据的范围在byte允许范围内。
提问：为什么此时没有进行强制转型
在本程序汇中执行byte num = 20 ;语句时，20是一个int型的常亮，但是为什么在byte赋值时没有进行强制类型的转换。
回答：在byte范围内可以将int常亮转化为byte常量
在Java语言中为了方便开发者为byte变量赋值，所以进行了专门的定义。如果所赋值的数据在byte范围内将自动转换，如果超过byte范围则必须强制转换：
范例：int 常亮强制转为buye类型
public class JavaDemo{
public static void main(String args[])
{
byte num=(byte)200;
System.out.println(num);
}
}
程序执行结果：
-56
由于数字200超过了byte类型，所以必须进行强制转换，所以此时出现了数据溢出问题。

2.3.2 浮点型

浮点型数据描述的是小数，而在Java里面任意一个小数常亮对应的类型为double，所以在以后描述小数的时候建议直接使用double来进行定义。
范例：定义double变量
public class JavaDemo{
public static void main(String args[])
{
double x=10.2;
int y=10;
double result=x*y;
System.out.prinln(result);
}
}

程序执行结果102.0
所有的数据类型进行自动转型的时候都是由小范围数据类型向大范围数据类型进行自动转换处理，所以int型变量会自动穿换位double类型后才可以进行计算，这样最终计算完成的结果就是double型。
        由于Java默认的浮点类型为double，如果定义为位数相对较少的float变量，在赋值时就必须采用强制类型转换。
        范例：定义float型变量
public class JavaDemo
{
public static void main(String args[])
{
float x=(float)10.2;
float y=10.1F;
System.out.println(x*y);
}
}
本程序利用了两个float型的变量进行惩罚运算，但是最终的结果可以发现多出了一些小数位，而这个问题也是Java长期以来的漏洞。
范例：观察整型除法计算
public class JavaDemo
{
public static void main(String args [])
{
int x=10;
int y=4;
System.out.println(x/y);
}
}
程序执行结果
2(计算结果缺少小数位)
        通过此时的计算可以发现，当前使用的类型为int，在进行除法计算后只保留了整数位，而想要解决这个问题，必须将其中一个变量的类型转换为double或float。
范例：解决除法计算中小数点问题
public class JavaDemo{
public static void main(String args[])
{
int x=10;
int y = 4;
System.out.println((double)x/y);
}
}"
本程序在进行除法计算中为了保证计算结果的正确性，将计算中的数据类型转化为了double，从而实现了小数位的数据保存。
注意：关于var关键字的使用
Java最初作为一种静态语言，这就要求在进行变量定义时都必须明确地为其定义数据类型，并且在随后的变量使用中也要求为变量赋值正确类型的数据。到那时从JDK1.10后为了迎合动态语言的支持，提供有var关键字，既可以通过设置的内容自动识别对应类型。
范例：使用var关键字
public class JavaDemo{
public static void main(String args[])
{
var num=10.2;
num=100;
System.out.println(num);
}
}
程序执行结果：
100.0(定义num时识别为double类型)
本程序利用var关键字定义了num动态变量，由于其赋值的常量为10.2，属于double类型，所以num的类型就为double；随后赋值的常亮100虽然是整型，但是由于num的类型是double，所以自动转型为double。
        虽然Java提供这样的动态语法，但是从本质上来讲，Java的动态变量定义并不如其他语言强大(例如javascript或python)

2.3.3 字符型

在计算机的世界里，一切都以编码的形式存在。Java使用的是十六进制的Unicode编码，此类编码可以保存任意的文字，所以在java中进行字符处理时就可以避免由于位数长度不同所造成的乱码问题，如果要定义字符变量则可以使用char关键字进行定义。
提示：关于Java中字符编码问题
在Unicode编码设计过程之中，考虑到与其他语言的结合问题(C/C++),那么在此编码里与ASCII编码的部分编码重叠，以下面的编码为例
大写字母范围：65('A')-90('Z')
小写字母范围：97('a')-122('z'),大写字母和小写字母之间差了32
数字字母范围：48('0')-57('9')
范例：定义char变量
public class JavaDemo
{
public static void main(String args[])
{
char c='A';
System.out.println(c);
}
}
        在Java中可以使用int型接受char型变量，这样就可以获取相应字符
提示：char和int转换
public class JavaDemo
{
public static void main(String args[])
{
char c='A';
int num=c;
System,out.println(num);
num+=32;
System.out.println((char)num);
}
}
程序执行结果：
65(大写字母A的编码数值)
a(编码增长之后将int型重新转回char)
        此时程序中可以使用int型接受char型变量，这样就可以获取相应字符的编码信息，由于大小写字母之间差了32个长度，所以利用这一特点实现了大小写的转换。
提示：使用char还可以保存中文
由于Unicode编码可以保存任何文字，所以在定义char类型是可以将内容设置为中文
范例：设置中文字符
public class JavaDemo
{
public static void main(String args[])
{
char c = '李';
int num = c;
System.out.println(num);
}
}
程序执行结果
26446(中文编码)
在Unicode编码中每一位中文字符都有各自的编码，所以在中文语言环境下当前的程序是没有任何问题的，但是需要注意的是，此时只允许保存一位中文字符。

2.3.4 布尔型

布尔型(boolen)是一种逻辑结果，主要保存两类数据：true和false，这类数据主要用于一些程序的逻辑使用上。
提示：布尔是一位数学家的名字。
范例：观察boolen类型
public class JavaDemo{
public static void main(String args[])
{
boolen flag=true;
if(flag)
{
System.out.println("111");
}
}
}

本程序中使用boolen定义了变量，并且设置内容为true，所以if判断才满足执行条件。
提示：关于O与非O描述布尔值的问题
在许多程序设计语言中，由于涉及的初期没有考虑布尔值的问题，就是用数字0表示false，而非0表示true。但是这样设计的对于代码开发比较混乱，Java中不允许使用0或1来填充布尔型的变量内容。

2.3.5 String字符串

字符串是Java中提供的一个系统类，其并不是基本数据类型，但是由于此类的使用较为特殊，所以可以向基本数据类型那样定义并且使用。
public class JavaDemo
{
public static void main(String args [])
{
String str="1111";
System.out.println(str);
}
}
本程序定义了一个String型的变量，利用“"”可以定义字符串中的组成内容。根据此类模式可以定义更多字符串，而字符串自荐可以使用“+”进行连接
范例：字符串链接
public class JavaDemo
{
String str="www.";
str+="mldn";
str+="cn";
System.out.println(str);
}
本程序首先定义了字符串变量str，随后利用“+”实现了字符串内容的连接处理。
提示：关于字符“+”在链接字符串与数值加法计算上的使用
在字符串上使用+可以实现字符串的连接功能，但是需要注意的是，“+”也可以用于两个数值的加法计算，如果混合使用，则所有的数据类型将全部变为字符串内省，而后实现连接处理。
范例：错误的“+”使用
public class JavaDemo
{
public static void main(String args[])
{
double x=10.1;
int y=20;
String str="计算结果"+x+y;
System.out.println(str);
}
}
程序执行结果
计算结果：10.120
在本程序中原本的含义是希望可以输出加法计算的结果，但由于存在字符串猖狂，所以所有的数据类型全部变味了字符串，而“+”就成为字符串连接的处理。如果要想解决此类问题，可以使用（）修改优先级。
范例：解决错误的连接使用
public class JavaDemo
{
public static void main(String args[])
{
double x=10.1;
int y=20;
String str="计算结果"+(x+y);
System.out.println(str);
}
}

由于（）执行的优先级最高，所以先执行基本数据类型的加法操作，而将最终的加法计算结果与字符串链接。
在进行字符或字符串描述的时候也可以使用转义字符来实现一些特殊符号的定义，例如，换行(\n)、制表符(\t)、\(\\)、双引号（\"）、单引号（\'）
范例：使用转义字符
public class JavaDemo
{
public static void main(String args[])
{
System.out.println("111 \t 1111 \n ");
}
}

2.4 运算符

Java中的语句有很多种形式，表达式就是其中的一种形式。表达式由操作数与运算符组成：操作数可以是常量、变量或方法，而运算符就是数学中的运算符号+、-、*、/、%等、以表达式z+10为例，z与10都是操作数，而+就是运算符。
Java中提供了许多运算符，这些运算符除了可以处理一般的数学运算外，还可以进行逻辑运算、地址运算等。根据其所使用的类的不同，运算符可分为赋值运算符、算术运算符、关系运算符、逻辑运算符、条件运算符等

提示：没有必要去记住这些优先级
从实际的工作来讲，这些运算符的优先级没有必要专门去记，就算勉强记住了，使用起来也很麻烦，所以在此笔者建议多使用（）去改变优先级才是最好的方式。

注意：不要写复杂的运算操作
范例：不建议使用的代码
public class JavaDemo
{
public static void main(String args[])
{
int x = 10 ;
int  y=20 ;
int result=x-- + y++ *--y/x/y*++x;
System.out.println(result);
}
}
虽然以上的程序可以得出最终的计算结果，但是面对如此复杂的运算，不建议。

2.4.1 数学运算符

程序是一个数据处理的逻辑单元，同时也是以数学为基础的学科，在Java中提供的运算符合一实现基础四则运算、数值自增或自减运算，
范例：四则运算
public class JavaDemo
{
public static void main(String args[])
{
int result=89*(29+100)*2;
System.out.println(result);
}
}
在四则运算中默认的顺序是县城出后加减，在本程序中使用括号修改了默认的优先级。
范例：模运算
public class JavaDemo
{
public static void main(String args[])
{
int num=10;
num=num%3;
System.out.println(num);
}
}
在Java中使用%运算符实现了模运算(余数)，所以10模3的结果就是1
在Java中为了简化数学运算与赋值的操作，也提供有一些简化结构，这些运算符表示参与运算之后直接进行赋值操作。
例如+=、-=、*=、/=、%=
范例：使用简化运算符
public class JavaDemo
{
public static void main(String args[])
{
int num=10;
num+=20;
System.out.println(num);
}
}
程序执行结果：
30
在数值型变量定义后也可以方便地实现数据自增与自减的操作，该操作主要使用++与--两种操作符完成，根据所处位置的不同，实现的机制也不同：
++运算符，自增，变量值加1，放在变量前表示先自增后运算，放在变量前表示先计算后自增，--运算符也一致，
范例：实现自增与自减操作
public class JavaDemo{
public static void main(String args[])
{
int x=10;
int y=20;
int result=++x-y--;
System.out.println("计算结果"+result);
System.out.println("x="+x);
System.out.println("y ="+y);
}
}
程序执行结果：
计算结果：-9(x自增 - y的内容)
x=11（变量x自增后的结果）
y=19(变量y自减后的结果)
本程序中在进行计算时采用了混合运算符，首先会计算“++x”的结果是11，随后将此计算后的结果与y作减法处理，最终的结果就是-9，档y参加计算后执行自减处理，变量y的内容变为19.

2.4.2 关系运算符

关系运算符的主要特征就是进行大小的比较处理，包括>、<、>=、<=、！=、==。所有的关系运算返回的判断结果都是bool类型的数据；
范例：大小关系判断
public class JavaDemo
{
public static void main(String args[])
{
int x=10;
int y=20;
boolen flag=x>y;
System.out.println(flag);
}
}
程序执行结果：
false
本程序中实现了两个整数变量的大小判断，由于变量x的内容小于变量y的内容，所以判断结果为false。
范例：相等判断
public class JavaDemo
{
public static void main(String args[])
{
double x=10.0;
int y=10;
boolen flag=x==y;
System.out.prinltn(flag);
}
}
本程序使用==运算符判断了两个数据变量是否相同，由于int和double属于两种类型，所以首先会将int转换为double类型后再进行比较。
范例：相等判断
public class JavaDemo
{
public static void main(String args[])
{
char x='李';
int y=26446;
boolen flag=x==y;
System.out.println(flag);
}
}
本程序首先判断了int与char两种不同类型的内容是否相同，由于char可以与int实现自动类型转换，所以此时会将char转换为int，后在进行相等判断。

2.4.3 三目运算符

在进行程序开发的时候三目运算符应用的最多，使用三目运算符可以减少一些逻辑判断的编写。三目是一种所谓的赋值运算处理。它需要设置一个逻辑关系的判断之后才可以进行赋值操作，基本语法如下：
数据类型 变量=关系运算？关系满足时内容：关系不满足时内容。
范例：使用三目运算符
public class JavaDemo
{
public static void main(String args[])
{
int x=10;
int y=20;
int max=x>y?x:y;
}
}
本程序中使用了三目运算符，并且将数值大的内容赋值给变量max

提示：三目运算符简化if逻辑判断

如果不使用三目运算符，那么以上范例也可以通过以下的if语句结构进行代替。
public class JavaDemo
{
int x=10;
int y=20;
int max=0;
if(x>y)
max=x;
else
max=y;

}
 

2.4.4 逻辑运算符

逻辑运算符一共包括三种：与(多个条件一起满足)、或(多个条件只有一个满足)、非(使用！操作，可以实现true和false之间的转换)
范例：使用非运算符
public class JavaDemo
{
public static void main(String args[])
{
boolen flag=!(1>2);
System.out.println(flag);
}
}
在本程序中括号中的表达式1>2的判断结果为false，但是当使用了运算符！后结果转变为true

范例：逻辑与运算
public class JavaDemo
{
public static void main(String args[])
{
int x=1;
int y=1;
System.out.println(x==y&&2>1);
}
}
在本程序中执行了两个判断条件：x==y 2>1,此时由于两个判断条件的结果都是true，所以与之后是true
提示：关于&和&&的区别
与逻辑运算的操作需要若干判断条件全部返回true，最终的结果才是true；如果有一个判断条件为false，那么不管多少个true最终结果一定是false。所以在Java中针对逻辑与操作提供两类运算符
普通与逻辑&：所有的判断条件都进行判断。
短路与逻辑&&：如果前面的判断条件反悔了false，直接中断后续的判断条件执行，最终结果就是false，
范例：使用普通地与逻辑运算符
public class JavaDemo
{
public static void main(String args[])
{
//条件1:1>2返回false
//条件2:10/0==0执行时会出现ArithmeticException异常导致程序中断
System.out.println(1>2&&10/0==0);
}
}
执行结果：
false
本程序中使用短路与逻辑，可以发现条件2并没有执行，即短路与判断性能要比普通的好。
或逻辑运算符也可以连接若干个判断语句，在这里判断一个为true，最终结果就是true

范例：或逻辑运算
public class JavaDemo
{
public static void main(String args[])
{
int x=1;
int y=1;
System.out.println(x!=y||2>1);
}
}
本题设置了两个判断条件，由于第二个判断条件2>1返回true，最终结果就是true。

提示：关于|和||的区别
或逻辑运算的操作特点就是若干个判断条件有一个返回了true，那么最终的结果就是true，所以在java中针对于或的运算符有两类
普通或逻辑|，所有的判断条件都执行。
短路或逻辑||：若干个判断条件如果有一个返回了true，那么后续的条件将不再判断

范例：普通或逻辑运算
public class JavaDemo
{
public static void main(String args[])
{
//条件1:1！=2返回true
//条件2:10/0==0
System.out.println(1!=2|10/0==0)
}
}
呈现执行报错
本程序定义了两个判断条件，1！=2返回true，10/0产生ArithmeticException算术错误，由于此时使用了普通地或，则在第一个判断条件返回true后，会执行第二个判断条件，此时就产生了异常，此时可以考虑短路与操作：
public class JavaDemo
{
public static void main(String args[])
{
//条件1:1！=2返回true
//条件2:10/0==0
System.out.println(1!=2||10/0==0)
}
}

2.4.5 位运算符

在Java中提供位运算符，该类运算符由操作数和位运算符所组成，可以实现对数值类型的二进制数进行运算，在位运算符中提供有两类运算符：逻辑运算符(~(取反)、&(按位与)、|(按位或)、^(异或))、移位运算符(>>(右移位)、<<(左移位)、>>>(无符号右移位)):
在Java中所有的数据都是以二进制数据的形式进行计算的，即如果一个int型变量，要采用位运算的时候必须将其变为二进制数据。每一位二进制进行与或异或操作的结果如下：
 

No.	二进制1	二进制2	与	或	异或
1	0	0	0	0	0
2	1	0	0	1	1
3	0	1	0	1	1
4	1	1	1	1	0

提示：10进制转二进制，
十进制转化为二进制的原则为数据除2取余，最后倒着排序，例如25的二进制为1101，但由于Java的int数据类型为32位，所以实际上最终的数据位：00000000 00000000 0000000 0011001

范例：实现位与操作
public class JavaDemo
{
public static void main(String args[])
{
int x=13;
int y=7;
Syetem.out.println(x&y);
}
}
程序执行结果5
计算分析：
13的二进制：00000000 00000000 00000000 00001101
7的二进制：00000000 00000000 00000000 00000111
|结果：00000000 00000000 00000000 00001111
10进制十15
移位操作
public class JavaDemo
{
public static void main(String args[])
{
int x=2;

Sysetm.out.println(x<<2);
Sysetm.out.println(x);
}
}

左移后结果8
原来结果2