目录
2.1代码注释与编码规范 为让代码容易懂 //为单行注释 /* */是多行注释 /** */注释运行会学显示出来
2.2变量与常量 注意标识符，
2.2.1标识符与关键字
1.标识符
标识符可以简单地理解为一个名字，用来标识类名、变量名、方法名、数组名等有效的字符序列。
Java语言规定标识符由任意顺序的字母、下划线(_ )、美元符号)($)和数字组成，并且第一个字符不能是数字。标识符不能是Java中的保留关键字。
编写Java代码有一套公认的命 名规范，如下。
(1)类名:通常使用名词，第一个单词字母必须大写，后续单词首字母大写。(2)方法名:通常使用动词，第一个单词首字母小写， 后续单词首字母大写。
(3)变量)第一个单词首字母小写，后续单词首字母大写.
(4)(常量)所有字母均大写。
(5)单词的拼接:通常使用"userL asName"式拼接单词，而不是"Nor _last_namer.
2.关键字
关键字是Java语言中已经被赋予特定意义的一些单词，不可以把这些字作为标识符来使用。简单理解为凡是在Eclipse变成红色粗体的单词，都是关键字。Java 语言中的关键字如下
Java关键字
int
public
this
finally
boolean
abstract
continue
float
long
short
throw
throws
return
break
for
static
new
interface
if
goto O
default
byte
do
case
strictfp
package
super
void
try
switch
else
catch
implements
private
final
class
extends
volatile
while
synchronized
instanceof
char
proteced
import
transient
dafault
double
2.3基本数据类型
数据类型决定了内存中存储数据的类型及所需内存的大小。Java的数据类型可分为两大类：
一、基本数据类型：byte、short、int、long、double、float、boolean、char
二、引用数据类型：类、接口、数组、枚举、注解
其中在基本数据类型中，byte、short、int、long为整型，是用来定义整数的关键字；double、float为浮点型，是用来定义小数的关键字；boolean为布尔型，又称逻辑型，只有true和false两个取值；char为字符型，采用Unicode编码，一个Unicode编码占2个字节（即16位），由于字符型不存在正负之分，所以其表示范围为0至2的16次方-1（0～65535）。
其中整型数据有如下四种表述形式：
一、十进制整数，例如12，-127,0。
二、二进制整数，以0b开头，例如0b011 （对应于十进制的3 ） （JDK7.0开始）。
三、八进制整数，以0开头，例如014（对应于十进制的12）。
四、十六进制整数，以0x或0X开头，例如0XF（对应于十进制的15）。
浮点型数据有如下两种表示方式：
一、十进制形式，例如3.14。
二、科学计数法形式，例如3.14e1。
字符型数据可以有以下四种赋值方法：
一、 使用英文单引号（'）括起单个字符；例如：
char c1 = 'a';
char c2 = '中';//char可以存储一个中文(一个中文也占2个字节)；
二、 使用英文单引号括起来十六进制字符代码值来表示单个字符，格式为'\uXXXX'，其中u是约定的前缀，为Unicode的第一个字 母，例如：
char c1 ='\u0061';// 实质代表a字母
三、 可以直接使用数字表示单个字符，例如：
char c2 = 97;//表示a字母
四、 某些特殊的字符可以采用转义符'\'来表示，以将其后面的字符转变为其它含义，例如：
char c1 = '\t';//制表符
char c2 = '\n';//换行符-New Line
char c3 = '\r';//回车符-Carriage Return
数据类型的转换可分为自动类型转换和强制类型转换两种类型。小范围数据可以直接转换为大范围数据，此为自动转换类型；大范围数据转换为小范围数据则为强制类型转换，可能出现精度缺失或溢出等现象。
如下特列一个溢出现象：
int x=(int)23.89;//x的值为23
long y=(long)34.98F; ;//y的值为34
byte z = (byte)256;//z的值为0，数据结果出现溢出
整型：
byte:1个字节 8位 -128~127
short ：2个字节 16位
int ：4个字节 32位
long：8个字节 64位
浮点型：
float：4个字节 32 位
double ：8个字节 64位
注：默认的是double类型，如3.14是double类型的，加后缀F（3.14F）则为float类型的。
char类型：
char：2个字节。
Boolean 类型
boolean: （true or false）（并未指明是多少字节 1字节 1位 4字节）
补充：BigInteger类实现了任意精度的整数运算，BigDecimal实现了任意精度的浮点数运算。
char占16位两个字节
一.常见的转义字符
转义字符对应的英文是escape character , 转义字符串（Escape Sequence）
字母前面加上捺斜线""来表示常见的那些不能显示的ASCII字符.称为转义字符.如\0,\t,\n等，就称为转义字符，因为后面的字符，都不是它本来的ASCII字符意思了。
所有的转义字符和所对应的意义：
注意：区分，斜杠："/" 与 反斜杠："" ,此处不可互换
二./斜线与\反斜线
① / 斜线， slash或又称为forward slash （前斜线）， 原本是标点符号。 起源于古罗马，中世纪时用作逗号（而当时的双斜线//是被当作连接号的，后来演化成等号=）。
a) 英语里的斜线， 最常用的即使替代字符“or”表选择， 比如： Yes/No； 还有就是避免名字的冲突，比如美国的人口普查表中有"Assyrian/Chaldean/Syriac"， 就是为了避免因Syriac名字不同叫法而产生的冲突或歧义，其实也是or的含义；
b) 算术； 英文里面称over， 比如： 123/456，也即分数
c) 金钱表示。 $50/- 表示50美元上限， 后面没有了，防止有人添加修改。
d) 日期的表示
② \ backslash, 反斜线， 主要用于电脑中， 也正是对普通/斜线的借鉴。 操作系统（xNix）， 电脑语言（C/C++, Perl），编码（部分Unicode）等都使用它。
2.4数据类型转换
sticker_start_tag_for_text 14:30:28
1.小范围类型-->-->大范围类型：自动类型转换。
2.大范围类型-->-->小范围类型：
1.若大范围类型的数超出小范围类型的值的范围： 报错，精度会有损失。
2.若大范围类型的数没有超出小范围类型值范围：
1. 若小范围类型为byte short char：编译器自动补充强制类型转换。
2.若小范围类型为 int：报错，精度会有损失。
sticker_start_tag_for_text 14:33:41
1、数据类型的分类
2、比较数据类型之间的字节大小
1字节=8位
、
3、转换中的知识点
*java中整数类型默认的int类型；小数类型默认的double；
*String的字符串转化为char类型时，只能用char类型的数组来接收；字符串在转化成char类型是不能像int、float那样使用封装类的parseXXX方法等，但它可以转换成char类型的数组；
自己心得：byte de=(byte) 128;System.out.println(de); 结果：-128
//如果数字溢出当前的数字类型，有两种方法可以阻止其出错，一种是直接强转成 当前数据类型，另一种是转成其他的数据类型（较大的）
//在进行数据类型转换时，两个char类型的数字相加强转成char时，会对应成字符编码里面的，但大多都会
//出现乱码，一个char类型的数字，一个字符如‘a’相加，最后结果会对应字符编码里面的，并输出相对应的字符；
//如果是提升为int类型时，不论是两个char类型的数字相加，还是一个char类型的字符和一个数字最后的结果都是数字
例如：
char c=12;
char c1=12;
char c4='a';
char c5=28;
char sa='a';
char sa1='b';
int c3=c+c1;
int c7=c4+c5;
char c2=(char) (c+c1);
char c6=(char) (c4+c5);
char sa3=(char) (sa+sa1);
System.out.println("**********");
System.out.println(c2);
System.out.println(c6);
System.out.println(sa3);
System.out.println("**********");
System.out.println(c3);
System.out.println(c7);
结果：
*String的字符串进行类型转换时，如果字符串中包含long整形的字符大写L或者小写l时，在转换成字符串时，会出现错误
例如： String str="123L";
long str1=Long.parseLong(str);
System.out.println(str1);//结果：错误
*String的字符串是float、double浮点型时，字符串可以加f、F、D、d等，在进行基本类型转换时不会出错
例如： String f1="12.34f";
float f2=Float.parseFloat(f1);
System.out.println(f2);//结果：12.34,；d、D也一样
4、转换
*自动类型转换(也叫隐式类型转换) ，其实就是小范围的数据类型向大范围的数据类型转换，例如int类型转long
*强制类型转换(也叫显式类型转换) int b = (int)(i + j);
*强制类型转换在某种情况下会丢失精度
*表达式的数据类型自动提升
5进行四则运算时
a、所有的byte型、short型和char的值将被提升到int型
b、如果一个操作数是long型，计算结果就是long型
c、如果一个操作数是float型，计算结果就是float型
d、如果一个操作数是double型，计算结果就是double型
e、如果一个操作数是String型，计算结果就是String型
2.5运算符算数运算符、关系运算符、逻辑运算符、位运算符
Java的运算符，分为四类：
算数运算符、关系运算符、逻辑运算符、位运算符。
算数运算符(9)：+ - * / % ++ --
关系运算符(6)：== != > >= < <=
逻辑运算符(6)：&& || ! ^ & |
位运算符(7)：& | ~ ^ >> << >>>
-------------------------------------------------------------------------
Java基本数据类型：
数值类型：
整型：byte、short、int、long
非整型：double、float
非数值类型：char[字符]、boolean[布尔]
-------------------------------------------------------------------------
一：算数运算符：
注：算数运算符操作数必须是数值类型。
分为一元运算符和二元运算符；
一元运算符，只有一个操作数；
二元运算符有两个操作数，运算符在两个操作数之间。
一元运算符：正‘+’，负‘-’，自加‘++’，自减‘--‘这四个。
①”++“和”--“运算符，只允许用于数值类型的变量，不允许用于表达式中；
"++"和”--“可以用于数值变量之前或者之后；
两处使用差别：
”++“和”--“用于数值变量之前，在赋值操作中，先对被”++“或”--“操作变量值先加1或者先减1，然后在进行其他的操作；
"++"和”--“用于数值变量之后，在赋值操作中，先用被”++“或”--“的操作变量值进行其他的操作，然后在对其值加1或者减1。
-
package com.numerical; -
public class Operator { -
public static void main(String[] args) { -
int a = 5; -
int b,c,d,f,g,h; -
b = +a; //正值 -
System.out.println("b="+b+",a="+a); -
c = -a; //负值 -
System.out.println("c="+c+",a="+a); -
int l = 2; -
d = ++l; //先l=l+1;再d=l -
System.out.println("d="+d+",l="+l); -
int m = 3; -
f = m++;//先f=m;再m=m+1 -
System.out.println("f="+f+",m="+m); -
int n = 4; -
g = --n;//先n=n-1;再g=n -
System.out.println("g="+g+",n="+n); -
int o = 6; -
h = o--;//先h=o;再o=o-1 -
System.out.println("h="+h+",o="+o); -
} -
}
上代码，输出结果为：
b=5,a=5
c=-5,a=5
d=3,l=3
f=3,m=4
g=3,n=3
h=6,o=5
注：一元运算符和前后的操作数之间有空格，可能在有些编译器下编译时会出错。
②二元运算符，加'+'，减'-'，乘'*'，除'/'，求余'%'。
在算数运算符中，”+“，”-“，”*“，”/“完成加减乘除四则运算，%是求两个操作数相除后的余数。
运算规则和数学运算基本相同，在算数运算中，计算时按照从左向右的顺序计算，乘除和求余优先于加减，不同的是，程序中的乘运算符不可省略，在数学中可写为”y=2x“而程序中必须写为”y=2*x“。
当二元运算的两个操作数的数据类型不同时，运算结果的数据类型和参与运算的操作数的数据类型中精度较高(或位数较长)一致。
-
int a = 3; -
double b = 3.53;//或者3.53d -
float c = 1.7f; -
int d = 1; -
System.out.println("int /int :a/d="+a/d); -
System.out.println("double/int:b/a="+b/a); -
System.out.println("float/int:c/a="+c/a);
输出结果为：
int /int :a/d=3
double/int:b/a=1.1766666666666665
float/int:c/a=0.56666666
转换原则：
从低精度向高精度转换byte 、short、int、long、float、double
低精度到高精度会自动转换，而高精度到低精度则要类型强制转换。
-
int a = 7; -
double b = 5.33; -
b = a; -
a = (int) b;
计算机的数据长度:
位：一个二进制数据0或1，是1bit(位)；
字节：存储空间的计量单位,是1byte = 8bit；如数据库的VARCHAR为字节；
-
boolean 类型变量的取值有：ture、false,1字节（8位） -
char数据类型有：unicode字符,16位 -
byte：一个字节（8位）（-128~127）（-2的7次方到2的7次方-1） -
short：两个字节（16位）（-32768~32767）（-2的15次方到2的15次方-1） -
int：四个字节（32位）（一个字长）（-2147483648~2147483647）（-2的31次方到2的31次方-1） -
long：八个字节（64位）（-9223372036854774808~9223372036854774807）（-2的63次方到2的63次方-1） -
float：四个字节（32位）（3.402823e+38 ~ 1.401298e-45）（e+38是乘以10的38次方，e-45是乘以10的负45次方） -
double：八个字节（64位）（1.797693e+308~ 4.9000000e-324）
对应java的基本数据类类型：Integer、Float、Boolean、Character、Double、Short、Byte、Long
注意：
①数值计算中语法现象——“晋升”，即：byte、short和char(低于int的数据类型)进行算术运算后，结果会自动提升成int类型；
②两个char型运算时，自动转换为int型；当char与别的类型运算时，也会先自动转换为int型的，再做其它类型的自动转换；
③算数运算可以加入小括号"()"提高优先级，优先小括号内运算，再其他运算符运算；
④算数运算前操作数变量必须赋值，反之，报语法错误。
二：关系运算符：
关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑类型(boolean布尔类型)的数值。
等于'=='，不等于'!='，大于'>'，大于等于'>='，小于'<'，小于等于'<='
以下代码为：
-
System.out.println("9.5<8 :"+(9.5<8)); -
System.out.println("8.5<=8.5:"+(8.5<=8.5)); -
System.out.println("a~z："+((int)'a')+"~"+((int)'z')); -
System.out.println("A~Z："+((int)'A')+"~"+((int)'Z')); -
System.out.println("'A' < 'a':"+('A' < 'a'));//字符'A'的Unicode编码值小于字符'a'
输出结果为:
9.5<8 :false
8.5<=8.5:true
a~z：97~122
A~Z：65~90
'A' < 'a':true
注： boolean类型只能比较相等和不相等，不能比较大小；
>=的意思是大于或等于，两者成立一个即可,结果为true，<=亦如此；
判断相等的符号是两个等号，而不是一个等号，这个需要特别小心。
实际代码中，数值、变量以及运算结果都可以直接参与比较，只是程序中为了增强可读性，有些时候需要将比较分开进行书写。
比较运算符是程序设计中实现数据比较的基础，也是很多逻辑实现的基础，在程序逻辑中，经常通过比较一定的条件，来判断后续的程序该如何执行。
三：逻辑运算符：
逻辑运算符要求操作数的数据类型为逻辑型，其运算结果也是逻辑型值。
逻辑运算的数据和逻辑运算符的运算结果是boolean类型。
逻辑与'&&'，逻辑或'||'，逻辑非'!'，逻辑异或'^'，逻辑与'&'，逻辑或'|'
逻辑运算符的真值表：
A和B是逻辑运算的两个逻辑变量；
两种逻辑与（&&和&）的运算规则基本相同，两种逻辑或（||和|）的运算规则也基本相同。 &和|运算是把逻辑表达式全部计算完，而&&和||运算具有短路计算功能。 对于&来说，如果左侧条件为false，也会计算右侧条件的值，而对于&&来说，如果左侧的条件为false，则不计算右侧的条件，这种现象被称作短路现象。 所谓短路计算，是指系统从左至右进行逻辑表达式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。 对于&&运算来说，只要运算符左端的值为false，则因无论运算符右端的值为true或为false，其最终结果都为false。 所以，系统一旦判断出&&运算符左端的值为false，则系统将终止其后的计算过程； 对于 || 运算来说，只要运算符左端的值为true，则因无论运算符右端的值为true或为false，其最终结果都为true。 所以，系统一旦判断出|| 运算符左端的值为true，则系统将终止其后的计算过程。
注：异或相同为false，相反则为true。
利用短路现象：
在程序设计时使用&&和||运算符，不建议使用&和|运算符。
四：位运算符： 位运算是以二进制位为单位进行的运算，其操作数和运算结果都是整型值。 位与'&'，位或'|'，位非'~'，位异或'^'，右移'>>'，左移'<<'，0填充的右移'>>>' 位运算的位与'&'，位或'|'，位非'~'，位异或'^'与逻辑运算的相应操作的真值表完全相同，其差别只是位运算操作的操作数和运算结果都是二进制整数，而逻辑运算相应操作的操作数和运算结果都是逻辑值boolean型。
下边为位&运算： int a = 15; //x等于二进制数的00001111 int b = 6; //y等于二进制数的00000110 int c = x&y //z等于二进制数的00000110
结果为：二进制数的00000110
右移是将一个二进制数按指定移动的位数向右移位，移掉的被丢弃，左边移进的部分或者补0（当该数为正时），或者补1（当该数为负时）。这是因为整数在机器内部采用补码表示法，正数的符号位为0，负数的符号位为1。
将一个数左移"<<"会使该值乘以2的幂。 将一个数右移>>"会使该值除以2的幂。 右移（补零）运算符，即无符号右移，">>>"永远不会产生负号，因为其符号位总是被补零。 不论被移动数是正数还是负数，左边移进的部分一律补0。
-
System.out.println(1<<3); -
System.out.println(8>>3);
输出为：8
1
int x = 70; //x等于二进制数的01000110 int y = 2; int z = x>>y //z等于二进制数的00010001 即运算结果为z等于二进制数00010001，即z等于十进制数17。
int x = -70; //x等于二进制数的11000110 int y = 2; int z = x>>y //z等于二进制数的11101110 即运算结果为z等于二进制数11101110，即z等于十进制数-18。 右移和左移操作，是整数机器数的补码表示法。
&运算符规定必须信号A和B都被充电，其结果才是充电。(1表示充电，0表示未充电)
|运算符规定只要信号A或B被充电，输出结果就是充电。
^异或（XOR）运算符规定如果信号A或B之一被充电，但是信号A和B不是同时被充电，则结果为充电。
~运算符也称为按位求补，它翻转所有的充电状态值。
五：赋值运算符与其他运算符的简捷使用方式 ：
① 赋值运算符可以与二元算术运算符、逻辑运算符和位运算符组合成简捷运算符，从而可以简化一些常用表达式的书写。
在程序开发中，大量使用“一元运算符或移位运算符等”该区别简化代码的书写，这样做，因为这样将增加阅读代码的难度，尽量注释。
② 方括号[]和圆括号（）运算符
方括号[]是数组运算符，方括号[]中的数值是数组的下标，整个表达式就代表数组中该下标所在位置的元素值。
圆括号（）运算符用于改变表达式中运算符的优先级。
-
String [] sa = {"a","b","c","d"}; -
System.out.println(sa[2]);
输出为：c
③ 字符串加（+）运算符
当操作数是字符串时，加（+）运算符用来合并两个字符串；当加（+）运算符的一边是字符串，另一边是数值时，机器将自动将数值转换为字符串，并连接为一个字符串。
-
String a ="aa"; -
int c = 555; -
String b = a+"bbb"+c; -
System.out.println(b);
输出为：aabbb555
④ 条件运算符(三目运算符)
<表达式1> ？<表达式2> : <表达式3>
先计算<表达式1>的值，
当<表达式1>的值为true时，则将<表达式2>的值作为整个表达式的值；
当<表达式1>的值为false时，则将<表达式3>的值作为整个表达式的值。
-
int a = 55,b = 132,res; -
res = a > b ? a : b; -
System.out.println(res);
输出为：132
⑤强制类型转换符
强制类型转换符能将一个表达式的类型强制转换为某一指定数据类型
-
int a; -
double b = 5.66600; -
a = (int) b; -
System.out.println(a);
输出为：5
⑥对象运算符instanceof
对象运算符instanceof用来测试一个指定对象是否是指定类（或它的子类）的实例，若是则返回true，否则返回false。
-
String s = new String("sa"); -
if(s instanceof Object){ -
System.out.println("String is object class"); -
}
输出为：String is object class
⑦点运算符
点运算符"."的功能有两个：一是引用类中成员，二是指示包的层次等级。
-
String s = "i am string"; -
s = s.substring(5); -
System.out.println(s); -
Map<Integer, String> map = new HashMap<Integer, String>(); -
map.put(1, "A"); -
map.put(2, "B"); -
map.put(3, "C"); -
Iterator it = map.entrySet().iterator(); -
while(it.hasNext()){ -
Map.Entry<Integer, String> me =(Map.Entry<Integer, String>) it.next(); -
System.out.println("key="+me.getKey()+",value="+me.getValue()); -
}
输出为：
string
key=1,value=A
key=2,value=B
key=3,value=C
在实际的开发中，可能在一个运算符中出现多个运算符，计算时，就按照优先级级别的高低进行计算，级别高的运算符先运算，级别低的运算符后计算.
运算符优先级表
优先级自上而下，级别由高
复合运算
优先级
例2.1 声明double 型常量,并给常量赋值,使用常量进行计算。
运行结果
例题2.2给int型变量按照十进制、八进制、十六进制赋值
运行结果
例题2.3展示4.35*100的错误结果，并给出解决方案。
运行结果
例题2.4计算2.0—1.9的结果，与0.1进行比较，展示错误结果，并给出解决方案。
运行结果
例题2.5使用转义字符
运行结果
例题2.6声明boolean变量
例题2.7创建不同数值类型的变量，进行隐式转换
运行结果
例题2.8创建不同数值类型的变量，进行显式转换
运行结果
例题2.9使用赋值运算符为变量赋值，实例代码如下:
例题2.10使用算术运算符将变量的计算结果输出。
例题2.11在循环中使用自增运算符，查看自增的效果。
例题2.12使用关系运算符对变量进行比较运算。
例题2.13使用逻辑运算符和关系运算符对变量进行运算。
例题2.14使用逻辑运算符进行运算
例题2.15使用位移运算符对变量进行位移运算
例题2.16让byte、short两种类型的变量做无符号右移操作。
190
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
