Java学习日记（一）关键字、标识符、注释、常量与变量、运算符、转义字符

一、关键字：

关键字的定义和特点：

定义：被Java语言赋予了特殊含义的单词

特点：关键字中所有字母都为小写

        ①用于定义数据类型的关键字：

              引用数据类型：class interface

              整数类型：byte short int long

              浮点型：float double

              字符型：char

              布尔型：boolean

              void用于定义函数，表示返回类型

       ②用于定义数据类型值的关键字：

              true flase null

       ③用于定义流程控制的关键字：

              判断：if else switch case default

              循环：while do for

              继续循环：continue

              结束循环或者选择结构：break

              返回：return

       ④用于定义访问权限修饰符的关键字：

              privateprotected public

       ⑤用于定义类，函数，变量修饰符的关键字：

              abstract finalstatic synchronized enum

       ⑥用于定义类与类之间关系的关键字：

              extends implements

       ⑦用于定义建立实例及引用实例，判断实例的关键字：

              new this superinstanceof（判断对象类型）

       ⑧用于异常类处理的关键字：

              trycatch finally throw throws

       ⑨用于包的关键字：

              package import

       ⑩其他修饰符关键字

              native strictfptransient volatile assert

附注：main不是关键字，却是被虚拟机所识别的一个名称。

 

二、标识符：

       在程序中自定义的一些名称

       由26个英文字母大小写（a-z、A-Z）、数字（0-9）、符号（_、$）组成

定义合法标识符规则：

       1.      数字不可以开头；

       2.      不可以使用关键字。

附注：Java中严格区分大小写。在起名字的时候，为了提高阅读性，要尽量有意义。

 

Java中的名称规范：

       包名：多单词组成的所有字母都小写（例如：com.itheima包名之间用“.”连接）

       类名接口名：多个单词组成时，所有单词的首字母大写（例如：StudentInfo）

       变量名和函数名：多个单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写（例如：getStudentName）

       常量名：所有字母都大写。多个单词时每个单词用下划线连接（例如：Max_Num）

 

三、注释：

       用于注解说明解释程序的文字就是注释。

       目的：提高代码的阅读性。

格式：

       ①单行注释：（// 注释文字）

       ②多行注释（/* 注释文字 */）

       ③文档注释（/** 注释文字 */）

对于单行和多行注释，被注释的文字，不会被JVM解释执行。

对于文档注释，是Java特有的注释，其中注释内容可以被JDK提供的javadoc工具所解析，生成一套以网页文件形式体现的该程序的说明文档。

 

注释是一个程序员必须要具备的良好编程习惯。

初学者编写程序可以养成习惯：先写注释再写代码（将自己的思路通过注释先整理出来，再用代码去体现）

 

/**

这是我的第一个程序

@auther Wangpeng

*/

class FirstProgram{

       /*

       这是主函数，是程序的入口

       它的出现可以保证程序的独立运行

*/

public staticvoid main(String[] args){

       //这是输出语句，用于将括号内的数据打印到控制台

       System.out.println(“Hello World!”);

       }

}

 

四、常量与变量：

       常量：不能改变的数值

       Java中常量的分类：

           ①整数常量：所有整数

           ②小数常量：所有小数

           ③布尔型常量：较为特有，只有两个数值（true、false）

           ④字符常量：将一个数字字母或者符号用单引号（’’）标识

           ⑤字符串常量：将一个或多个字母用双引号（””）标识

           ⑥null常量：只有一个数值就是null

       对于整数：java有三种表现形式：

               ·十进制：0-9，满10进1；

               ·八进制：0-7，满8进1，用0开头表示；

               ·十六进制：0-9，A-F，满16进1，用0x开头表示。

       进制的基本转换：

       十进制转换为二进制：除2取余（从下往上写）

       示例如下:

              

       二进制转换成十进制：按权展开

              示例：将二进制1010转换成十进制数

              从第一位到末尾的顺序，每个的权值相加：1*2^3+0*2^2+1*2^1+0*2^1=8+2=10。

 

       十进制与八进制和十六进制的互转，跟转换二进制的方法一样。

       方法：可以先将十进制转换为二进制，再转换为八进制和十六进制。这就利用了一个八 进制位相当于三个二进制位，而一个十六进制位相当于四个二进制位。如：

              

附注：负数的二进制——只需要将对应的正数取反加1就OK了（负数的最高位是1）。

Java API文档中的Integer、Long等类中都提供了转成二进制、八进制、十六进制的静态方法toBinaryString(type i)、toOctalString(typei)、toHexString(type i)（其中type代表类的具体类型）

 

变量：内存中的一个存储空间（有自己的名称和类型）

           作用：用来不断的存放同一类型的数据，并可以重复使用

           定义格式：数据类型 变量名=初始化值；

           数据类型：①基本数据类型

                               ②引用数据类型

        如下图所示：

              

       ●类型的自动提升：

       在运算中，当低类型数据与高类型数据进行计算时，系统会自动将表达式中的低类型数据提升到高类型。

       示例：

                     byte b=4;

                     int c;

                     c=b+2;//b会自动提升为int类型进行运算

自动类型转换图如下所示：

       ●强制类型转换：

       当程序中，数据类型需要变换时，可以进行强制转换。

       示例：

                     byte b=4;

                     b=b+4;//就会报错

                     b=(byte)(b+4);//强制类型转换，强制将b+4的结果转换为byte类型，再赋值给b。

 

五、运算符

           1、算术运算符

               +：加法运算符

               示例：

                     int a=3;

                     int b=4;

                     int sum=a+b;//结果为7

                     附注：除此以外，+还具有连接字符串的作用

              -：减法运算符

               示例：

                     int a=99;

                     int b=43;

                     int res=a-b; //结果为56

                     附注：除此以外，-还具有求负运算的作用

              示例：

                     double x= -5.0;

                     x= -x;//将x求负，所以结果为：5.0

              *:乘法运算符

               示例：

                          double a=5.2;

                          double b=3.1;

                           double multiply=a*b;//结果为16.12

               /:除法运算符

               如果除法运算的两个操作数都是整数类型的话，那么结果也是整数；

               示例：

                     int a=19;

                     int b=4;

                     in tdiv=a/b;//结果为4

              如果除法运算中的两个操作数有一个或者两个都是浮点数的话，那么结果也将是浮点数；

               示例：

                     double a=6.2;

                     double b=3.1;

                     double div=a/b;//结果为2.0

              或者

                     double a=6.3;

                     int b=3;

                     double div=a/b;//结果为2.1

               %：取余运算符

               示例：

                     int a=5;

                     int b=3;

                     int div=a%b;//结果为2

                     附注：进行取模运算时，如果有负数，运算结果取决于运算左边有没有负数。

               ++：自增运算符

               自增运算符只能操作单个数值型（整型、浮点型）的变量，不能操作常量或者表达式。该运算符既可以放在操作数的左边，也可以放在操作数的右边，但是出现在左边和右边的结果是不一样的，如果把++放在左边，则先把操作数+1，然后再运算；如果++放在右边，则先运算，然后再+1。

               示例：

                          int a=5;

                          int b=a++ +6;//结果为11

               或者

                          int a=5;

                          int b=++a +6;//结果为12

               --：自减运算符

               与++基本类似

               示例：

                   int a=14;

                    int b= a- - +3;//结果为17；

               或者

                     int a=14;

                     int b= - -a +3;//结果为16

           2、赋值运算符

               符号：=  +=  -= *= /=  %=等等

               示例：

                   ▲int a,b,c;a=b=c=3;

                   ▲int a=3;a+=5;

                   ▲int d=9;d/=3;

           3、比较运算符

               ◆>：大于——只支持两边操作数是数值类型。如果前面变量的值大于后面变量的值，返回true

               ◆>=：大于等于——只支持两边操作数是数值类型。如果前面变量的值大于等于后面变量的值，返回true

               ◆<：小于——只支持两边操作数是数值类型。如果前面变量的值小于后面变量的值，返回true

               ◆<=：小于等于——只支持两边操作数是数值类型。如果前面变量的值小于等于后面变量的值，返回true

               ◆==：等于——如果进行比较的两个操作数都是数值类型，即使它们的数据类型不同，只有它的值相等，就会返回true。例如97==’a’返回true，5.0==5也返回true。如果两个操作时都是引用类型，那么只有当两个引用变量的类型具有父子关系时才可以比较，而且这两个引用必须指向同一个对象才会返回true。Java也支持两个boolean类型的值进行比较，例如，true==false将返回false。

               ◆!= ：不等于——如果进行比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要它们的值不相等，就返回false。如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用变量指向的不是同一个对象就会防护false。

    附注：比较运算符的结果都是boolean型，也就是要么是true，要么是false

           4、逻辑运算符

               ◆&&：简洁与，两个操作数都是true返回true，否则返回false。当第一个操作数是false直接返回false

               ◆&：与，两个操作数都是true返回true，否则返回false。

               ◆||：简洁或，只要有一个操作数是true返回true，否则返回false。当第一个操作数是true直接返回true

               ◆|：或，只要有一个操作数是true返回true，否则返回false。

               ◆!：非，只要有一个操作数，如果为true，则返回false；如果为false，则返回true。

               ◆^：异或，当两个操作数不同时才返回true，如果两个操作数相同则返回false。

           5、位运算符

               ◆<<：左移，空位补0，被移除的高位丢弃。

              ◆>>：右移，被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1。

              ◆>>>：无符号右移，被移位二进制最高位无论是0或者是1，空缺位都补0。

              ◆&：与，二进制位进行&运算，只有1&1时结果是1，否则是0。

              ◆|：或，二进制位进行 |运算，只有0 | 0时结果是0，否则是1。

              ◆^：异或，任何相同二进制位进行^运算，结果是0；1^1=0 , 0^0=0。不相同二进制位 ^运算结果是1。1^0=1 , 0^1=1。

              ◆~：反码，对二进制进行取反。

           6、三元运算符

       格式： (条件表达式)?表达式1：表达式2；

            a)如果条件为true，运算后的结果是表达式1；

            b)如果条件为false，运算后的结果是表达式2；

        示例：

                     int a=3;

                     int b=8;

                     int z=(a>b)?a:b;//结果为：8

 

六、转义字符

         通过“\”来转变后面字母或符号的含义

              常用的转义字符有：

              \b：退格 

              \n：换行

              \t：制表符，相当于tab键

              \r：回车

              \\：表示反斜杠

              \'：表示单引号

              \"：表示双引号

 

练习：

       1.最有效的方式算出2乘以8等于几？——2<<3

       2.对两个整数变量的值进行互换的方法？

public classSwapTwoNum {

 

       public static void main(String[] args) {

              swap_1(2, 3);

              swap_2(4, 6);

              swap_3(5, 8);

       }

 

       // 方式一：使用第三方变量

       public static void swap_1(int a, int b) {

              sopln("第一种交换方法：");

              sopln("第一种交换前：" + "a=" + a +",b=" + b);

              int temp;

              temp = a;

              a = b;

              b = temp;

              sopln("第一种交换后：" + "a=" + a +",b=" + b + '\n');

       }

 

       // 方式二：不使用第三方变量（一）（有局限性：当a和b的值非常大时，会超出指定类型的范围）

       public static void swap_2(int a, int b) {

              sopln("第二种交换方法：");

              sopln("第二种交换前：" + "a=" + a +",b=" + b);

              a = a + b;

              b = a - b;

              a = a - b;

              sopln("第二种交换后：" + "a=" + a +",b=" + b + '\n');

       }

 

       // 方式三：不实用第三方变量（二）

       public static void swap_3(int a, int b) {

              sopln("第三种交换方法：");

              sopln("第三种交换前：" + "a=" + a +",b=" + b);

              a = a ^ b;

              b = a ^ b;

              a = a ^ b;

              sopln("第三种交换后：" + "a=" + a +",b=" + b);

       }

 

       // 带换行的输出

       public static void sopln(Object obj) {

              System.out.println(obj);

       }

}

结果为：

       3.位运算将十进制数60转成十六进制数？

       思路：依次取出低四位即可。

public classJinzhiTrans {

 

       public static void main(String[] args) {

              int num = 60;

 

              // 获取60的最低4位，通过&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);

       }
}