关键字
关键字的定义和特点
- 定义：被java语言赋予了特殊含义，用做专门用途的字符串（单词）
- 特点：关键字中所有字母都为小写
- 关键字，在java语言编程的时候，在关键的地方使用的单词，体现关键的地方的含义，这些单词都是特有的，事先定义好的。
| 用于定义数据类型的关键字 |
|---|
| class | interface | enum | byte | short |
|---|---|---|---|---|
| int | long | float | double | char |
| boolean | void |
| 用于定义数据类型值的关键字 |
|---|
| true | false | null |
|---|
| 用于定义流程控制的关键字 |
|---|
| if | else | switch | case | default |
|---|---|---|---|---|
| while | do | for | break | continue |
| return |
保留字
- Java保留字：现有Java版本尚未使用，但以后版本可能回作为关键字使用。自己命名标记符时要避免使用这些保留字
| byValue | cast | future | generic | inner | operator |
|---|---|---|---|---|---|
| outor | rest | var | goto | const |
文本编辑器（辅助编程）
查看代码常用的
| windows | mac |
|---|---|
| notepad++ | Subline Text |
| UltraEdit | BBEdit |
| EditPlus |
notepad++中有竖排编辑模式
按照alt键，用鼠标删除
标识符
- 标识符：
- Java中对各种变量，方法和类等要素命名时使用的字符序列称为标识符
- 凡是可以自己起名字的地方都叫标识符，eg：类名
- 定义合法标识符规则：
- 由26个英文字母大小写，0-9，_或$组成
- 数字不可以开头
- 不可以使用关键字和保留字，但能包含关键字和保留字
- java中严格区分大小写，长度无限制
- 标识符不能包含空格
- 注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
java中的名称命名规范
- 包名：多名词组成时所有的字母都小写：xxxyyyzzz
- 类名，接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
- 变量名，方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
- 常量名：所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ
变量
变量的概念
- 内存中的一个存储区域
- 该区域有自己的名称（变量名）和类型（数据类型）
- java中每个变量必须先声明后使用
- 该区域的数据可以在同一个类型范围内不断变化
使用变量注意：
- 变量的作用域，一对{ }之间有效
- 初始化值 eg. int i ；是错的
定义变量的格式：
数据类型 变量名 = 初始化值
eg. int x = 1
注意：声明变量过程的这个 = ，不是数学意义上的 = ，在java编程中代表赋值。
初始化：第一次给变量赋值
变量是通过使用变量名来访问这块区域的
变量的分类–按照数据类型
- 对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
在Java中，数据类型分为基本数据类型和引用数据类型，其中基本数据类型有八种，除了这八种之外其他的所有数据类型都为引用数据类型。
整数类型：byte，short，int，long
- java各整数类型有固定的表述范围和字段长度，不受具体的OS的影响，以保证java程序的可移植性
- Java的整数类型默认为 int 型，声明 long 型常量必须后加‘ l '或’ L ‘
| 类型 | 占用存储空间 | 表述范围 |
|---|---|---|
| byte | 1字节=8bit | -128——127 |
| short(短整型） | 2字节 | -215——215-1 |
| int(整型） | 4字节 | -231——231-1 |
| long（长整型） | 8字节 | -263——263-1 |
byte b=126;
int i=1;
short s=1;
long l=3l; //3l代表数值为3，但是为一个长整型
浮点类型：float ，double
- 与整数类型类似，java浮点类型也有固定的表述范围和字段长度，不受具体OS影响
- Java的浮点型常量默认为double型，声明float型常量，需后加’ f ’或’ F ’
- 浮点型常量有两种表示形式：
- 十进制数形式。如：5.12 512.0f .512 (必须要有小数点）
- 科学技术法形式。如：5.12e2 512E2 100E-2
| 类型 | 占用存储空间 | 表述范围 | 精度 |
|---|---|---|---|
| 单精度float | 4字节 | -2128——2128 | 7位有效数字 |
| 双精度double | 8字节 | -21024——21024 | 16位有效数字 |
double a=1.22
float f=1.22f float类型赋值时后面带上字母f
字符类型 ：char
- char型数据用来表示通常意义上“字符”（2字节）
- 字符型常量的表现形式：
- 字符常量是用单引号（‘’）括起来的单个字符，涵盖世界上所有书面语的字符。例如：char c1= ‘a’； char c2= ‘哈’ char c3= ’8’
- java中还允许使用转义字符 '‘来将其后的字符转变为特殊字符型常量，例如：char c3= ‘\n’;//’\n’表示换行符
- char类型是可以进行运算的。因为它都对应有Unicode码
| 转义字符 | 说明 |
|---|---|
| \b | 退格符 |
| \n | 换行符（光标下移一行） |
| \r | 回车符（光标回到开头） |
| \t | 制表符 |
| " | 双引号 |
| ’ | 单引号 |
| \ | 反斜线 |
布尔类型：boolean
- boolean类型适用于逻辑运算，一般用于程序流程控制；
- if条件控制语句
- while循环控制语句
- do-while循环控制语句
- for循环控制语句
- boolean类型数据只允许取值true和false，无null
- 不可以0或非0的整数替代false和true，这点和c语言不同
boolean b1=true；
System.out.print(""); //输出但是不换行
System.out.println(""); //输出换行
引用类型：Sting类
- 值null可以赋值给任何引用类型（类，接口，数组）的变量，用以表示这个引用类型变量中保存的地址为空。
- String类属于引用类型，可用null赋值
- String类是一个典型的不可变类，String对象创建出来就不可能改变。创建出来的字符串将存放在数据区，保证每个字符串常量只有一个，不会产生多个副本。
String s0=“hello”；
String s2=“he"+“ll”+“o”;
字符串：就是由0到多个字母数字符号共同组成的一个串，这个串要用英文的双引号括起来。
引用类型，都可以用null作为值，也就是说可以在初始化的时候赋值为null
String是引用类型，也就是说可以使用null作为值
int i0 =1；
int i1=1;
以上这种情况会在内存中存储两个1的值
String s0=“hello”;
String s1=“hello”;
以上这种情况在内存中只存在一个“hello”。
假设“hello”的内存地址为xxxxx，声明s0变量时给s0赋值“hello”实际上让s0变量引用“hello”的内存地址xxxxx；
当我们再声明s1也赋值“hello”的时候实际上也是直接把已经存在的“hello”的内存地址给s1引用。
数据类型补充
基本数据类型转换
- 自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：
byte b=1；
int m=b；
System.ou.println(m);//输出的值为1
int i=0;
byte b=i;//这种异常叫做编译期异常，只有在执行javac的时候被发现
出错
- 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
int i=1;
short s=2;
byte b=3;
int a =i +s +b;
//在计算过程中，整数类型int的范围最大，所以在计算的过程中，s和b 都分别先转换为int类型，然后进行加的计算，最终的结果为int类型的数据
char c='a';//char类型的数据在与数字进行数学运算的时候它是转换为相应的ASCII码的值然后再进行的计算
byte b0=2;
int k=c+b0;
System.out.println(k);//输出结果为99
ASCII码：上个世纪60奶年代，美国制定了一套字符编码，对英文字符与二进制位之间的关系，做了统一规定，这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE"是32（二进制00100000），大写的字母A是65（二进制01000001）
- byte，short，char之间不会相互转换，他们三者在计算时首先转换为int类型
- 当把任何基本类型的值和字符串值进行连接运算时（+），基本类型的值将自动转化为字符串类型。
String str="abc";
int i=1;
System.out.println(str+i);//输出abc1
String str0=”1“+1+2+3；
System.out.println(str0);//输出1123
String str1=”“+1+2+3；
System.out.println(str1);//输出123
System.out.println(3+4+"hello");//输出7hello
System.out.println("hello"+3+4);//输出hello34
System.out.println('a'+1+"hello");//输出98hello
System.out.println("hello"+'a'+1);//输出helloa1
//注意当有一系列的+的运算的时候，如果某个部分其中含有字符串，那么这个字符串前边挨着的+开始要按照字符串拼接去算，一直往后都按照字符串拼接。
String str =1+3+”a"+2+3+6//4a236
强制类型转换
- 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符（（）），但可能会造成精度降低或溢出，格外要注意。
- 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换为基本类型。
- 如：String a=“43”;int i=integer.parseInt(a);
- boolean类型不可以转换为其他的数据类型
byte b=9;
int i=b;//正常隐式转换的数据类型，自动的
int k=7;
byte b0=(byte)k;//强制转换数据类,转换的数据类型要用英文的（）
数字类型的运算规则：
- 有多种类型的数据混合计算时，系统首先自动将所有数据转换为容量最大的那种数据类型，然后再进行计算，数字类型的从小到大分别是byte，short，int，long，float，double。
- 数字类型的运算中，多个相同类型变量参与的运算，变量要先转换为相应的数据类型的默认类型（比如说两个byte类型的变量相加，会先把两个byte类型的变量转换为默认的int类型之后在计算，得到的结果是int类型），这种情况适用于变量的数据类型的容量比默认类型的容量小，（比如byte，short，都比int小）
- byte，short，char之间不会相互转换，他们三者在计算时首先转换为int类型。
练习判断
short s=5；
s=s-2; //错，在进行运算的时候，s-2得到的值已经位int类型
byte b=3;
b=b+4; //错
b=(byte)(b+4);//对
char c=‘a’;
int i=5;
double d=3.14;
double result=c+i+d; //对
byte b=5;
short s=3;
short t=s+b; //错
集成开发环境
集成开发环境里面包含了文本编译工具，自动编译，简化运行，随时进行代码的调式。
| eclipse | IDEA | NetBeans |
|---|
运算符
运算符是一种特殊的符号，用以表示数据的运算，赋值和比较等。
算数运算符
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +3 | 3 |
| - | 负号 | b=4;-b | -4 |
| + | 加 | 5+5 | 10 |
| - | 减 | 6-4 | 2 |
| * | 乘 | 3*4 | 12 |
| / | 除 | 5/5 | 1 |
| % | 取模 | 7%5 | 2 |
| ++ | 自增（前），先运算后取值 | a = 2 ; b = + + a ; | a=3;b=3 |
| ++ | 自增（后）先取值后运算 | a=2;b=a++; | a=3;b=2 |
| – | 自减（前），先运算后取值 | a=2;b=- -a | a=1;b=1 |
| – | 自减（后），先取值后运算 | a=2;b=a- -; | a=1;b=2 |
| + | 字符串连接 | “he"+“llo” | "hello |
System.out.println(7/2);//输出3，整数除整数，会把小数部分舍弃，只保留整数
System.out.println(7.0/2);//shuchu 3.5
int i=0;
i++;
System.out.println(i);//1
++i;
System.out.println(i);//2
int k=i++;
System.out.println(k);//2
int m=++i;
System.out.println(m);//4
算数运算符的注意问题
- 如果对负数取模，可以把模数负号忽略不计，如：5% -2=1.但是被取模数是负数则不可互虐。此外，取模运算的结果不一定总是整数。
System.out.println(5 % -2 );//1
System.our .println(-5%2);//-1
- 对于除号“/”，它的整数和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
eg:
int x=3510;
x=x/1000*1000;//3000
- “+”除字符串相加功能外，还能把非字符串转换为字符串。例如：
System.out.println("5+5="+5+5);// 5+5=55
- 以下二者的区别：
System.out.println('*'+'\t\+'*');//93
//char类型数据是可以做数学运算的，再做数学运算时把字符转换为ASCII码进行计算,char类型在做数学运算的时候会转化为int类型
System.out.println("*"+'\t'+'*');//* *
//字符串与其他数据类型相加时，实际上把其他的数据转换为字符串，做字符串的拼接
练习：
public class TestSign{
public static void main(String[] args){
int i1=10,i2=20;
int i=i1++;
System.out.println("i="+i);//10
System.out.println("i1=+i1);//11
i=++i1;
System.out.println("i="+i);//12
System.out.println("i1="+i1);//i1=12
i=i2--;
System.out.println(“i=”+i)//20
System.out.println("i2="+i2);//19
i=--i2;
System.out.println("i="+i);//18
System.out.println("i2="+i2);//18
}
}
赋值运算符
- 符号：=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理
int i=1;
short s=2;
i=s;//自动类型转换
s=(short)i；//强制类型转换
- 支持连续赋值
int i0=0;
int i1=0;
int i2=0;
i0=i1=i2=0;
- 扩展赋值运算：+=，-=，/=，%=
int i=1;
i=i+2;//i=3;
i+=2;//3
i-=2;//1
String str="he";
str+="llo";
System.out.println(str);//hello，字符串的+=是字符串的拼接
思考
short s=3;
s=s+2;
//错误，变量参与运算时候
//java程序不知道具体这个变量在做完运算后会不会超出当前变量的范围，所以会先把变量转化为有个更大的长度
//这个例字中，short为短整型数据，short会转化为默认的int类型
s=(short)(s+2);//这样改后可以
s+=2; 在使用扩展赋值运算符的时候，变量在参与运算时会把结果**强制**转换为当前变量的类型。
int i=1;
i*=0.1;
System.out.println(i);// 0
i++;
System.our.println(i);//1
比较运算符
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4==3 | false |
| != | 不等于 | 4!=3 | true |
| < | 小于 | 4<3 | false |
| > | 大于 | 4>3 | true |
| <= | 小于等于 | 4<=3 | false |
| >= | 大于等于 | 4>=3 | true |
- 比较运算符的结果都是boolean型，也就是说要么是ture，要么是false
- *比较运算符“==”不能误写为“=”
逻辑运算符
并且，或者，异或，非
&-------逻辑与
|--------逻辑或
!--------逻辑非
&&----短路与
||-------短路或
^-------逻辑异或
| a | b | a&b | a或b | !a | a^b | a&&b | a短路或b |
|---|---|---|---|---|---|---|---|
| true | true | true | true | false | false | true | true |
| true | false | false | true | false | true | false | true |
| false | true | false | true | true | true | false | true |
| false | false | false | false | true | false | false | false |
- 逻辑运算符用于连接布尔型表达式，在java中不可以写成3<x<6,应该写成 x>3&&x<6
- "&"和“&&”的区别：
- “&”，左边无论真假，右边都进行运算；
- “&&”，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算
- “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算
- 异或（^)与或( | )的不同之处是：当左右都为true时，结果为false，理解：异或追求的是“异”。
int x=1;
int y=1;
if(x++==2&++y=2){ //x 先取值后计算
x=7;
}
System.out.println("x="+x,"y="+y);// 2,2
int x=1;
int y=1;
if(x++==2&&++y=2){
x=7;
}
System.out.println("x="+x,"y="+y);// 2,1
int x=1;
int y=1;
if(x++==2|++y=2){
x=7;
}
System.out.println("x="+x,"y="+y);// 7,2
int x=1;
int y=1;
if(x++==2||++y=2){
x=7;
}
System.out.println("x="+x,"y="+y);// 7 1
位运算符
| 运算符 | 运算 | 范例 |
|---|---|---|
| << | 左移 | 3<<2=12–>322=12,m<< n–>m* 2n |
| >> | 右移 | 3>>1=1–>3/2=1,m>>n–>m* 2 -n |
| >>> | 无符号右移（正数的与右移一致） | 3>>>1=1–>3/2=1 |
| & | 与运算 | 6&3=2 |
| 或 | 或运算 | 6或3=7 |
| ^ | 异或运算 | 6^3=5 |
| ~ | 反码 | ~6=-7 |
（无<<<)
有符号的右移是看右移之后的首位是0还是1，是0前面空位补0，是1就补1.
无符号的右移，移动之后不管首位是0还是1，空位都是直接补0.
- 位运算是直接对二进制进行运算
<<
空位补0，被移除的高位丢弃，空缺位补0
负数右移(左边空缺的地方全补1）和无符号右移
System.our.println(8>>2);//2
System.our.println(8>>>2);//2
System.our.println(-8>>2);//-2
System.our.println(-8>>>2);//1073741522
&和|
&运算，同位相&运算时，都是1，结果为1，其他情况都是0
|运算，同位相 | 运算时，只要一个为1，结果为1，其他为0
^和~
^运算时，同位 ^ 运算时，相同为0，不同为1。
~运算，就是把二进制的同位反转。
进制的意思是逢几进一
十进制：逢十进一
1+9=10二进制：逢二进一
0+1=1
1+1=10
10+1=11
11+1=110
-
转成二进制主要有以下几种
- 正数转二进制。除二取余，然后倒序排列，高位补零。（即除二取余法）
- 也就是说，将正的十进制数除以2，得到的商再除以2，以此类推直到商为0或1时为之，然后在旁边标出各步的余数，最后倒着写出来，高位补零就可以了。
-计算机内部表示数的字节单位时定长的，如8位，16位，或32位，所以，位数不够时，高位补零，所以，42转化为二进制以后，就是00101010，也即规范的写法为（42）10=（00101010）2
- 也就是说，将正的十进制数除以2，得到的商再除以2，以此类推直到商为0或1时为之，然后在旁边标出各步的余数，最后倒着写出来，高位补零就可以了。
- 负数转为二进制。
- 先是对应的正整数转换成二进制后，对二进制取反，然后对结果再加一。还以42为例，负整数也就是-42，如下解释后，最后即为（-42）10=（11010110）2.
42转换成二进制后为：00101010 -42转换成二进制时：00101010 先取反 11010101 然后再加一获得： 1010110- 小数转为二进制的方法：对小数点后的数乘以2，有一个结果，取结果的整数部分，然后再用小数部分再乘以2，再取结果的整数部分…以此类推，直到小数部分为0或者位数已经够了就欧克了，然后再把取的整数部分按先后次序排列就欧克了，就构成了二进制小数部分的序列。如下列，0.125.
0.125*2=0.125----------0 0.25*2=0.5----------------0 0.5*2=1.0-----------------1 此时，小数部分为0了，就可以停止乘以2，然后正序排列就构成了二进制的小数部分：0.001- 如果小数的整数部分有大于0的整数时该如何转化,方法为：整数转换为二进制，小数转换成二进制，然后加在一起就可以了。如下
6.125： 6--->110 0.125--->0.001 相加 （110.001）2 - 正数转二进制。除二取余，然后倒序排列，高位补零。（即除二取余法）
-
整数二进制转换为十进制：首先先将二进制数补齐位数，首位如果是0就代表正整数，如果首位是1则代表负整数
- 先看首位是0的正整数，补齐位数之后，将二进制中的位数分别与2(n-1)相乘，然后相加得到的就为十进制
- 若二进制不足位数之后首位为1时，就需要先取反在换算：例如，11101011，首位为1，就先取反：-00010100，然后算出10100对应的十进制为20，所以对应的十进制为-20.
-
将有小数的二进制转换为十进制时：例如0.1101转换为十进制的方法：将二进制中的四位数与对应的值相乘如下：
0 1 1 0 1 20 2-1 2-2 2-3 2^-4
正负数转化
以15为例（负数以-15为例）
15的二进制：00000000 00000000 00000000 00001111
-15的二进制：11111111 11111111 11111111 11110001
（按位取反，末位加一）
计算过程：补码（负数的二进制）=反码+1
反码：11111111 11111111 11111111 11110000
补码（即加一）：11111111 11111111 11111111 11110001 （也就是-15的二进制）
正数二进制——反码——加一（补码）——负数二进制
负数二进制——减1 ——反码——原码——正数二进制
三元运算符（三目运算符）
- 格式：
- （条件表达式）？ 表达式1：表达式2；
为true，运算结果为表达式1；
为false，运算结果为表达式2；
- （条件表达式）？ 表达式1：表达式2；
int i=1;
int k = i > 0 ? 1 : 0; //k=1
int k=-1;
int k= i > 0 ? 1 : 0; //k=0
获取两个数中较大的数：
int m=1;
int n=2;
System.our.println(m>n ? m :n); //2
获取三个数中较大的数
int k=0;
int m=1;
int n=2;
//(条件表达式）？表达式1 ：表达式2
System.our.println(m>n ? (m > k ? m : k) :(n>k ? n : k )); //2
//条件表达式 m>n
//表达式1：m>k? m: k
//表达式2：n>k? n:k
运算符的优先级
- 运算符有不同的优先级，所谓的优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
- 只有单目运算符，三元运算符，赋值运算符是从右往左运算的，即具有右结合性。
1905
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
