Java基础语法：变量和运算符
1. 关键字
定义：被Java语言赋予了特殊含义，用做专门用途的单词 特点：关键字中所有字母都为小写
目前我们学习接触到的关键字较少，其他的关键字后续学习过程中逐步掌握，目前不需要全部记忆。
2. 保留字
Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 goto 、const
3. 标识符
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符 总结：凡是自己可以起名字的内容都称之为标识符。
4. 标识符命名规范
语法规定(最低标准)：
可以由：字母、数字、_、$、￥ 组成，但不能以数字开头。
不能与关键字、保留字重名。
约定俗成(更高标准)：
望文生义、见名知义。
类名由一个或多个单词组成，每个单词首字母大写（pascal）。
举例：学生 Student 人类 Person 订单信息 ：OrderInfo
方法名、变量名由一个或多个单词组成，首单词全部小写，拼接词首字母大写（camel）。
举例：学生姓名 studentNameAndInfo
包名全小写，只可以使用特殊字符“.”，并且不以“.”开头或结尾。
举例： com.xxx.xxx
常量全大写，多个单词用 _ 连接。
举例：国家名称 COUNTRY_NAME
public class A{
}
class 2B1{ // 这种命名会报错 数字不能开头
}
class $C{
}
class ￥D{
}
class 一个类{
}
5. 变量和数据类型概念
概念：计算机内存中的一块存储空间，是存储数据的基本单元。
生活中我们通常需要记录数据，在程序中亦是如此，生活中我们通过各种途径：图片，音频，视频，文字等方式记录数据，在程序中使用变
量记录数据。
举例：比如你的同桌需要大宝剑，发现前不够，找你借5毛钱。
时间：2025年3月29日09:35:35
事件：借钱
人物：你的同桌
地点：教室
金额：5毛 / 0.5元
……
记录数据涉及到不同的数据类型，Java语言也提供了对应的类型来存储不同类型的数据。
6. 变量的定义方式
声明变量的3种方式： 先声明，再赋值：【常用】 数据类型 变量名; 变量名 = 值;
声明并赋值：【常用】 数据类型 变量名 = 值;
多个同类型变量的声明与赋值：【了解】 数据类型 变量1 , 变量2 , 变量3 = 值3 , 变量4 , 变量5 = 值5;
public class TestVariableDefine{
public static void main(String [] args){
// 变量的定义方式
// 方式1 先声明 再赋值
int a;
a = 100;
// 字符串(英文双引号包括起来的内容都属于字符串)
// 字符串与任何内容相加 实为拼接 不做数学计算
System.out.println("变量a的取值为：" + a);
// 方式2 连声明带赋值写为一条语句
int b = 200;
System.out.println("变量b的取值为：" + b);
// 方式3 同时声明多个同类型的变量
int c , d , e = 55 , f , g = 66;
System.out.println("变量e的取值为：" + e);
System.out.println("变量g的取值为：" + g);
// 未赋值的局部变量 LocalVariable 不能使用 因为没有默认值
System.out.println("变量c的取值为：" + c);
System.out.println("变量d的取值为：" + d);
System.out.println("变量f的取值为：" + f);
}
}
7. 单位换算
1TB = 1024GB
1GB = 1024MB
1MB= 1024KB
1KB = 1024Byte(字节)
1Byte = 8bit(位)
一个字节占8位，即一个字节在内存中占8个小格子，每一个小格子只能存储一个0或者一个1，这个小格子我们称之为：位
8. 基本数据类型
8.1 整数类型
徽标 + CALC 呼出系统自带的计算器
public class TestNumberDefine{
public static void main(String [] args){
// 整数类型
// byte 类型 1个字节 取值范围 -128 ~ 127
byte b1 = -20;
byte b2 = 127;
// byte b3 = 128; 超出范围 无法存放
System.out.println("变量b1的取值为：" + b1);
System.out.println("变量b2的取值为：" + b2);
// System.out.println("变量b3的取值为：" + b3);
// short 类型 2个字节 取值范围 -32768 ~ 32767
short s1 = 12345;
short s2 = -12345;
System.out.println("变量s1的取值为：" + s1);
System.out.println("变量s2的取值为：" + s2);
// short s3 = -32769;
// short s4 = 32768;
// int类型 4个字节 取值范围 -2147483648 ~ 2147483647
int i1 = 45678;
int i2 = -789454;
System.out.println("变量i1的取值为：" + i1);
System.out.println("变量i2的取值为：" + i2);
// int i3 = -2147483649;
// int i4 = 2147483648;
// long 8个字节 取值范围 -9223372036854775808 ~ 9223372036854775807
System.out.println("long类型最大值：" + Long.MAX_VALUE);
System.out.println("long类型最小值：" + Long.MIN_VALUE);
long l1 = 5689;
long l2 = -78945;
System.out.println("变量l1的取值为：" + l1);
System.out.println("变量l2的取值为：" + l2);
// 给long类型赋值 如果取值范围超出int 则值的末尾必须追加 L 大小写都可以 推荐大写
// 如果取值范围没有超出int 则L可加可不加
// 当我们使用long类型存储数据 默认依然使用四个字节帮我们进行保存
// 这个操作属于JVM帮我们实现的内存优化 所以一旦超出int取值范围 会报错
// 如果希望JVM使用8个字节存储数据 则必须 显式 加上L
long l3 = 2147483648L;
System.out.println("变量l3的取值为：" + l3);
}
}
8.2 浮点类型
注意：double为浮点数的默认类型，如需为float类型赋值，需要在值的后面追加“F” float和double都属于近似值 不是精确值(无法表示精确值) 根据有效位决定 float有效位是6~7位数值 double有效位是15 ~ 16位数值
如果需要保存金钱，或者其他对精度有要求的数据，后续我们会学习BigDecimal
public class TestFloatAndDouble{
public static void main(String [] args){
// float 4个字节 取值范围 -3.4E38 ~ 3.4E38
float minValue = -340000000000000000000000000000000000000F;
System.out.println("float最小取值：" + minValue);
float maxValue = 340000000000000000000000000000000000000F;
System.out.println("float最大取值：" + maxValue);
double d1 = 2.5;
double d2 = 3.6;
System.out.println(d1);
System.out.println(d2);
double d3 = 20;
System.out.println(d3);
// 当直接赋值整数 取值范围超出int 则必须在值的末尾追加 D 推荐大写
double d4 = 2147483648D;
System.out.println(d4);
}
}
8.3 布尔类型
可直接赋值true / false
也可赋值一个结果为true / false的表达式
注意：Java中的boolean不能参与算数运算
public class TestBooolean{
public static void main(String [] args){
// 布尔类型 boolean 1个字节 true / false
boolean bl1 = true;
boolean bl2 = false;
System.out.println(bl1);
System.out.println(bl2);
int a = 10;
int b = 20;
boolean bl3 = a > b;
System.out.println(bl3);
}
}
8.4 字符类型
字符赋值：char c1 = 'A';（通过''描述为字符赋值）
整数赋值：char c2 = 65;（通过十进制数65在字符集中对应的字符赋值）
进制赋值：char c3 = '\u0041';（通过十六进制数41在字符集中所对应的字符赋值）
编码表：
ASCII码表 美国标准信息交换码
Unicode编码表 万国码
public class TestChar{
public static void main(String [] args){
// char类型 2个字节 取值范围 0 ~ 65535
// 三种赋值方式
// 方式1 直接使用英文单引号包括任意一个字符
char ch1 = 'a';
char ch2 = '中';
char ch3 = '_';
char ch4 = '1';
char ch5 = '?';
System.out.println(ch1);
System.out.println(ch2);
System.out.println(ch3);
System.out.println(ch4);
System.out.println(ch5);
System.out.println("-----------------------------------------");
// 方式2 直接赋值取值范围在0~65535以内的任意整数
// 当我们直接赋值整数 取值范围在0~127以内 将参考ASCII码表 映射为对应的字符
char c1 = 65; // A
char c3 = 66; // B
char c4 = 67; // C
char c2 = 97; // a
System.out.println(c1);
System.out.println(c3);
System.out.println(c4);
System.out.println(c2);
// 当我们直接赋值整数 取值范围超出 0~127 将参考Unicode编码表
// Unicode编码表 万国码 收录了世界上个各个国家文字 字符
// 是一个十六进制的编码表 0000 ~ FFFF
// 中文的取值范围： 4E00(19968) ~ 9FA5(40869)
char c5 = 20013;
System.out.println(c5);
char c6 = 20320;
System.out.println(c6);
char c7 = 19968;
System.out.println(c7);
char c8 = 40869;
System.out.println(c8);
System.out.println("-----------------------------------------");
// 方式3 直接使用英文的单引号包括 Unicode字符集的值 必须以 杠u 开头
char cc1 = '\u4E00';
char cc2 = '\u4E2D';
char cc3 = '\u4F59';
System.out.println(cc1);
System.out.println(cc2);
System.out.println(cc3);
// 使用十六进制 再转换为二进制
System.out.println((char)0B0110001000010001);
System.out.println((char)0B0111001000110001);
System.out.println((char)0B0100111101100000);
}
}
9.String类型(引用数据类型)
字符串与任何内容相加，不做数学计算，作拼接处理。
public class TestString{
public static void main(String [] args){
// String类型 任何英文双引号之间的内容都属于字符串(对象)
String s1 = "abc";
String s2 = "世界你好 66666 hello world";
String s3 = " 魏文强额温枪 额外企鹅 分我让人王企鹅请问二维请问饿";
System.out.println(s1 + s2);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
}
}
10. 转义字符
转义字符是为了保存一些特殊符号或者实现一些特殊的效果
public class TestConvertSign{
public static void main(String [] args){
// 转义字符
char ch1 = '\'';
System.out.println(ch1);
// \n 换行
System.out.println("a\nb\nc\nd\ne\nf\ng");
// \t 制表符 制表位 用于上下行文本对齐
System.out.println("床\t前\t明\t月\t光");
System.out.println("疑\t是\t地\t上\t霜");
// \\ 保存一个\ 需要写两个
char ch2 = '\\';
System.out.println(ch2);
// \" 保存在char类型中 可以不必转义
char ch3 = '"';
System.out.println(ch3);
String s1 = " a \" \" z ";
System.out.println(s1);
}
}
11. 类型转换
11.1 自动类型转换
自动类型转换 两种类型相互兼容。(6种数值类型和char类型兼容) 目标类型(等号左边)取值范围大于源类型(等号右边)取值范围。 byte < short < int < long < float < double char < int < long < float < double char转换为byte 或者 char转换为short都不能自动类型转换 必须强转
public class TestAutoConvert{
public static void main(String [] args){
// 自动类型转换
// 两种类型相互兼容。(6种数值类型和char类型兼容)
// 目标类型(等号左边)取值范围大于源类型(等号右边)取值范围。
// byte < short < int < long < float < double
// char < int < long < float < double
// char转换为byte 或者 char转换为short都不能自动类型转换 必须强转
byte b1 = 100;
short s1 = b1;
System.out.println(s1);
System.out.println("***************************");
short s2 = 2356;
int i1 = s2;
System.out.println(i1);
System.out.println("***************************");
int i2 = 5566;
long l1 = i2;
System.out.println(l1);
System.out.println("***************************");
long l2 = 564578L;
float f1 = l2;
System.out.println(f1);
System.out.println("***************************");
float f2 = 3.5F;
double d1 = f2;
System.out.println(d1);
System.out.println("***************************");
char c1 = 'A'; // 65
int a = c1;
long b = c1;
float c = c1;
double d = c1;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
11.2 强制类型转换
强制类型转换 两种类型相互兼容。(6种数值类型和char类型兼容) 目标类型(等号左边)取值范围小于源类型(等号右边)取值范围。
double > float > long > int > short > byte
double > float > long > int > char
short > char
byte > char
public class TestForceConvert{
public static void main(String [] args){
// 强制类型转换
// 两种类型相互兼容。(6种数值类型和char类型兼容)
// 目标类型(等号左边)取值范围小于源类型(等号右边)取值范围。
// double > float > long > int > short > byte
// double > float > long > int > char
// short > char
// byte > char
double d1 = 2.5;
float f1 = (float)d1;
System.out.println(f1);
System.out.println("---------------------------------------");
float f2 = 3.6F;
long l1 = (long)f2;
System.out.println(l1);
System.out.println("---------------------------------------");
long l2 = 100;
int i1 = (int)l2;
System.out.println(i1);
System.out.println("---------------------------------------");
int i2 = 100;
short s1 = (short)i2;
System.out.println(s1);
System.out.println("---------------------------------------");
short s2 = 100;
byte b2 = (byte)s2;
System.out.println(b2);
System.out.println("---------------------------------------");
double a = 65.5;
float b = 65.5F;
long c = 65;
int d = 65;
char c1 = (char)a;
System.out.println(c1);
char c2 = (char)b;
System.out.println(c2);
char c3 = (char)c;
System.out.println(c3);
char c4 = (char)d;
System.out.println(c4);
System.out.println("---------------------------------------");
short sho1 = 65;
byte by1 = 65;
char cc1 = (char)sho1;
System.out.println(cc1);
char cc2 = (char)by1;
System.out.println(cc2);
}
}
11.3 强制类型转换特殊情况
原返补码
计算机是以补码形式表示所有整数数值的
正数的原返补码都一样 三码合一
负数不同
原码：首位为符号位 0表示正数 1表示负数 其余各位为计数器
反码：在原码的基础上 符号位不变 其余各位取反
补码：在反码的基础上 + 1
强制类型转换规则： 整数长度足够，数据完整。 例：int i = 100; byte b = (byte)i; //b = 100
整数长度不够，数据截断。 例：int i = 10000; byte b = (byte)i; //b = 16 例：int a = 128; byte b = (byte)a;（符号位变化，可能变为负数）
小数强转整数，数据截断。 例：double d = 2.5; int i = (int)d; //i = 2（小数位舍掉）
字符整数互转，数据完整。 例：char c = 65; int i = c; //i = 65 boolean的取值为true/false，不可与其他类型转换。
/**
* 原返补码
* 计算机是以补码形式表示所有整数数值的
*
* 正数的原返补码都一样 三码合一
* 负数不同
*
* 原码：首位为符号位 0表示正数 1表示负数 其余各位为计数器
* 反码：在原码的基础上 符号位不变 其余各位取反
* 补码：在反码的基础上 + 1
*
*/
public class TestSpecialForceConvert{
public static void main(String [] args){
System.out.println("-----------------符号位发生变化------------------");
short s1 = 128;
byte b1 = (byte)s1;
System.out.println(b1); // 1000 0000 -128
System.out.println("-------------------符号位发生变化----------------");
s1 = 129;
b1 = (byte)s1;
System.out.println(b1); // 1000 0001 -127
System.out.println("-----------------符号位不变------------------");
// 符号位不变
s1 = 257;
b1 = (byte)s1;
System.out.println(b1); // 0000 0001 1
System.out.println("------------------符号位不变-----------------");
s1 = 259;
b1 = (byte)s1;
System.out.println(b1); // 0000 0011 3
}
}
12. 包的概念
包 英文名称 package 用于管理java文件以及class文件
包就是文件夹
包名命名规范：全部小写 域名倒置 不能以点开头或者结尾 可以包含 点 每存在一个 点 表示一个子文件夹
www.baidu.com com.baidu.xxx
www.sina.com.cn cn.com.sina.xxxx
www.xxx.com com.xxx.xxx
编写在包中的类 必须在第一行使用package关键字 声明所在包
package com.xxx.test1; // 声明当前类所在包 永远在Java类中的第一行代码
public class HelloPackage {
public static void main(String[] args) {
System.out.println("hello package 世界你好 ");
}
}
13. 运算符
13.1 算术运算符
/**
* 算数运算符
* + - * / %
*
* ctrl + D 复制当前行代码
*
* 修改类名和文件名 直接在代码中修改类名 然后使用alt + 回车 rename file 重命名文件
*
*/
public class TestArithmeticOperator1 {
public static void main(String[] args) {
int a = 10;
int b = 5;
System.out.println(a + b); // 15
System.out.println(a - b); // 5
System.out.println(a * b); // 50
System.out.println(a / b); // 2
System.out.println(a % b); // 0
int c = 3;
System.out.println(a / c); // 因为a和c 都属于int类型 所以最终的结果也是int类型 即结果为3
// tab键应用AI提示
System.out.println(a % c);
}
}
++ 或者 -- 情况1：如果单独作为一条语句书写 在前在后 没有区别
情况2：如果不是单独作为一条语句书写 在前在后 有区别 如果++或者--在前 则先执行++或者-- 再执行其他的 如果++或者--在后 则先执行其他的 再执行++或者--
package com.xxx.test2;
/**
* 算数运算符
* ++ 表示自增1
* -- 表示自减1
* 如果不希望有不正确单词的波浪线提示 可以鼠标悬停单词 选择添加到字典中
*
*/
public class TestArithmeticOperator2 {
public static void main(String[] args) {
int a = 10;
a++; // 结果等同于 a = a + 1;
System.out.println("a = " + a); // soutv 打印上方的变量
int b = 10;
b--; // 结果等同于 b = b - 1;
System.out.println("b = " + b);
System.out.println("----------------------------------------------");
int c = 10;
++c;
System.out.println("c = " + c);
int d = 10;
--d;
System.out.println("d = " + d);
System.out.println("---------------------------------------------");
// ++ 或者 --
// 如果单独作为一条语句书写 在前在后 没有区别
// 如果不是单独作为一条语句书写 在前在后 有区别
// 如果++或者--在前 则先执行++或者-- 再执行其他的
// 如果++或者--在后 则先执行其他的 再执行++或者--
int j = 10;
int k = j++;
System.out.println("k = " + k);
int e = 10;
int f = ++e;
System.out.println("f = " + f);
System.out.println("---------------------------------------------");
// 先乘除 后加减
int n = 1;
int m = n++ + ++n * n++;
System.out.println("m = " + m); // 30 ? 10 ? 3 ? 7 ?
System.out.println("n = " + n);
System.out.println("---------------------------------------------");
// 小括号内的优先计算 如果小括号内 只有++或者-- 那么小括号不影响运算顺序
n = 1;
m = (n++) + (++n) * (n++);
System.out.println("m = " + m); // 14 ？ 10
System.out.println("n = " + n);
System.out.println("---------------------------------------------");
int s = 1;
// 如果赋值运算符左右两边都是同一个变量 并且右边只有++或者--操作 同时++或者--在后的情况
// 那么最终的结果只按照第一次赋值的结果来
s = s++;
System.out.println("s = " + s); // ?
}
}
13.2 算数计算类型问题
进行算数运算时： 两个操作数有一个为double，计算结果提升为double。 如果操作数中没有double，有一个为float，计算结果提升为float。 如果操作数中没有float，有一个为long，计算结果提升为long。 如果操作数中没有long，有一个为int，计算结果提升为int。
多个操作数进行书写计算，最终结果会提升为取值范围最大的类型
如果操作数中没有int，均为short或byte或者char，计算结果仍旧提升为int。
特殊：任何类型与String相加（+）时，实为拼接，其结果为String。
package com.xxx.test2;
/**
* 进行算数运算时：
* 两个操作数有一个为double，计算结果提升为double。
* 如果操作数中没有double，有一个为float，计算结果提升为float。
* 如果操作数中没有float，有一个为long，计算结果提升为long。
* 如果操作数中没有long，有一个为int，计算结果提升为int。
*
*
* 如果操作数中没有int，均为short或byte或者char，计算结果仍旧提升为int。
*
* 特殊：任何类型与String相加（+）时，实为拼接，其结果为String。
*/
public class TestArithmeticOperator3 {
public static void main(String[] args) {
double a = 10.5;
float b = 3.5F;
long c = 100;
int d = 200;
double sum1 = a + b;
float sum2 = b + c;
long sum3 = c + d;
int e = 100;
int sum4 = d + e;
byte b1 = 10;
short s1 = 10;
char c1 = 'A';
int sum5 = b1 + s1;
int sum6 = s1 + c1;
System.out.println("sum6 = " + sum6);
int sum7 = b1 + c1;
System.out.println("sum7 = " + sum7);
char c2 = 'A';
System.out.println(c2 - 1);
System.out.println(c2 + 1);
System.out.println(c2 * 2);
System.out.println(c2 / 2);
}
}
13.3 赋值运算符
package com.xxx.test3;
/**
* 赋值运算符
*
*/
public class TestAssigmentOperator {
public static void main(String[] args) {
int a = 10;
a += 10; // 结果等同于 a = a + 10;
System.out.println("a = " + a); // 20
a -= 10; // 结果等同于 a = a - 10;
System.out.println("a = " + a); // 10
a *= 10; // 结果等同于 a = a * 10;
System.out.println("a = " + a); // 100
a /= 10;// 结果等同于 a = a / 10;
System.out.println("a = " + a); // 10
a %= 3;// 结果等同于 a = a % 3;
System.out.println("a = " + a); // 1
short s1 = 10;
s1 += 10; // 这里JVM帮我们实现了 隐式 的类型转换
s1 = (short) (s1 + 10);
s1++;// 这里JVM帮我们实现了 隐式 的类型转换
s1 = (short) (s1 + 1);
}
}
13.4 关系运算符
关系运算符最终的结果都是布尔类型 表示某种关系是否成立
package com.xxx.test3;
/**
* 关系运算符
* 关系运算符最终的结果都是布尔类型 表示某种关系是否成立
*/
public class TestRelationOperator {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a > b); // false
System.out.println(a < b); // true
System.out.println(a >= b); // false
System.out.println(a <= b); // true
System.out.println(a == b); // false
System.out.println(a != b); // true
}
}
13.5 逻辑运算符
& 与 没有短路效果 不管前边的条件结果如何 都将执行完所有的条件
&& 短路与 有短路的效果 如果前边的条件不成立 则后续的条件不再执行
| 或 没有短路效果 不管前边的条件结果如何 都将执行完所有的条件
|| 短路或 有短路的效果 如果前边的条件成立 则后续的条件不再执行
package com.xxx.test3;
/**
* 逻辑运算符
* & 与 没有短路效果 不管前边的条件结果如何 都将执行完所有的条件
* && 短路与 有短路的效果 如果前边的条件不成立 则后续的条件不再执行
*
* | 或 没有短路效果 不管前边的条件结果如何 都将执行完所有的条件
* || 短路或 有短路的效果 如果前边的条件成立 则后续的条件不再执行
*
* !
*/
public class TestLogicOperator {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
System.out.println((a < b) & (b < c)); // true
System.out.println((a > b) & (b < c)); // false
System.out.println((a < b) & (b > c)); // false
System.out.println((a > b) & (b > c)); // false
System.out.println("---------------------------------");
System.out.println((a < b) && (b < c)); // true
System.out.println((a > b) && (b < c)); // false
System.out.println((a < b) && (b > c)); // false
System.out.println((a > b) && (b > c)); // false
System.out.println("---------------------------------");
System.out.println((a < b) | (b < c)); // true
System.out.println((a > b) | (b < c)); // true
System.out.println((a < b) | (b > c)); // true
System.out.println((a > b) | (b > c)); // false
System.out.println("---------------------------------");
System.out.println((a < b) || (b < c)); // true
System.out.println((a > b) || (b < c)); // true
System.out.println((a < b) || (b > c)); // true
System.out.println((a > b) || (b > c)); // false
System.out.println("---------------------------------");
System.out.println(!true);
System.out.println(!false);
}
}
package com.xxx.test3;
/**
* 逻辑运算符练习题
* <p>
* ctrl + alt + L 自动对齐 格式化代码
*/
public class TestLogicOperatorExercise {
public static void main(String[] args) {
int x = 8;
int y = 9;
System.out.println((++x == y) && (++x != y)); // true
System.out.println(x); // 10
x = 8;
y = 9;
System.out.println((x++ == y) && (++x != y)); // false
System.out.println(x); // 9
x = 8;
y = 9;
System.out.println((x++ == y) & (++x != y)); // false
System.out.println(x); // 10
System.out.println("-------------------------------------------------------");
x = 8;
y = 9;
System.out.println((++x == y) || (++x != y)); // true
System.out.println(x); // 9
x = 8;
y = 9;
System.out.println((++x == y) | (++x != y)); // true
System.out.println(x); // 10
}
}
package com.xxx.test3;
/**
* 三元运算符
*/
public class TestThreeElementOperator {
public static void main(String[] args) {
int age = 27;
System.out.println(age >= 18 ? "成年" : "未成年");
int a = 1;
int b = a >= 10 ? 55 : 66;
System.out.println("b = " + b);
}
}
13.6 位运算符
package com.xxx.test4;
/**
* 位运算符 直接针对于二进制数进行计算 所以效率非常高 但是优先级比较低
*/
public class TestBitOperator {
public static void main(String[] args) {
// << 左移 左移几位表示乘以2的几次方 符号位有可能发生变化 变为负数
System.out.println(1 << 1);
System.out.println(1 << 2);
System.out.println(1 << 3);
System.out.println(1 << 4);
System.out.println(1 << 31);
System.out.println(1 << 32);
System.out.println(1 << 33);
System.out.println("------------------------------");
// >> 右移 右移几位表示除以2的几次方
// 如果最高位是1 则移动以后空缺位补1
// 如果最高位是0 则移动以后空缺位补0
System.out.println(16 >> 1);
System.out.println(16 >> 2);
System.out.println(16 >> 3);
System.out.println(16 >> 4);
System.out.println(16 >> 5);
System.out.println(16 >> 6);
System.out.println(16 >> 7);
System.out.println(-20 >> 2);
System.out.println("------------------------------");
// 无符号 ：没有正负号
// >>> 右移几位表示除以2的几次方 不管最高位原来是0还是1 移动以后统一补0
// 所以 无符号右移以后 都是正数 没有负数
System.out.println(16 >>> 1);
System.out.println(16 >>> 2);
System.out.println(16 >>> 3);
System.out.println(16 >>> 4);
System.out.println(16 >>> 5);
System.out.println(16 >>> 6);
System.out.println(16 >>> 7);
System.out.println(-20 >>> 2);
System.out.println("------------------------------");
// & 与 两个二进制数进行与运算
// 相同位 都为1 结果为1 其他情况结果为0
System.out.println(21 & 7);
System.out.println("------------------------------");
// | 或 两个二进制数进行或运算
// 相同位 有一个为1 或者两个都为1 结果为1 其他情况结果为0
System.out.println(21 | 7);
System.out.println("------------------------------");
// ^ 异或 找不同 相同二进制位 ： 不同为1 相同为0
System.out.println(21 ^ 7);
System.out.println("------------------------------");
// ~整数 取反 包括符号位在内 每一位都取反 是0改为1 是1改为0
System.out.println(~7);
}
}
14. 运算符优先级
运算符是有优先执行等级的 但我们不需要每个都记忆 只需要掌握 下括号优先级最高
赋值运算符优先级最低 即可
15. 表达式
使用运算符连接的变量或字面值，并可以得到一个最终结果。
1 + 2;
a - 2;
b * c;c / b;
d > e;d <= e;
// 以上都属于表达式
16. 整数的四种赋值方式
package com.xxx.test5;
/**
* 整数数值的各种赋值方式
*/
public class TestNumber {
public static void main(String[] args) {
int a = 10;
int b = 0B11; // 二进制
System.out.println("b = " + b);
int c = 011; // 八进制
System.out.println("c = " + c);
int d = 0X4E2D; // 十六进制 20013
System.out.println("d = " + d);
char c1 = 20013;
System.out.println("c1 = " + c1);
}
}
17. Scanner 工具类
Scanner是JDK提供的一个工具类，位于java.util这个包中，使用此类必须通过import关键字导包。
我们使用Scanner可以使用户和程序交互，接收用户输入的各种信息
Scanner提供了如下方法用于接收用户输入的对应类型的数据
nextByte() 接收用户输入的byte类型数据
nextShort() 接收用户输入的short类型数据
nextInt() 接收用户输入的int类型数据 nextLong() 接收用户输入的long类型数据
nextFloat() 接收用户输入的float类型数据
nextDouble() 接收用户输入的double类型数据
nextBoolean() 接收用户输入的boolean类型数据
next() 接收用户输入的String类型数据注意：没有nextChar() 这个方法 即即使需要接收一个字符 也只能使用next()方法 处理为字符串
package com.xxx.test6; // 这条语句永远在第一行
import java.util.Scanner; // 导包语句在包声明之后 类声明之前
/**
* Scanner类的使用
*
* 使用Scanner接收用户输入的数据 如果类型不匹配 将会出现 InputMismatchException
* 而异常会导致程序中断 即未执行完的代码 不再执行
*
*/
public class TestScanner {
public static void main(String[] args) {
// 1.创建Scanner类型的变量 取名为 input
Scanner input = new Scanner(System.in);
// 2.提示用户输入信息
System.out.println("请输入您的姓名");
// 3.接受用户输入的数据 并且 保存在变量中
String name = input.next();
// 4.将用户输入的数据打印出来
System.out.println("您输入的姓名为：" + name);
// 接收其他类型的数据 重复以上 第 2.3.4步即可
System.out.println("请输入您的年龄");
int age = input.nextInt();
System.out.println("您输入的年龄为：" + age);
System.out.println("请输入您的身高");
double height = input.nextDouble();
System.out.println("您输入的身高为：" + height);
System.out.println("请输入你今天是否开心");
boolean isHappy = input.nextBoolean();
System.out.println("您输入的是否开心为：" + isHappy);
System.out.println("程序结束");
}
}
