标识符和变量

标识符

什么是标识符

程序员在定义java程序时，自定义的一些名字，标识符可以应用在类名，方法名，变量名，包名上。

标识符遵循规则

1、字母，数字，下划线，美元符号组成，不能以数字开头。

2、大小写敏感。

3、不能与JAVA关键字冲突，关键字全是小写。

4、true和false/null不是java的关键字，但也不能做为标识符。

标识符的命名规范

1.包名

全部小写，比如：com.boxiaoyuan.www 

2.类名和接口

单词的首字母大写，其它字母小写，比如：HelloWorld

3.变量名和方法名

首单词全部小写，其他单词的首字母大写，其他小写，比如：userName

4.常量名

全部大写，单词和单词之间使用下划线分割，比如UP_DIRECTION

注意：只是为了增加规范性、可读性而做的一种约定，标识符在定义的时候最好见名知意，提高代码阅读性。

关键字

什么是关键字

在java中，有些标识符是有着特殊含义的，我们把这些具有特殊含义的标识符叫做关键字。

常见关键字

定义数据类型的关键字
class	interface	byte	short	int
long	float	double	char	boolean
void
定义流程控制的关键字
if	else	switch	case	default
while	do	for	break	continue
return
定义访问权限的关键字
private	protected	public
定义类，方法，变量的关键字
abstract	final	static	synchronized
定义类与类之间关系的关键字
extends	implements
定义实例及引用实例，判断实例的关键字
new	this	super	instanceof
异常处理的关键字
try	catch	finally	throw	throws
用于包的关键字
package	import

 

 注释

注释的作用

注释可以提高程序的可读性，使java程序的条例更加清晰，方便后期的维护。

注释的种类

1.//单行注释

2./**/多行注释

3.文档注释/***/

注释的细节

1． 单行注释可以嵌套使用，多行注释不能嵌套使用。

2． 一般单行注释都是写在代码的右边，多行注释写在代码的上方。

3． 文档注释也是多行注释。

4．多行注释中可以嵌套单行注释。

文档注释

1.一个类需要生成开发者文档，需要使用关键字public修饰该类。

2.文档注释一定要位于一个类的上方或者是一个方法的上方。

package com.boxiaoyuan.test;

/**
 * 需求：在控制台打印helloworld
 * @author boxiaoyuan
 * @version 1.0
 */
public class Demo0002 {
    /**
     * 该方法是程序的主入口，保证该类可以单独运行
     * @param args 运行该类时需要传递的参数
     */
    public static void main(String[] args) {
        System.out.println("hello world");
    }

}

E:\javatest\JavaTestProj\src\com\boxiaoyuan\test> javadoc -encoding UTF-8 -d D:/testaa -version  -author Demo0002.java

常量

常量概述

常量是指在程序运行过程中其值不能改变的量。

常量分类

    整数常量 ： 所有整数

    小数常量 ： 所有小数

    布尔常量 ： 只有true和false

    字符常量 ：使用’’引起来的单个字符

    字符串常量 ：使用“”引起来的字符序列，“”  、“a” 、” ” 

    null常量 ： 只有一个值null

 整数常量的表现形式

二进制：由0,1组成，以0b开头。

八进制：由0,1，...7组成，以0开头。

十进制：由0,1,...9组成，整数默认是十进制。

十六进制：由0,1,...9,a,b,c,d,e,f（大小写均可）组成，以0x开头。

字符常量

转义字符	名称
\b	退格键
\t	tab键
\n	换行
\r	回车
\\	反斜杠
\'	单引号
\\"	双引号

 

 说明：换行符就是另起一行，回车符就是回到一行的开头，我们平时编写文档的回车符应该叫回车换行符。

定义常量

常量一旦被初始化后，就不可以被更改，声明的格式为：

final 数据类型 变量名称 = 变量初始值;

final是定义常量的关键字。

public class Demo0003 {
    //静态常量，不需要创建对象就可以反问，在类外访问形式为Demo0003.PI。
    public static final double PI = 3.14;
    //声明成员常量
    final static int x = 11;
    
    public static void main(String[] args) {
        //声明局部常量
        final double y = 2.1;
    }
}

定义常量时需要注意：

• 定义常量时需要对常量进行初始化。
• final关键字不仅可以修饰基本的数据类型，还可以修饰对象的引用和方法。
• 为了与变量区别，常量名一般都用大写字符。

变量

变量的概述

用于存储可变数据的容器。

变量的声明

数据类型 标识符；
数据类型 标识符 = 变量值

变量的数据类型

1. 整型

byte   代表一个字节的大小   8bit  2(8)   -128~127        256

 short  代表两个字节的大小  16bit  2(16)  -2(15)~2(15)-1

int    代表四个字节的大小  32bit  2(32)  -2(31)~2(31)-1

long   代表八个字节的大小  64bit  2(64)  -2(63)~2(63)-1

如果一个数值没有采取特殊的处理，那么该整数默认的类型是int。

可以使用数值后面添加L或小写L改变默认的整数类型。

2. 浮点型

 float  代表四个字节的大小  32bit

 double 代表八个字节的大小  64bit

java程序中所有的小数默认的类型是double类型，所以需要使用特殊的符号改变默认的小数类型。

3. 字符型

  char   代表两个字节的大小  16bit  2(16)

  原理：将字符映射为码表中对应的十进制数据加以存储。

4. 布尔型

   boolean  占一个字节或者四个字节。只有true与false两个值。

如果boolean用于声明一个基本类型变量时是占四个字节，如果用于声明一个数组类型的时候，那么数组中每个元素占一个字节。

变量赋值

变量初始化是指为变量指定一个明确的初始值，初始化变量有两种方式：一种是声明时直接赋值，一种是先声明后赋值。

public class Demo0004 {
    char usersex = '男';    
    public static void main(String[] args) {
        String username ;
        username = "张三";
    }
}

注意事项：

• 变量是类中的字段，如果没有显式初始化，默认状态下创建便令并默认初始值。
• 方法中的变量必须显式初始化，否则使用时会报错。

数据类型转换

隐式转换

隐式转换的实现需要同时满足两个条件：两种数据类型彼此兼容；目标类型的取值范围大于源数据类型（低级数据类型转换成高级数据类型）。

转换规则：

数值型数据的转换：byte--->short--->int--->long--->float--->double。

字符型转换为整形：char--->int。

 显式转换

当两种类型彼此不兼容，或者目标类型取值范围小于源类型，无法进行自动隐式转换，需要进行强制类型转换。

public class Demo0004 {     
    public static void main(String[] args) {
        int a = 128;
        byte b = (byte)a;
        System.out.println(b);//-128
    }
}

强制类型转换会损失精度。

int

00000000

00000000

00000000

10000000

 

 

byte

10000000

 

 

补码的运算步骤：

• 先获取负数的绝对值，然后获取绝对值的二进制（原码）
• 原码取反（反码）
• 反码+1=补码

10000000（首位为1，表示负数，根据补码算原码）--->01111111（反码）--->10000000（原码）--->加上负号-128

 运算符

算术运算符

java中常用的算术运算符：

算术运算符	名称
+	加法
-	减法
*	乘法
/	除法
%	求余
++	自增1
--	自减1

示例：

public class Demo0004 {     
    public static void main(String[] args) {
        int a = 5;
        int b = ++a;
        System.out.println(b);//6,a先自增1，然后再赋值给b
        
        int c = 5;
        int d = c++;
        System.out.println(d);//5,c先赋值给d，然后再自增1
    }
}

public class Demo0005 {     
    public static void main(String[] args) {
        int age1 = 12;
        int age2 = 13;
        System.out.println(age1 + age2);//25，加法
        System.out.println(age2 - age1);//1，减法
        System.out.println(age1 * age2);//156，乘法
        System.out.println(age1 / age2);//0，除法
        System.out.println(age2 % age1);//1，求余    
    }
}

赋值运算符

java中常用的赋值运算符：

赋值运算符	名称
=	赋值
+=	加等于
-=	减等于
*=	乘等于
/=	除等于
%=	模等于

 示例：

public class Demo0006 {     
    public static void main(String[] args) {
        int one = 10;
        int two = 20;
        int three = 0;
        three +=one; //等同于three = three + one
        System.out.println(three);//10
        three -= one; //等同于three = three - one
        System.out.println(three);//0
        one *= two; //等同于one = one * two
        System.out.println(one);//200
        one /= two; //等同于two = two /one
        System.out.println(one);//10
        two %= one; //等同于two = two % one
        System.out.println(two); //0        
    }
}

比较运算符

java中常用的比较运算符：

比较运算符	名称
>	大于
<	小于
>=	大于等于
<=	小于等于
==	等于
!=	不等于

 

 > 、 < 、 >= 、 <= 只支持左右两边操作数是数值类型

== 、 != 两边的操作数既可以是数值类型，也可以是引用类型

示例：

public class Demo0007 {     
    public static void main(String[] args) {
        int a = 12;
        double b = 14.9;
        String s1 = "hello";
        String s2 = "hello";
        System.out.println("a等于b："+(a==b));//false
        System.out.println("a大于b："+(a>b));//false
        System.out.println("a小于b："+(a//true
        System.out.println("a大于等于b："+(a>=b));//false
        System.out.println("a小于等于b："+(a<=b));//true
        System.out.println("a不等于b："+(a!=b));//true
        System.out.println("s1等于s2："+s1.equals(s2));//true
    }
}

说明：

• ==用于基本数据类型数据比较时，判断的是两个数据是否相等，==用于引用数据类型比较的时候，那么比较的是两个变量所指向的对象是否为同一个（比较的是内存地址）。

• ==比较的是2个对象的地址，而equals比较的是2个对象的内容。

逻辑运算符

java中常用的逻辑运算符：

逻辑运算符	名称
&	逻辑与
|	逻辑或
!	逻辑非
&&	短路与
||	短路或
^	异或

说明：

• &，只要两边的boolean表达式结果有一个为false，则结果为false；两遍都为true，则结果为true。
• |，两遍只要有一个为true，则结果为true；当两边都为假时，则结果为假。
• ^，两边相同，结果为false；两边不同，结果为true。
• &&，先对左边进行判断, 如果位真，则判断右边；如果为假，则不再判断右边，它的效率比逻辑与要高一点。
• ||，先判断左边，为假，则再判断右边，如果右边为假，则为假，否则返回真.；如果左边为真，则为真，不再判断右边。

 位运算符

java中常用的位运算符为：

位运算符	名称
&	与
|	或
^	异或
~	取反

 说明：

• &，参见运算的两位数都为1，&运算符结果才为1，否则就为0。
• |，参与运算的两位都为0，运算的结果才为0，否则就为1。
• ^，只有参与运算的两位不同，运算的结果才为1，否则为0。
• ~，取反，规律，把对应的值加上负号，再减去1。

移位操作符

<<   空位补0，被移除的高位丢弃，空缺位补0。

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

>>>  被移位二进制最高位无论是0或者是1，空缺位都用0补。

三元运算符

格式：

(条件表达式)?表达式1:表达式2；

如果条件表达式为true，运算后的结果为表达式1，反之，则运算后的结果为表达式2。

示例：

public class Demo0008 {     
    public static void main(String[] args) {
        int x = 6;
        System.out.println(x % 2==0 ? "偶数" : "奇数"); //偶数
    }
}