第2章 变量与运算符

于 2024-02-29 21:22:45 发布
阅读量1.6k 收藏 41
点赞数 50
分类专栏： Java编程语言基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46896961/article/details/136338022
版权

1、注释与API文档

1.1注释

注释是指源文件中用于解释、说明程序的文字,Java语言注释主要有三种，单行注释、多行注释和文档注释。

（1）单行注释

//这里是单行注释的内容

（2）多行注释

/*
这
里
是
多
行
注
释
的
内
容
*/

注：

  • 对于单行和多行注释，被注释的文字，不会不会出现在字节码文件中，进而不会被JVM（java虚拟机）解释执行。

  • 多行注释里面不允许有多行注释嵌套。

（3）文档注释（Java语言独有的）

  • 文档注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
  • 格式 
    /**
文档注释演示。这是我的第一个Java程序！^_^
@author Wang
@version 1.0
*/
    javadoc -d mydoc -author -version Hello.java

    1.2API文档

  • API （Application Programming Interface，应用程序编程接口）是 Java 提供的基本编程接口。

  • Java语言提供了大量的基础类，因此 Oracle 也为这些基础类提供了相应的说明文档，用于告诉开发者如何使用这些类，以及这些类里包含的方法。大多数Java书籍中的类的介绍都要参照它来完成，它是编程者经常查阅的资料。

  • Java API文档，即为JDK使用说明书、帮助文档。类似于小学生在学习汉字时使用的字典。

  • 注：此处提供常用API文档

     （i） 在线看：Overview (Java SE 17 & JDK 17)

     （ii） 离线下载：Java Development Kit 17 Documentation

2、关键字、保留字和标识符

2.1关键字

（1）定义：被Java语言赋予了特殊含义，用做专门用途的字符串（或单词）

  • 特点：全部关键字都是小写字母。

  • 关键字比较多，不需要死记硬背，学到哪里记到哪里即可。

（2）说明：

  • 关键字一共50个，其中const和goto是保留字(reserved word)。

  • true，false，null不在其中，它们看起来像关键字，其实是字面量，表示特殊的布尔值和空值。

2.2标识符

（1）定义：Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。

（2）标识符的命名规则（必须遵守的硬性规定） ：

  •  由26个英文字母大小写，0-9 ，_或 $ 组成  

       数字不可以开头。原因如下：

            int 123L = 12；
            long x = 123L;


      不易区分123L是变量还是常数。

  •  不可以使用关键字和保留字，但能包含关键字和保留字。
  •  Java中严格区分大小写，长度无限制。标识符不能包含空格。

（3）标识符的命名规范（建议遵守）:

  • 包名：多单词组成时所有字母都小写：xxxyyyzzz。例如：java.lang、com.atguigu.bean
  •  类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz。例如：HelloWorld，String，System等
  •  变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz、例如：age,name,bookName,main,binarySearch,getName
  •  常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ。 例如：MAX_VALUE,PI,DEFAULT_CAPACITY

3、变量

3.1定义

        变量是程序中不可或缺的组成单位，最基本的存储单元。

3.2说明

（1）变量位于内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化

（2）变量的构成包含三个要素：数据类型、变量名、存储的值

（3）Java中变量声明的格式：数据类型 变量名 = 变量值

（4）变量的作用：用于在内存中保存数据。

（5）注意：

  • Java中每个变量必须先声明，后使用。

  • 使用变量名来访问这块区域的数据。

  • 变量的作用域：其定义所在的一对{ }内。

  • 变量只有在其作用域内才有效。出了作用域，变量不可以再被调用。

  • 同一个作用域内，不能定义重名的变量。

3.3Java语言中的数据类型

3.4变量的使用

        Java语言中变量必须先声明后赋值。

（1）变量的声明

格式： 数据类型  变量名;

//byte类型变量
byte b;

//short类型变量

short s;

//int 类型变量

int i;

//String 类型变量

String s;

//注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。

（2）变量的赋值

        给变量赋值，就是把“值”存到该变量代表的内存空间中。同时，给变量赋的值类型必须与变量声明的类型一致或兼容。

        格式：变量名 = 值;

方法一：用常量值给已经声明的变量赋值

b = 2;

s = 12;

i = 123;

s = "dkfj";

方法二：使用其他变量或者表达式给变量赋值

//变量的声明与使用
int m = 1;
//将变量的值赋值给变量
int n = m;
        
int x = 1;
int y = 2;
//使用表达式给变量赋值
int z = 2 * x + y;

4、基本数据类型

4.1 整数类型：byte、short、int、long

（1）Java各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。

（2）定义long类型的变量，赋值时需要以"l"或"L"作为后缀。

（3）Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。

（4）Java中整型变量常使用int类型。

（5）四种整数类型各自占用的空间大小和表示范围如下图所示

注：字节（Byte）：是计算机用于计量存储容量的基本单位，一个字节等于8 bit。

位（bit）：是数据存储的最小单位。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。

转换关系：

  • 8 bit = 1 Byte

  • 1024 Byte = 1 KB

  • 1024 KB = 1 MB

  • 1024 MB = 1 GB

  • 1024 GB = 1 TB

4.2 浮点类型：float、double

（1）与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。

（2）浮点型常量有两种表示形式：

  • 十进制数形式。如：5.12 512.0f .512 (必须有小数点）
  • 科学计数法形式。如：5.12e2 512E2 100E-2

（3）float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。

        double：双精度，精度是float的两倍。通常采用此类型。

注：定义float类型的变量，赋值时需要以"f"或"F"作为后缀。

      Java 的浮点型常量默认为double型。

（4）float类型和double类型所占用的空间和表示范围如下

注：

  • 并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。

  • 浮点类型float、double的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。

4.3 字符类型：char

（1）char 型数据用来表示通常意义上“字符”（占2字节）

（2）Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

（3）字符型变量的三种表现形式：

  • 形式1：使用单引号(' ')括起来的单个字符。

    例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';

  • 形式2：直接使用 Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。

    例如：\u0023 表示 '#'。

  • 形式3：Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。

    例如：char c3 = '\n'; // '\n'表示换行符

    形式4：Java中还允许使用具体字符对应的数值（比如ASCII码）。

    例如：char c4 = 97; // 97在ASCII码中表示a

    char c5 ='1'; char c6 =1; // c5!=c6

（4）char类型是可以进行运算的。因为它都对应有Unicode码，可以看做是一个数值。

转义字符说明Unicode表示方式
\n换行符\u000a
\t制表符\u0009
\"双引号\u0022
\'单引号\u0027
\\反斜线\u005c
\b退格符\u0008
\r回车符\u000d

4.4 布尔类型：boolean

（1）boolean 类型用来判断逻辑条件，一般用于流程控制语句中：

  • if条件控制语句；

  • while循环控制语句；

  • for循环控制语句；

  • do-while循环控制语句；

（2）boolean类型数据只有两个值：true、false，无其它。

  • 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。

  • 拓展：Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。——《java虚拟机规范 8版》

注：建议不要这样写：if ( isFlag = = true )，很容易写错成if(isFlag = true)，这样就变成赋值isFlag为true而不是判断,推荐写法是if (isFlag)或者if ( !isFlag)。

5. 基本数据类型变量间运算规则（难点）

5.1自动类型提升

        具体规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时

int i = 'A';//char自动升级为int，实质把字符的AScII编码值赋值给i变量了
double d = 10;//int自动升级为double
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
​
//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double

（3）当byte,short,char数据类型的变量进行算术运算时，按照int类型处理。

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译不通过，b1 + b2自动升级为int

short s1 = 1;
short s2 = 2;
short s3 = s1 + s2;//编译不通过，s1 + s2自动升级为int

char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113 

int i1 = b1 + s1;
int i2 = b1 + c1;

规定：整型常量是int类型，浮点型常量规定为double类型。

5.2强制类型转换

        具体规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。

注：自动类型提升是Java自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行，并且强制类型转换可能会存在精度损失的情况。

        格式如下：

数据类型1 变量名 = (数据类型1)被强转数据值;  //()中的数据类型必须<=变量值的数据类型

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。

int i = (int)12.3;//损失精度 i = 12

double d = 1.2;
int num = (int)d;//损失精度 num = 1

int i = 200;
byte b = (byte)i;//溢出

 （2）当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。

int i = 1;
int j = 2;
double bigger = (double)(i/j);

（3）声明long类型变量时，可以出现省略后缀的情况。float则不同。

long l1 = 123L;
long l2 = 123;//可以理解是int类型的123自动类型提升为long类型

//long l3 = 123123123123; //报错，因为123123123123超出了int的范围。
long l4 = 123123123123L;


//float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型
float f2 = 12.3F;
float f3 = (float)12.3;

注：为什么标识符的声明规则里要求不能数字开头？

//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中l的值到底是123？还是变量123L对应的取值12呢？ 出现歧义了。
long l = 123L;

 5.3基本数据类型与String的运算

（1）字符串类型：String

  • String不是基本数据类型，属于引用数据类型

  • 使用一对""来表示一个字符串，内部可以包含0个、1个或多个字符。

  • 声明方式与基本数据类型类似。例如：String str = “尚硅谷”;

（2）运算规则
  • 任意八种基本数据类型的数据与String类型只能进行连接“+”运算，且结果一定也是String类型
System.out.println("" + 1 + 2);//12

int num = 10;
boolean b1 = true;
String s1 = "abc";

String s2 = s1 + num + b1;
System.out.println(s2);//abc10true

//String s3 = num + b1 + s1;//编译不通过，因为int类型不能与boolean运算
String s4 = num + (b1 + s1);//编译通过
  •  String类型不能通过强制类型()转换，转为其他的类型
String str = "123";
int num = (int)str;//错误的

int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转

（3）练习

String str1 = 4;                       //判断对错：×
String str2 = 3.5f + "";               //判断str2对错：√
System.out.println(str2);              //输出：3.5
System.out .println(3+4+"Hello!");     //输出：7Hello
System.out.println("Hello!"+3+4);      //输出：Hello34
System.out.println('a'+1+"Hello!");    //输出：bHello
System.out.println("Hello"+'a'+1);     //输出：Helloa1
System.out.println("*    *");				//输出：
System.out.println("*\t*");					//输出：
System.out.println("*" + "\t" + "*");		//输出：
System.out.println('*' + "\t" + "*");		//输出：
System.out.println('*' + '\t' + "*");		//输出：
System.out.println('*' + "\t" + '*');		//输出：
System.out.println("*" + '\t' + '*');		//输出：
System.out.println('*' + '\t' + '*');		//输出：

6、运算符（Operator）（掌握）

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

运算符的分类：

  • 按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符

分类运算符
算术运算符（7个）+、-、*、/、%、++、--
赋值运算符（12个）=、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等
比较(或关系)运算符（6个）>、>=、<、<=、==、!=
逻辑运算符（6个）&、|、^、!、&&、||
位运算符（7个）&、|、^、~、<<、>>、>>>
条件运算符（1个）(条件表达式)?结果1:结果2
Lambda运算符（1个）->
  • 按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）  
分类运算符
一元运算符（单目运算符）正号（+）、负号（-）、++、--、!、~
二元运算符（双目运算符）除了一元和三元运算符剩下的都是二元运算符
三元运算符 （三目运算符）(条件表达式)?结果1:结果2

6.1算数运算符

应用举例

（1）举例1：加减乘除模

public class ArithmeticTest1 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		
		System.out.println(a + b);// 7
		System.out.println(a - b);// -1
		System.out.println(a * b);// 12
		System.out.println(a / b);// 0
		System.out.println(a % b);// 3
        
        //结果与被模数符号相同
        System.out.println(5%2);//1
		System.out.println(5%-2);//1
		System.out.println(-5%2);//-1
		System.out.println(-5%-2);//-1		
		//商*除数 + 余数 = 被除数
		//5%-2  ==>商是-2，余数时1    (-2)*(-2)+1 = 5
		//-5%2  ==>商是-2，余数是-1   (-2)*2+(-1) = -4-1=-5
	}
}

（2）举例2：“+”号的两种用法

  • 第一种：对于+两边都是数值的话，+就是加法的意思

  • 第二种：对于+两边至少有一边是字符串的话，+就是拼接的意思

public class ArithmeticTest2 {
	public static void main(String[] args) {
		// 字符串类型的变量基本使用
		// 数据类型 变量名称 = 数据值;
		String str1 = "Hello";
		System.out.println(str1); // Hello
		
		System.out.println("Hello" + "World"); // HelloWorld
		
		String str2 = "Java";
		// String + int --> String
		System.out.println(str2 + 520); // Java520
		// String + int + int
		// String		+ int
		// String
		System.out.println(str2 + 5 + 20); // Java520
	}
}

（3）举例3：自加自减运算

理解：++ 运算，表示自增1。同理，-- 运算，表示自减1，用法与++ 一致。

（i）单独使用

  • 变量在单独运算的时候，变量前++和变量后++，是没有区别的。

  • 变量前++ ：例如 ++a 。

  • 变量后++ ：例如 a++ 。

public class ArithmeticTest3 {
	public static void main(String[] args) {
		// 定义一个int类型的变量a
		int a = 3;
		//++a;
		a++;
        // 无论是变量前++还是变量后++，结果都是4
		System.out.println(a);
	}
}

（ii）复合使用

  • 和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。

  • 变量前++ ：变量先自增1，然后再运算。

  • 变量后++ ：变量先运算，然后再自增1。

public class ArithmeticTest4 {
	public static void main(String[] args) {
		// 其他变量放在一起使用
		int x = 3;
		//int y = ++x; // y的值是4，x的值是4，
		int y = x++; // y的值是3，x的值是4
		
		System.out.println(x);
		System.out.println(y);
		System.out.println("==========");
        
		// 和输出语句一起
		int z = 5;
		//System.out.println(++z);// 输出结果是6，z的值也是6
		System.out.println(z++);// 输出结果是5，z的值是6
		System.out.println(z);
        
	} 
}

6.2 赋值运算符

（1）符号：=

  • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。

  • 支持连续赋值。

（2）扩展赋值运算符： +=、 -=、*=、 /=、%=不会改变数据类型

赋值运算符符号解释
+=将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量
-=将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量
*=将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量
/=将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量
%=将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量

public class SetValueTest1 {
	public static void main(String[] args) {
		int i1 = 10;
		long l1 = i1; //自动类型转换

		byte bb1 = (byte)i1; //强制类型转换

		int i2 = i1;

		//连续赋值的测试
		//以前的写法
		int a1 = 10;
		int b1 = 10;
		
		//连续赋值的写法
		int a2,b2;
		a2 = b2 = 10;
		
		int a3 = 10,b3 = 20;

		//举例说明+=  -=  *=  /=   %=  
		int m1 = 10;
		m1 += 5; //类似于 m1 = m1 + 5的操作，但不等同于。
		System.out.println(m1);//15
		
		//练习1：开发中，如何实现一个变量+2的操作呢？
		// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。
		//写法1：推荐
		short s1 = 10;
		s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
		System.out.println(s1);//12
		//写法2：
		short s2 = 10;
		//s2 = s2 + 2;//编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
		s2 = (short)(s2 + 2);
		System.out.println(s2);


		//练习2：开发中，如何实现一个变量+1的操作呢？
		//写法1：推荐
		int num1 = 10;
		num1++;
		System.out.println(num1);

		//写法2：
		int num2 = 10;
		num2 += 1;
		System.out.println(num2);

		//写法3：
		int num3 = 10;
		num3 = num3 + 1;
		System.out.println(num3);

	}
}

小王敲代码00
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值