首页 > 程序开发 > 软件开发 > Java >

Java语言基础(关键字、标识符、注释、常量、变量、运算符)

2017-11-07

Java语言基础组成:关键字、标识符、注释、常量和变量、运算符、语句、函数、数组。

Java语言基础组成:关键字、标识符、注释、常量和变量、运算符、语句、函数、数组。

一. 关键字

【注】关键字的所有的字母都是小写

?1.?用于定义数据类型的关键字

基本数据类型 数值型 整数:byte(字节)?short(短整型)?int (整型)?long(长整型)
浮点数: float(单精度浮点数)?double(双精度浮点数)
字符型 char(字符型)
布尔型 boolean(布尔型)
引用数据类型 chass(类)

interface(接口)
void(表示函数的返回值是无返回值类型)


?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(同步)?Enum(枚举)

?6.?用于定义类与类之间的关键字
?extends(继承类)?implements(实现接口)

?7.?用于定义建立实例及引用实例,判断实例的关键字
?new(实例化类)?this(本类对象)?super(父类对象)?instanceof(判断对象类型)

?8.?用于异常处理的关键字
?try(检查异常)?catch(抓住异常)?finally(发生异常后最终执行)?
?throw(程序中实例化异常抛出)?throws(标识方法抛出异常)

?9.?用于包的关键字
?package(创建包名) import(引入包名)

?10.?其他修饰符关键字

native(本地)

native关键字说明其修饰的方法是一个原生态方法,方法对应的实现不是在当前文件,而是在用其他语言(如C和C++)实现的文件中。

strictfp(strict float point (精确浮点))

使用strictfp关键字声明一个方法时,该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时,该类中的所有代码,包括嵌套类型中的初始设定值和代码,都将严格地进行计算。

transient(变量修饰符,用它声明一个实例变量,在对象序列化时不会被序列化)

当对象被序列化时(写入字节序列到目标文件)时,transient阻止实例中那些用此关键字声明的变量持久化;当对象被反序列化时(从源文件读取字节序列进行重构),这样的实例变量值不会被持久化和恢复。例如,当反序列化对象——数据流(例如,文件)可能不存在时,原因是你的对象中存在类型为java.io.InputStream的变量,序列化时这些变量引用的输入流无法被打开。

volatile(类型修饰符,用来修饰被不同线程访问和修改的变量)

Java 语言提供了一种稍弱的同步机制,即 volatile 变量.用来确保将变量的更新操作通知到其他线程,保证了新值能立即同步到主内存,以及每次使用前立即从主内存刷新. 当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的.

assert(断言,可以看作是异常处理的一种高级形式,用于捕捉我们在代码中做出的假设)

在Java中,assert关键字是从JAVA SE 1.4 引入的,为了避免和老版本的Java代码中使用了assert关键字导致错误,Java在执行的时候默认是不启动断言检查的(这个时候,所有的断言语句都将忽略!),如果要开启断言检查,则需要用开关-enableassertions或-ea来开启。

二. 标识符

标识符是在程序中自定义的一些名称,由大小写字母[a-zA-Z],数字[0-9],下划线[ _ ],特殊字符[$]组成。

1. 标识符的命名规则:

(1) 数字不可以开头
(2) 不可以使用关键字
(3) Java中严格区分大小写

?【注】“main”不是关键字,但被JVM(Java虚拟机)识别

2. 标识符的名称规范:

(1) 包名:多个单词组成时,所有字母小写
? e.g. xxxyyyzzz
(2) 类名和接口名:多个单词组成时,所有单词首字母大写
? e.g. XxxYyyZzz
(3) 变量名和函数名:多个单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写
? e.g. xxxYyyZzz
(4) 常量名:多个单词组成,所有字母大写,每个单词用下划线连接
? e.g. XXX_YYY_ZZZ

三. 注释

Java的注释有三种:单行注释,多行注释,文档注释(是程序的说明书,Java特有的,使用javadoc执行程序可以提取出来形成网页,给开发人员看的)。

//(单行注释)

/*
(多行注释)
*/

/**
(文档注释)
@author 作者
@version 版本号
*/

1. 注释的作用:

(1) 注解说明程序,但是注意不要每一行都加注释,不然会导致中英文结合地非常密,阅读性差
(2) 调试程序(很重要的应用)

2. 注释的问题:

(1) 单行注释中能够使用单行注释
(2) 多行注释中能够使用单行注释
(3) 多行注释中不能使用多行注释,文档注释
(4) 文档注释中不能使用文档注释,多行注释

3. 注释的分别用法:

(1) 类上面加的是文档注释
(2) 函数上面加的是文档注释
(3) 如果修饰符有改变的话,加多行注释
(4) 代码中的某几句话,加单行注释

四. 常量

常量不能被改变数值

1. 常量包括:

(1)整数常量
(2)小数常量
(3)布尔型常量:true,false
(4)字符常量:’4’,单个字母
(5)字符串常量:”abc”
(6)null常量,值为null

2. 整数常量:

(1)十进制[0-9],满10进1
(2)八进制[0-7],用0开头
(3)十六进制[0-9A-F],用0x开头
(4)二进制[0-1],8位1,0表示一个字节,字节是一个数据单位。
【注】ASCII码使用指定的7位或8位二进制数组合来表示128或256种可能的字符。
? e.g. 01000001表示A
? e.g. 01000002表示B

2.1 十进制->二进制:

原理:对十进制数进行除2运算

【实例】:6的二进制

6的二进制

System.out.println(Integer.toBinaryString(6)); //打印结果为110

2.2 二进制->十进制:

原理:对二进制数乘以2n运算(n是从0开始)

【实例 1】:110 =>0?20+1?21+1?22=6

【实例 2】:00110101的十进制(便捷式)

00110101的十进制(便捷式)

(【注】8个1 = 255; 7个1 = 127)

【实例 3】:5 + 4 = 9 内存中的算法:101 + 100 = 1001 =>9

2.3 二进制->十六进制:

原理:四个二进制位就是一个十六进制位(1111 => 15 =24?1

【实例】:十进制90的十六进制

十进制90的十六进制

2.4 二进制->八进制:

原理:三个二进制位就是一个八进制位(111 => 7 =23?1

【实例】:十进制90的八进制

十进制90的八进制

【注】其他进制转换:先把十进制转换为二进制,再对应地进行转换

2.5 负数的二进制变现形式:

6 =>110
-6:其实就是6的二进制取反+1(取反:将二进制的1变成0,0变成1)
【注】整数在内存中为4个字节,1个字节为8位

【实例 1】:十进制6的转换为-6的过程

十进制6的转换为-6的过程

结论:负数的最高位都是1,取反得来。

【实例 2】:(拓展)求111…111001=? 【解题思路】:先减1,再取反,再加负号

求111...111001=?

五. 变量

变量就是将不确定的数据进行存储,也就是需要在内存中开辟一个空间。(Java是强类型语言)


图片名称

【注】:Java在方法中定义的变量不会自动初始化,必须要我们给它初始化后才能使用它。在类中定义的变量会自动初始化。

1. 变量的初始化:

(1)Java在方法中定义的变量不会自动初始化,必须要我们给它初始化后才能使用它。
(2)在类中定义的变量会自动初始化。

2. 变量的作用域:

Java中变量的作用域——大括号划分

{
    int x = 9;
}
System.out.println(x); //不可以在大括号外调用X

3. 变量的嵌套定义:

(1)Java同一函数中变量不允许嵌套定义(和C语言中不同)

public static void main(String[] args)
{
    int x = 3;
    {
        int x = 9; //不允许嵌套定义
        System.out.println(x);
    }
    System.out.println(x);
}

(2)Java同一类中允许方法中的变量与成员变量同名

class Demo
{
    private int x;
    public int getX()
    {
        int x = ++this.x;
        return x; //此处调用的是方法中定义的x,而非类的成员变量
    }
}

六. 运算符

处理数据的原理就是运算。运算符包括:算术运算符,赋值运算符,比较运算符,逻辑运算符,位运算符,三元运算符。

1. 算术运算符:

+(正号) -(负号)
+(加) -(减) *(乘) /(除)【e.g.】5 / 5 = 1

%(取模)?规律:左边小于右边 = 左边?【e.g.】 2 %5 = 2;
?????????左边等于右边 = 0?【e.g. 】5 %5 = 0;
?????????右边等于1 = 0?【e.g. 】5 %1 = 0;

+(字符串相加)?字符串数据和任何数据使用【+】都是相连接,最终都会变成字符串
???????? 【e.g.】(“He” + “llo”) =>(“Hello”)
++(自增) 自增前(先自增,后赋值): a = 2; b = ++a; ?=>?a = 3 ; b = 3;
自增后(先赋值,后自增): a = 2; b = a++; ?=>?a = 3 ; b = 2;
【总结】:a++;?=>?a = a + 1;
?????a++和++a运算过后,a的值都增加1
- -(自减) 自减前(先自减,后赋值): a = 2; b = - -a; ?=>?a = 1 ; b = 1;
自减后(先赋值,后自减): a = 2; b = a- -; ?=>?a = 1 ; b = 2;


【实例】:”+” 字符串连接符的用法

System.out.println("5+5=" + 5 + 5); //5+5=55
System.out.println("5+5=" + (5+5)); //5+5=10
System.out.println("a=" + a + ", b=" + b); //a=4, b=5

2. 赋值运算符

=(赋值) +=(和赋值) -=(差赋值) *=(积赋值) /=(商赋值) %=(余数赋值)
【注】:以上的符号如”-=” 都是仅为一个运算符符号


【实例1】x += 4; => x = x + 4;
????左右两边的和赋值给左边

【实例2】两个赋值方法对比

short s = 4;
s = s + 4;
short s = 4;
s += 4;
先做加法,再做赋值,有自动类型提升的过程 这个只做了一次运算,只是运用了赋值运算符,把左右两边的和赋值给左边
【编译失败】,因为s会被提升为int类型,运算后的结果还是int类型,无法赋值给short类型 【编译成功】,因为”+=”赋值运算符在给s赋值时,自动完成了强转操作
总结:s = (short) (s + 4)这样才能将和赋值给s 总结:(1)s = 4; (2)s += 4; 这两个表达式都只用了赋值运算符,将int类型赋值给short型,会进行自动类型转换

3. 比较运算符:

比较运算符结果都是boolean型,true 或者 false。

==(相等) !=(不相等) <(小于) >(大于) <=(小于等于) >=(大于等于)
instanceof(检查是否是类的对象)


【实例】:

System.out.println("Hello" instanceof String); //true
System.out.println(3 > 4); //false

4. 逻辑运算符:

逻辑运算符代表关系,用于连接boolean类型的表达式。

& And (与) true&true= true
true&false = false
false &true= false
false &false = false
【结论】:

?两边只要有一个为false,结果就是false,
?两边只要都为true,结果为true。
【实例】:
int x = 4;
x > 3 & x<4 = false;
true & true = true;
| or (或) true|true= true
true| false = true
false |true= true
false |false = false
【结论】:

?两边只要有一个true,结果为true,
?两边只要都为false,结果为false。
^ xor (异或) true^true= false
true^false = true
false ^true= true
false ^false = false
【结论】:

?两边相同,结果为false,
?两边不同,结果为true。
Not (非) !true = false
&& And (短路) 【 & 与 && 的区别】:

?&:无论左边是true,还是false,右边都运算。

?&&:当左边为false时,右边不运算,因为结果肯定为false,
???? 左边为true,右边参与运算。
|| or (短路) 【 | 与 || 的区别】:

?|:无论左边是true,还是false,右边都运算。

?||:当左边为true时,右边不运算,因为结果肯定为true,
?? 左边为false,右边参与运算。

5. 位运算符:

位运算符是二进制运算的运算符,“位”是二进制的位,是最快的运算,但局限是基为2。

<< 左移 3<<2?? =>?3?22=12
>> 带符号右移 3>>1?? =>?3/21=1 高位空出来要补什么?
按原有数据的高位置是0补0,是1补1。
>>> 无符号右移 3>>>1?=>?3/21=1 右移空出来都拿0补
& 与运算 6 & 3 = 2
| 或运算 6?|?3 = 7
^ 异或运算 6 ^ 3 = 5
~ 反码 ~6 = -7


【实例】:左移,右移,无符号右移之间的区别

【 1.<<>>的区别】:
<<(左移) 其实就是乘以2的移动位数为次幂
>>(右移) 其实就是除以2的移动位数为次幂

【 2.>>时,正数和负数 的区别】:
>>(正数右移时) 高位补0
>>(负数右移时) 高位补1

【 3.>>>>>的区别】:
>>(带符号右移) 高位补0或1:具体看原有值高位,是0补0,是1补1
>>>(无符号右移) 高位都补0

5.1 <<(左移):

【实例 】: 3<<2?? =>?3?22=12

左移实例

【总结】:m<<n?? =>?m?2n?(向左边移动,右边用0补。)

5.2 >>(右移):

【实例 1】: 正数右移:3>>1?? =>?3/21=1

右移实例正数

【总结】:m>>n?? =>?m/2n?

【实例 2】: 负数右移:?3>>1?? =>??3/21=?2

(1)将3转换为二进制的-3(取反加1)
(2)将二进制的-3右移1位,高位用1补(负数高位为1)
(3)将二进制的-3转换为十进制(减1取反)

右移实例负数

【总结】:负数右移还是负数。

5.3 >>>(无符号右移):

【实例 1】: 正数无符号右移:3>>>1?? =>?3/21=1

无符号右移实例正数

【实例 2】: 负数无符号右移:-3>>>1?? =>??3/21=2147483646

无符号右移实例正数

【总结】:如果是负数右移的话,高位也补0,此时的数就转变为了正数

5.4 &(与运算):

【实例】: 6 & 3 = 2

&(与运算)

5.5 | (或运算):

【实例】: 6 | 5 = 7

5.6 ^(异或运算):

【实例 1】: 6 ^ 5 = 3

^(异或运算)

【实例 2】:异或运算还可以用于加密解密: 7 ^ 4 ^ 4 = 7;(“4”相当于密钥)

加密解密

【总结】:一个数异或同一个数两次,结果是本身。

5.7 ~(反码):

【实例】: ~6 = -7 ?步骤:(1)取反,(2)减1,(3)取反,(4)加负号

~(反码)

5.8 位运算练习:

【实例 1】:最有效的方式算出2乘以8等于几?

?解: 2 * 8 =2?23=> 2的二进制位向左移了3位;
??? 2的二进制为000..0000-0010
??? 左移了3位:000..0001-0000 => 16

【实例 2】:对两个整数变量的值进行交换(不需要第三方变量)

// (1)使用第三方变量
    int n = 3, m = 8;
    int temp;
    temp = n;
    n = m;
    m = temp;

// (2)不需要使用第三方变量,利用两数的和
    n = n + m;
    m = n - m;
    n = n - m;

// (3)不需要使用第三方变量,利用异或同一个数两次还是本身
    n = n ^ m;
    m = n ^ m; //m = (n ^ m) ^ m;
    n = n ^ m; //n = (n ^ m) ^ n;

【实例 3】: 60(十进制)转换为十六进制,用代码

60(十进制)转换为十六进制

public static void main(String[] args) 
    {
        int num = 60;

        //取出最低4位,方法:通过&15
        int n1 = num & 15;

        //输出最低4位的十六进制值
        System.out.println(n1 > 9 ? (char)(n1 - 10 + &#39;A&#39;) : n1); 
        //char是两个字节,int是四个字节,(n1 - 10 + &#39;A&#39;)会自动类型提升为int型,所以输出结果为67

        //获取下一组4位,右移4位
        int temp = num >>> 4;
        int n2 = temp & 15;
        System.out.println(n2 > 9 ? (char)(n2 - 10 + &#39;A&#39;) : n2);
    }

【实例 4】:(扩展) -60(十进制)转换为十六进制

-60(十进制)转换为十六进制

6. 三元运算符:

(条件表达式)? 表达式 1 : 表达式 2; =>一定有结果

(1)如果条件为true, 运算后的结果为表达式 1;
(2)如果条件为false,运算后的结果为表达式 2;

相关文章
最新文章
热点推荐