程序员_Java初级 关键字、标识符、运算符、进制
<一、Java关键字的解释>
关键字：即被java语言赋予特殊含义的单词，关键字中所有字母都是小写
(1). 数据类型
8种基本数据类型：整数类型：byte，short，int，long 浮点类型：float、double
字符类型：char 布尔类型：boolean
基本数据类型讲解：
<1>基本类型的大小：1字节=8位
整数类型：byte：占1字节，short：2字节，int：4字节，long：8字节
浮点类型：float：4字节、double：8字节
字符类型：char：2字节 布尔类型：boolean ：1个字节
<2>定义、转换及运算：定义：
long l=4l:通常带有l
float f=2.3 错，浮点型默认类型为double型，2.3默认为double型
基本数据类型的初始化：
整型默认初始化为： 0 字符型默认初始化为：null
浮点型默认初始化为： 0.0(f) 布尔型默认初始化为：false
自动转换具体规则：
（1）布尔型和其它基本数据类型之间不能相互转换；
（2）byte型可以转换为short、int、、long、float和double；
（3）short可转换为int、long、float和double；
（4）char可转换为int、long、float和double；
（5）int可转换为long、float和double；
（6）long可转换为float和double；
（7）float可转换为double；
也就是说，只能有取值窄的范围向宽范围转换，反之则不行。（可用小碗水可倒进大碗水形象记忆）
如：
Byte b=3；
b=b+2； //错，需要b=（byte）b+2
Int x=4270
x=x/1000*1000;//结果为4200；
引用数据类型：class、interface、数组
(2)数据类型值： true:成立 false:不成立 null:空
(3)流程控制： if:如果 else:或者 switch:选择 case:选项 default::默认 while:当..时
do:做 for:为 break:停止 continue:继续 return:返回
(4)访问权限修饰符：private:私有的 protected:受保护的 public:公有的
(5) 定义类、函数、变量修饰符：abstract:抽象的 final:不变的 static:静态的 synchronized:线程同步
(6)定义类与类之间关系的关键字：extends:继承 implements:实现
(7)定义建立实例及引用实例，判断实例：new:新建 this:本类 super:父类 instanceof:实例运算
(8) 异常处理： try:尝试 catch:处理 finally:一定执行 throw:方法体内抛出 throws方法体上抛出
(9)包关键字：package:包 import:导入
(10)其它：native:本地方法 strictfp:严格 transient:短暂 volatile:不稳定 assert:断言
重难点关键字讲解：
1 static关键字
static表静态的，可以是静态的方法或者静态的属性，表示所有的类共享，在类中可以直接调用其他类可以用类名直接调用，除了内部类一般不可以定义静态的类
2 abstract关键字
表示抽象的，可以用来申明抽象类和抽象方法，用在类的声明中来指明一个类是不能被实例化的，但是可以被其他类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现。它的用途是向子类提供通用的信息。抽象类可以包含正常的类包含的任何东西，也就是说，类和实例变量，以及带有任何修饰词的方法。只有抽象类可能有抽象方法。如果一个不是抽象的类包含一个抽象方法，那么将会出现编译错误，采用 abstract方法的类本来就是抽象类，并且必须声明为 abstract，abstract 类不能实例化。仅当 abstract 类的子类实现其超类的所有 abstract 方法时，才能实例化abstract 类的子类。这种类称为具体类，以区别于 abstract 类。
3 final关键字
Final表示完结的意思，对基本类型中前面加上final和static表示修饰的变量为常量，不能修改，final一般和static搭配使用，final方法:一是把方法锁定，以防止继承类修改它的含义，二是确保继承中使方法行为保持不变，并且不会被覆盖。类中所有的private方法都隐式地指定为是final，用final来修饰类时表示当前类不能被继承
4 implements关键字
implements 关键字在是实现一个接口的，以指示所声明的类提供了在 implements 关键字后面的名称所指定的接口中所声明的所有方法的实现。一个类可以实现多个接口，
示例：public class A implements B{ }
实现接口时必须重写接口里的所有方法
5 private关键字
private 关键字是访问控制修饰符，可以应用于类、方法或字段（在类中声明的变量）, 只能在声明 private（内部）类、方法或字段的类中引用这些类、方法或字段。在类的外部或者对于子类而言，它们是不可见的。所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。
6 protected 关键字
protected 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符, 可以在声明 protected类、方法或字段的类、同一个包中的其他任何类以及任何子类（无论子类是在哪个包中声明的）中引用这些类、方法或字段。所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。
7 public 关键字
public 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符，可能只会在其他任何类或包中引用 public 类、方法或字段。
所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。
8 super 关键字
super 关键字 是由子类访问父类的内容；super.父类属性，如果属性没有被覆写，则也可以不写super；super.父类方法(),如果方法没有被覆写，则可以不用 加super也表示调用父类中的方法；super是访问父类中的构造方法，必须放在首行。
9 this 关键字
this 关键字是直接访问本类中的内容；this.本类属性，调用本类中的属性；this.本类方法(),可以不写this,也表示调用本类的；this 是访问本类中的其他构造，必须放在首行。
10 throw 关键字
throw 关键字用于引发异常。throw 语句将 java.lang.Throwable 作为参数。Throwable 在调用栈中向上传播，直到被适当的 catch 块捕获。
11 throws关键字
throws 关键字可以应用于方法，以便指出方法引发了特定类型的异常。throws 关键字将逗号分隔的java.lang.Throwables 列表作为参数。引发非 RuntimeException 异常的任何方法还必须在方法声明中使用 throws修饰符来声明它引发的异常。
12continue 关键字
continue 关键字用来跳转到 for、while 或 do 循环的下一层循环。continue 总是跳到最深层 while、for 或 do 语句的下一层循环。
示例：for (i=0; i<10; i++)
{
if (a>1 )
{
continue;
}
b=23;
}
13 default关键字
default 关键字用来标记 switch 语句中的默认分支。default 块没有隐式结束点。break 语句通常在每个 case 或default 块的末尾使用，以便在完成块时退出 switch 语句。
示例
int i =2;
switch (i)
{
case 1:
b=0;
break;
case 2:
b=2;
break;
default:
b=3;
break;
}
break 关键字用于提前退出 for、while 或 do 循环，或者在 switch 语句中用来结束 case 块
14finally 关键字
finally 关键字用来定义始终在 try-catch-finally 语句中执行的块。
finally 块通常包含清理代码，用在部分执行 try 块后恢复正常运行
15 instanceof 关键字
instanceof 关键字用来判断对象是不是其他类的实例
示例
if (a instanceof A)
{
b=1；
}
16 native 关键字
native 关键字可以应用于方法，以指示该方法是用 Java 以外的语言实现的。
17.synchronized 关键字
synchronized 关键字可以应用于方法或语句块，并为一次只应由一个线程执行的关键代码段提供保护。
18.transient Java 关键字
transient 关键字可以应用于类的成员变量，以便指出该成员变量不应在包含它的类实例已序列化时被序列化。
19.volatile Java 关键字
volatile 关键字用于表示可以被多个线程异步修改的成员变量。
<二、标识符>
二、标识符：
1、定义：程序中自定义的一些名称。如类名
2、命名规则：
a.由26个英文字符大小写，数字0-9，符号中的_和$，组成。
b.数字不可以开头，不可以使用关键字
c.严格区分大小写，起名为了提高阅读性，尽量使用有意义的名字
3、名称规范：
a.包名：多单词组成是全部为小写字母。如：packageperson
b.类名和接口名：首个单词大写，多个单词组成时，后面的每个单词首字母大写。如：StringDemo
c.变量名和函数名： 首个单词小写，多个单词组成时，后面的每个单词首字母大写。如：functionTest
d.常量名：所有字母都大写。多个单词组成时，用下划线（“_”）连接。如MAX_VALUE
<三、运算符>
1.转义字符，通过\来转变后面字母或者字符的含义。
\n：换行
\b：退格，相当于backspace键。
\r：按下回车键。windows中，回车符是\r\n.
\t：制表符，相当于tab键。
\":双引号
\\:斜线
\':单引号
注：windows中，回车符由两个字符表示：\r\n.
例如：
System.out.println(“\\“hello\”\”)-------- “hello”
System.out.println(“\\hello\\”)----------\hello\
System.out.println(‘\\’)-------\
2.赋值运算符：
(1)符号：= += -= *= /= %=
注意：模除%：取模时若出现负数，则只看左边；
如 -1/6=-1,-1/-6=-1,
(2)s=s+2和s+=2的区别
short s=0；
s=s+2 ;//编译失败，为两次运算，因为s会被提升为int类型，运算后结果还是int型。无法赋值给左边的short 类型。
s+=2;//编译通过，为一次运算，因为+=运算符在给s赋值时，自运完成了强制转换操作。
3.比较运算符：
符号：==,!=,<,>,<=,>=,instanceof
== 相等于 4==3 -> false
!= 不等于 4!=3 -> true
< 小于 4<3 -> false
> 大于 4>3 -> true
<= 小于等于4<=3 -> false
>= 大于等于4>=3 -> true
instanceof 检查是否是类的对象 “Hello” instanceof String -> ture
注意：比较运算符结果都是boolean型。
4.逻辑运算符：
& 与 false&true -> false 无论左边是true是false，右边都运算
| 或 false|true -> true 两边都参与运算
^ 异或 false^true -> true 当两边都是true时，结果为false
! 非 !true -> false
&& 与短路 false&&true -> false 当左边为false时，右边不运算。
|| 非短路 false||true -> true当两边都为true，右边不运算。
注：逻辑运算符用于连接boolean类型的表达式。
5.位运算符：
带符号位移>>：右移时最高位补什么，看原数最高位补0或1
<< 左移 3 << 2 = 12 --> 3*2*2=12//就是乘以2的移动的位数次幂
>> 右移 3 >> 1 = 1 -->3/(2的1次幂)=1//就是除以2的移动的位数次幂
无符号右移 >>>： 3>>>1 = 1 -->3/2=1//无论最高位是什么，右移后，都用0补空位
& 与运算 6 & 3 = 2 就是2进制的真假运算。
| 或运算 6 | 3 = 7
^ 异或 6 ^ 3 = 5
~ 反码 ~6 = -7
注：1^4^4=1;
一个数异或同一个数两次，结果还是那个数，
此方法可用来加密和解密数据。
位运算练习：
（1）最有效的方式算出2乘以8等于几：
答：可以用位运算，2*2^3=2<<3=16;
（2）对于两个整数变量的值进行互换
答：方法一：通过第三方变量
Int n=3，m=8；
int temp；
temp=n；n=m；m=temp；
方法二：不通过第三方变量；
./*
演示：
11=3+8;
3=11-8;
8=11-3;
*/
即：n=n+m;
m =n-m；
n=n-m；
注意：有局限性，如果n与m的值非常大，容易超出int型范围。
方法3：思想：一个数异或同一个数两次，还是那个数；
n=n^m;
m=n^m;//(n^m)^m;
n= n^m;//(n^m)^n;
注意：此方式为技巧性，不会出现损失精度情况，在开发中通常用方法一。
6.三元运算符：
(1)格式：(条件表达式 )? 表达式1 :表达式2
若条件为true,运算结果为表达式1；
若条件为false,结果为表达式2;
(2)示例：
int x=1,y;
y=(x>1)?100:200;
08.注释
1.注释的三种方式
(1)//用于单行注释
(2)/*
用于多行注释
*/
(3)文档注释
/**
* java特有的注释方式，用于多行注释，可被javadoc工具解析
*/
1、进制概要：
二进制： 0和1，逢2进1.如110（表示六）
八进制： 0 - 7，逢8进1；以0开头表示。如015（表示十三）
十进制： 0 - 9，逢10进1。如12（表示十二）
十六进制：0 - 9、A - F，逢16进1；以0x开头表示。如0x3c（表示60）
2、进制特点：
a.二进制：始于电信号。任何计算机底层都是用二进制表示的。
b.八进制：将二进制的三位表示一位，即为八进制，最大值为7（2^3-1）。
c.十六进制：将二进制的四位表示一位，即为十六进制，最大值为15（2^4-1）。
d.进制数越大，位数越短。
3、进制间转化：
1）十进制转二进制：取2的余数运算
例：求6的二进制：6/2商3---余0，3/2商1---余1,1/2---余1；最终余1或除尽余0，则将每次除得的余数倒叙排列为110，即十进制的6转为二进制是110.
2）二进制转十进制：取2的幂运算
例：求110的十进制：0*2^0 +1*2^1 +1*2^2 = 6，其中012...代表各位数。
3）二进制转八进制：从右向左取二进制三位为一位，不足补0，算出每三位的十进制值（不会超过7）
例：求10011011的八进制：八位补一位为010,011,011；计算010 = 2, 011 = 3, 011 =3；则八进制为233
4）二进制转十六进制：从右向左取二进制四位为一位，不足补0，算出每四位的十进制值（不会超过15，过了9，记为A/B/C/D/E/F）
例：求10011011的十六进制：补位为0000,0000,1001,1011，计算0000 = 0, 0000 = 0,1001 = 9, 1011 = B(11)，则十六进制为9B
4）八进制、十六进制转二进制：先转为十进制，再转为二进制。
5）二进制的负数形式：取反后再+1
实例：1.求-6的二进制：
0000-0000 0000-0000 0000-0000 0000-0110
^ 1111-1111 1111-1111 1111-1111 1111-1111//取反
--------------------------------------------------------------------
1111-1111 1111-1111 1111-1111 1111-1001
+ 0000-0000 0000-0000 0000-0000 0000-0001//+1
--------------------------------------------------------------------
1111-1111 1111-1111 1111-1111 1111-1010
则-6的二进制为：1111-1111 1111-1111 1111-1111 1111-1010。
说明：二进制的负数形式的最高位皆为1.
int num=60；
//获取数60的最低四位,即将60的二进制&1111，即n&15；
int n1=num&15；
System.out.println(n1>9?(char)(n1-10+’A’):n1);//三元运算符
//要获取下一组四位，将60右移4位
int temp=60>>>4；//因为要把有效位移光
//对temp的值进行最低四位的获取
Int n2=temp&15；
System.out.println(n2>9? (char)(n2-10+’A’):n2);