程序员_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.

2.获取一个数60的十六进制：
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);