1、Java SE基础-数据类型、运算符

最新推荐文章于 2024-04-26 10:16:36 发布
最新推荐文章于 2024-04-26 10:16:36 发布
阅读量237 收藏
点赞数
分类专栏： Java 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42749734/article/details/108555648
版权

Java基础

1、变量的基本概念

2、变量的声明方式

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

  • 变量要声明
  • 变量要初始化
  • 变量不能重复声明
public class VarTest{

	public static void main(String[] args){
	
		//声明变量
		int age=18;
		String name="张三";
		//打印值
		System.out.println("age："+age);


	}


}

从终端获取数据并打印

import java.util.Scanner;

public class VarIOTest{
	
	public static void main(String[] args){

		String name;
		int age;
		System.out.println("输入姓名和年龄");
		
		// 从终端获取数据
		Scanner sc = new Scanner(System.in);
		
		// 把获取到的数据赋值给name,age
		name = sc.next();
		age = sc.nextInt();

		// 打印姓名年龄
		System.out.println("姓名："+name);
		System.out.println("年龄："+age);
	}


}
  • 标识符
  1. 由数字、字母、下划线以及￥等组成，其中数字不能开头。
  2. 不能使用Java语言的关键字，所谓关键字就是java语言用于表示特殊含义的单词；
  3. 区分大小写，长度没有限制但不宜过长；
  4. 尽量做到见名知意，支持中文但不推荐使用
  5. 标识符可以给类、变量、属性、方法、包起名。

关键字

在这里插入图片描述

3、数据类型

数据类型的分类
1、 基本数据类型
byte、short、int、long、float、double、boolean、char
2、引用数据类型
数组、类、接口、枚举、标注

整数类型

/*
    编程实现整数类型的使用
 */
public class IntTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个byte类型的变量并初始化
		byte b1 = 25;
		//byte b1 = 250;     // 错误: 不兼容的类型: 从int转换到byte可能会有损失  250这样直接写出的整数数据叫做直接量/常量/字面值 默认为int类型 
		// 2.打印变量的数值
		System.out.println("b1 = " + b1); // b1 = 25
		
		System.out.println("---------------------------------------------");
		// 3.声明一个short类型的变量并初始化
		short s1 = 250;
		//short s1 = 250250;  // 错误：不兼容的类型：从int转换到short可能会有损失
		System.out.println("s1 = " + s1); // s1 = 250
		
		System.out.println("---------------------------------------------");
		// 4.声明一个int类型的变量并初始化
		int i1 = 250250;
		//int i1 = 2502505006; // 错误: 整数太大   默认为int类型，这个数据自身已经出错，无法表示
		//int i1 = 2502505006L;  // 错误：不兼容的类型：从long转换到int可能会有损失
		System.out.println("i1 = " + i1); // i1 = 250250
		
		System.out.println("---------------------------------------------");
		// 5.声明一个long类型的变量并初始化，若描述比long类型还大的数据则使用java.math.BigInteger类型
		long g1 = 2502505006L;
		System.out.println("g1 = " + g1); // g1 = 2502505006
		
		System.out.println("---------------------------------------------");
		// 6.请问下面的代码是否有错误？若有请指出并说明原因
		//int i2 = 25;
		//byte b2 = i2;  // 错误: 不兼容的类型: 从int转换到byte可能会有损失
		//System.out.println("b2 = " + b2);
		
	}
}

浮点类型

/*
    编程实现浮点类型的使用
 */
public class DoubleTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个float类型的变量并初始化
		//float f1 = 3.1415926;   // 错误: 不兼容的类型: 从double转换到float可能会有损失   小数数据叫做直接量，默认为double类型
		float f1 = 3.1415926f;
		// 2.打印变量的数值
		System.out.println("f1 = " + f1); // f1 = 3.1415925     一般是7位有效数字
		
		System.out.println("---------------------------------------------------------");
		// 3.声明一个double类型的变量并初始化
		double d1 = 3.1415926;
		System.out.println("d1 = " + d1); // d1 = 3.1415926     一般是15位有效数字
		
		System.out.println("---------------------------------------------------------");
		// 4.笔试考点
		System.out.println(0.1 + 0.2);  // 0.30000000000000004  运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型 
	}
}

字符型

/*
   编程实现字符类型的使用         
 */
public class CharTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个char类型的变量并初始化
		char c1 = 'a';
		// 2.打印变量的数值
		System.out.println("c1 = " + c1); // c1 = a   
		System.out.println("对应的编号是：" + (int)c1); // 表示将char类型的c1强制转换为int类型并打印   97 
		
		System.out.println("-------------------------------------------------------------------------");
		// 2.声明一个char类型的变量并初始化
		char c2 = 98;
		System.out.println("c2 = " + c2); // c2 = b   
		System.out.println("对应的编号是：" + (int)c2); // 98
		
		System.out.println("-------------------------------------------------------------------------");
		// 3.使用Unicode字符集来表示一下我的名字   奇点  对应的编号是： \u5947\u70b9
		char c3 = '\u5947';
		char c4 = '\u70b9';
		System.out.println("最终的结果是：" + c3 + c4); // 奇点
		
		System.out.println("-------------------------------------------------------------------------");
		// 4.特殊字符的使用   双引号本身有2个含义：a.字符串的开头和结尾标志    b.双引号自身    \ 转义就是转换原有的含义
		System.out.println("我想过过\"过过过过的生活！");   //  \"  - "
		System.out.println("我想过过\'过过过过的生活！");
		System.out.println("我想过过\\过过过过的生活！");
		System.out.println("我想过过\t过过过过的生活！");
		System.out.println("我想过过\n过过过过的生活！");
	}
}

布尔类型

/*
    编程实现布尔类型的使用
 */
public class BooleanTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个boolean类型的变量并初始化
		boolean b1 = true;
		// 2.打印变量的数值
		System.out.println("b1 = " + b1); // b1 = true
		
		System.out.println("-------------------------------------------");
		// 3.修改变量b1的数值   = 赋值运算符，用于将=右边的数据赋值给=左边的变量，覆盖变量中原来的数值
		b1 = false;
		System.out.println("b1 = " + b1); // b1 = false
		
		System.out.println("-------------------------------------------");
		//b1 = 1; // 错误: 不兼容的类型: int无法转换为boolean
	}
}

4、进制

正十进制转二进制

  • 除2取余法：使用十进制整数不断地除以2取出榆树，知道商为0时将余数逆序排序。
    在这里插入图片描述
    0b/0B为二进制标识
  • 拆分法，将十进制整数拆分为若干个二进制权重的和，有该权重下面写1，否则写0.

在这里插入图片描述

二进制转十进制

  • 加权法，使用二进制中的每个数字乘以当前位的权重再累加起来。
    在这里插入图片描述

负数之间的进制转换
先将十进制的绝对值转为二进制，然后进行按位取反加1；负数的需要补码：按位取反，再加1。
在这里插入图片描述

验证：-45+45=0

在这里插入图片描述
负二进制转十进制
：先减1再按位取反，合并为十进制整数后添加负号

在这里插入图片描述
单个字节表示的范围

  • 在计算机中单个字节表示八位二进制，其中最高位（最左边）代表符号位，使用0代表非负数，使用1代表负数，具体的整数范围如下：
  • 非负数表示范围：0000 0000 ~ 0111 1111 =>0 ~ 127=>0~2^7-1
  • 负数的表示范围：1000 0000 ~ 1111 1111=>-128 ~ -1=>-2^7 ~ 2^0
  • 单个字节表示的整数范围是：-128 ~ 127

在这里插入图片描述
整数类型

  • Java语言中描述整数数据的类型有：byte、short、int、long；推荐使用int类型（系统默认为int）
  • 其中byte类型在内存空间占1个字节，表示范围是：-2^7 ~ 2^7-1
  • 其中short类型在内存空间占2个字节，表示范围是：-2^15 ~ 2^15-1
  • 其中int类型在内存空间占4个字节，表示范围是：-2^31 ~ 2^31-1
  • 其中long类型在内存空间占8个字节，表示范围是：-2^63 ~ 2^63-1
  • 在java程序中直接写出的整数数据叫做直接量/字面值/常量，默认为int类型。若希望表达更大的直接量，则在直接量的后面加上l或者L，推荐L。

浮点型

  • java语言中用于描述小数数据的类型：float 和 double，推荐double类型；
  • 其中float类型在内存空间占4个字节，叫做单精度浮点数，可以表示7位有效数字，范围：-3.403E38 ~ 3.403E38。
  • 其中double类型在内存空间占8个字节，叫做双精度浮点数，可以表示15位有效数字，范围：-1.798E308 ~ 1.798E308。
  • java程序中直接写出的小数数据叫做直接量，默认为double类型，若希望
    表达float类型的直接量，则需要在直接量的后面加上f或者F。

布尔类型
只有两个值，true，false
布尔类型在内存空间中所占大小没有明确的规定，可以认为是1个字节
字符类型

  • 计算机的底层只识别0和1组成的二进制序列，对于字符 ‘a’ 这样的图案来说不满足该规则，因此该数据无法直接在计算机中存储，但现实生活中存在这样的图案数据需要计算机存储，为了使得该数据能够存储起来就可以给该数据指定一个编号，然后将编号存储起来即可，该编号就叫做
    ASCII。

  • 要求掌握的ASCII有：‘0’ -48 ‘A’ -65 ‘a’ -97 空格 -32 换行符 -10

  • java 字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集，所有的字符都是16位。

  • 常用的转义字符有：
    在这里插入图片描述

在这里插入图片描述

基本数据类型的转换

  • 小转大自动转
  • 大转小需要强转
    在这里插入图片描述
    类型之间的转换
/*
    编程实现基本数据类型之间转换的使用
 */
public class TransformTest {
	
	public static void main(String[] args) {
		
		// 1.声明两个变量并初始化
		byte b1 = 10;
		short s1 = 20;
		// 2.打印变量的数值
		System.out.println("b1 = " + b1); // b1 = 10
		System.out.println("s1 = " + s1); // s1 = 20
		
		System.out.println("----------------------------------------------");
		// 3.实现自动类型转换的使用
		// 表示将变量b1的数值赋值给变量s1，并覆盖变量s1中原来的数值，相当于从byte类型到short类型的转换，小到大  自动转换
		s1 = b1;
		System.out.println("b1 = " + b1); // b1 = 10
		System.out.println("s1 = " + s1); // s1 = 10
		
		System.out.println("----------------------------------------------");
		// 4.实现强制类型转换的使用
		// 表示将变量s1的数值赋值给变量b1，并覆盖变量b1中原来的数值，相当于从short类型到byte类型的转换，大到小  强制转换
		//b1 = s1;   // 错误: 不兼容的类型: 从short转换到byte可能会有损失
		s1 = 128;    // 故意加该行代码      128:0000 0000 1000 0000  => 1000 0000 => 0111 1111 => 1000 0000 => 128 => -128
		b1 = (byte)s1;
		System.out.println("b1 = " + b1); // b1 = 10   -128 
		System.out.println("s1 = " + s1); // s1 = 10   128
	}
}

5、运算符

算数运算符

· + 表示加法运算符

· - 表示减法运算符

· * 表示乘法运算符

· / 表示除法运算符

· % 表示取模/取余运算符

重点：

  • int类型整除怎么保留小数
  • 0不能做除数

/*
    编程实现算术运算符的使用
 */
public class ArithmeticTest {
	
	public static void main(String[] args) {
		
		// 1.声明两个int类型的变量并初始化
		//int ia = 6, ib = 2;       // 表示声明两个int类型的变量ia和ib，不推荐使用
		int ia = 6;                 // 推荐该方式，提高了代码的可读性
		int ib = 2;
		System.out.println("ia = " + ia); // ia = 6
		System.out.println("ib = " + ib); // ib = 2
		
		System.out.println("----------------------------------------");
		// 2.使用上述变量实现算术运算符的使用   +  -  *  /  %
		// 表示声明变量ic来记录ia与ib的和
		int ic = ia + ib;
		System.out.println("ic = " + ic); // ic = 8
		// 其中ia+ib这个整体叫做表达式  ia、ib叫做操作数   +叫做操作符/运算符
		System.out.println(ia + ib);  // 8
		System.out.println(ia - ib);  // 4
		System.out.println(ia * ib);  // 12
		System.out.println(ia / ib);  // 3
		System.out.println(ia % ib);  // 0
		
		System.out.println("----------------------------------------");
		// 3.注意事项
		// 3.1 当两个整数相除时结果只保留整数部分，丢弃小数部分
		System.out.println(5 / 2); // 2
		
		System.out.println("----------------------------------------");
		// 3.2 若希望保留小数部分该如何处理？
		// 处理方式一：使用强制类型转换将其中一个操作数转换为double类型再运算即可
		System.out.println((double)5 / 2);   // 2.5
		System.out.println(5 / (double)2);   // 2.5
		System.out.println((double)5 / (double)2); // 2.5
		System.out.println((double)(5 / 2)); // 2.0
		// 处理方式二：让其中一个操作数乘以1.0即可（推荐）
		System.out.println(5*1.0 / 2); // 2.5
		System.out.println(5.0 / 2);   // 2.5   ia.0 错误的表示
		
		System.out.println("----------------------------------------");
		// 3.3 0不能作除数
		//System.out.println(5 / 0); // 编译ok，运行发生java.lang.ArithmeticException(算术异常 记住): / by zero
		System.out.println(5 / 0.0); // Infinity 无穷
 		System.out.println(0 / 0.0); // NaN Not a Number 
	}
}

时间拆分

重点：整除，取余

知识点：

  • +既可以作为字符串连接符，又可以作为加法运算符；只要+两边的操作数中有一个操作数是字符串类型，则该+就被当做字符串连接符处理，否则当做加法运算符处理
/*
    编程使用算术运算符实现秒数的拆分
 */

import java.util.Scanner; 
 
public class ArithmeticTimeTest {
	
	public static void main(String[] args) {
		
		// 1.提示用户输入一个正整数的秒数并使用变量记录
		System.out.println("请输入一个正整数的秒数：");
		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();
		
		// 2.将正整数的秒数拆分为时分秒后并使用变量记录
		// 3666秒 => 1小时1分钟6秒钟
		// 3666 / 3600 = 1 小时     3666 % 3600 = 66 / 60 = 1 分钟     3666 % 60 = 6 秒钟 
		int hour = num / 3600;      // 拆分小时数
		int min = num % 3600 / 60;  // 拆分分钟数
		int sec = num % 60;         // 拆分秒数
		
		// 3.打印最终的拆分结果
		System.out.println(num + "秒转换为" + hour + "小时" + min + "分钟" + sec + "秒钟");
		
		System.out.println("---------------------------------------------------------------------");
		// 4.+既可以作为字符串连接符，又可以作为加法运算符
		// 只要+两边的操作数中有一个操作数是字符串类型，则该+就被当做字符串连接符处理，否则当做加法运算符处理
		System.out.println(hour + min + sec);       // 8
		System.out.println(hour + min + sec + "");  // 8
		System.out.println(hour + min + "" + sec);  // 26
		System.out.println(hour + "" + min + sec);  // 116
		System.out.println("" + hour + min + sec);  // 116
		System.out.println("" + (hour + min + sec));// 8
	}
}

赋值运算符

重点知识

  • b1 += 2（ia = ia + 2）; 真正等价于b1 = (byte)(b1 + 2);

byte b1 = 10;
System.out.println("b1 = " + b1);
b1 + 2; // 错误: 不兼容的类型: 从int转换到byte可能会有损失；byte + int 相加结果还是int类型
b1 = b1 + (byte)2; 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte + byte 相加结果还是int类型 编译器优化
b1 = (byte)(b1 + 2); 强制类型转换，将int类型转换为byte
b1 += 2; 真正等价于b1 = (byte)(b1 + 2);

  • 判断2是否等于变量ia的数值
    2 == ia; 从结果上来说等价，推荐该方式
/*
    赋值运算符的使用
 */
public class AssignTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个int类型的变量并初始化
		int ia = 3;
		// 2.打印变量的数值
		System.out.println("ia = " + ia); // ia = 3
		
		System.out.println("-----------------------------------");
		// 3.简单赋值运算符的使用
		// 表示将数据5赋值给变量ia并且覆盖变量ia原来的数值
		ia = 5;
		System.out.println("ia = " + ia); // ia = 5
		// 下面的代码是在打印表达式的结果
		System.out.println( ia = 5 ); // 5
		System.out.println("ia = " + ia); // ia = 5
		int ib = ia = 6;
		System.out.println("ia = " + ia); // ia = 6
		System.out.println("ib = " + ib); // ib = 6
		int ic;
		ic = ib = ia = 8;
		System.out.println("ia = " + ia); // ia = 8
		System.out.println("ib = " + ib); // ib = 8
		System.out.println("ic = " + ic); // ic = 8
		
		System.out.println("-----------------------------------");
		// 4.复合赋值运算符的使用
		//ia = ia + 2;  目前推荐使用该方式
		ia += 2;        // 简化写法，从结果上来看是等价的
		System.out.println("ia = " + ia); // ia = 10
		
		System.out.println("-----------------------------------");
		// 5.笔试考点1
		byte b1 = 10;
		System.out.println("b1 = " + b1); // b1 = 10
		//b1 = b1 + 2; // 错误: 不兼容的类型: 从int转换到byte可能会有损失         byte + int 相加结果还是int类型
		//b1 = b1 + (byte)2; // 错误: 不兼容的类型: 从int转换到byte可能会有损失   byte + byte 相加结果还是int类型  编译器优化
		//b1 = (byte)(b1 + 2); // 强制类型转换，将int类型转换为byte
		b1 += 2; // 真正等价于b1 = (byte)(b1 + 2);
		System.out.println("b1 = " + b1); // b1 = 12
		
		System.out.println("-----------------------------------");
		// 6.笔试考点2
		//ia == 2; - 表示判断变量ia的数值是否等于2
		//2 == ia; - 表示判断2是否等于变量ia的数值，从结果上来说等价，推荐该方式
		//ia = 2;  - 表示将2赋值给变量ia，覆盖变量ia原来的数值
		//2 = ia;  //- 编译报错  错误: 意外的类型
	}
}

关系/比较运算符

  • >表示是否大于
  • >=表示是否大于等于
  • <表示是否小于
  • <=表示是否小于等于
  • ==表示是否等于
  • \！=表示是否不等于
    所有以关系运算符作为最终运算的表达式的结果一定是boolean类型。

自增减运算符

  • ++ 表示自增运算符，用于使得当前变量自身的数值加1的效果

  • - - 表示自减运算符，用于使得当前变量自身的数值减1的效果

  • 只能用于变量，常数不可以

重点：
前++，后++的区别


/*
    编程实现自增减运算符的使用
 */
public class SelfTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个int类型的变量并初始化
		int ia = 10;
		// 2.打印变量的数值
		System.out.println("ia = " + ia); // ia = 10
		
		System.out.println("---------------------------------------------");
		// 3.实现自增减运算符的使用
		// 表示让变量ia自身的数值加1，并覆盖该变量原来的数值   
		ia++;   // ia = ia + 1;
		System.out.println("ia = " + ia); // ia = 11
		
		// 表示让变量ia自身的数值加1，并覆盖该变量原来的数值  
		++ia;
		System.out.println("ia = " + ia); // ia = 12
		
		// 表示让变量ia自身的数值减1，并覆盖该变量原来的数值
		--ia;
		System.out.println("ia = " + ia); // ia = 11
		
		ia--;
		System.out.println("ia = " + ia); // ia = 10
		
		System.out.println("---------------------------------------------");
		// 4.简单的变换
		// 其中ia++这个整体叫做表达式   其中ia叫做操作数/变量       也就是ia++和ia表示不同的含义，因此所占的内存空间应该不同
		// 下面的代码是在打印表达式的结果
		// 后++表示先让变量ia的数值作为整个表达式的最终结果，然后再让ia变量自身的数值加1
		System.out.println(ia++);         // 10
		System.out.println("ia = " + ia); // 11
		// 前++表示先让变量自身的数值加1，然后再让变量的数值作为整个表达式的结果
		System.out.println(++ia);         // 12
		System.out.println("ia = " + ia); // 12
		
		System.out.println("---------------------------------------------");
		// 5.笔试考点
		int ib = ia++;
		System.out.println("ib = " + ib); // 12
		System.out.println("ia = " + ia); // 13
		int ic = ++ia;
		System.out.println("ic = " + ic); // 14
		System.out.println("ia = " + ia); // 14
		
		//                  14  + 16
		System.out.println(ia++ + ++ia);  // 30
		System.out.println("ia = " + ia); // 16
		
	}
}

逻辑运算符

· && 表示逻辑与运算符，相当于"并且"，同真为真，一假为假。

· || 表示逻辑或运算符，相当于"或者"，一真为真，同假为假。

· ! 表示逻辑非运算符，相当于"取反"，真为假，假为真。

· 逻辑运算符的操作数均为boolean表达式。

在这里插入图片描述

逻辑运算符的短路特性

  • 对于逻辑与运算符来说，若第一个表达式为假则结果为假，此时跳过第二个表达式；

  • 对于逻辑或运算符来说，若第一个表达式为真则结果为真，此时跳过第二个表达式；

/*
    编程实现逻辑运算符的使用
 */
public class LogicTest {
	
	public static void main(String[] args) {
		
		// 1.声明两个boolean类型的变量并初始化
		boolean b1 = true;
		boolean b2 = false;
		// 2.打印变量的数值
		System.out.println("b1 = " + b1); // b1 = true
		System.out.println("b2 = " + b2); // b2 = false
		
		System.out.println("---------------------------------------------");
		// 3.使用上述变量实现逻辑运算符的使用
		boolean b3 = b1 && b2;
		System.out.println("b3 = " + b3); // false
		System.out.println(b1 && b2); // false   并且
		System.out.println(b1 || b2); // true    或者
		System.out.println(!b1);  // false       取反
		System.out.println(!b2);  // true
		
		System.out.println("---------------------------------------------");
		// 4.测试一下短路特性
		int ia = 3;
		int ib = 5;
		// 对于逻辑与运算符来说，若第一个条件为假则整个表达式为假，此时跳过第二个表达式不执行
		boolean b4 = (++ia == 3) && (++ib == 5);
		System.out.println("b4 = " + b4); // false
		System.out.println("ia = " + ia); // 4
		System.out.println("ib = " + ib); // 5
		
		// 对于逻辑或运算符来说，若第一个条件为真则整个表达式为真，此时跳过第二个表达式不执行
		boolean b5 = (++ia == 5) || (++ib == 5);
		System.out.println("b5 = " + b5); // true
		System.out.println("ia = " + ia); // 5
		System.out.println("ib = " + ib); // 5
	}
}

赋值运算符

· = 表示赋值运算符，用于将=右边的数据赋值给=左边的变量，覆盖变量原来的数值。

· 赋值表达式本身也有值，其本身之值即为所赋之值。

· +=、 -=、 *=、 /=

条件/三目运算符

· 条件表达式? 表达式1: 表达式2

· 判断条件表达式是否成立，若成立则执行表达式1，否则执行表达式2 。

/*
    编程使用三目运算符查找最大值
 */

import java.util.Scanner; 
 
public class ThreeEyeTest {
	
	public static void main(String[] args) {
		
		// 1.提示用户输入两个整数并使用变量记录
		System.out.println("请输入两个整数：");
		Scanner sc = new Scanner(System.in);
		int ia = sc.nextInt();
		int ib = sc.nextInt();
		
		// 2.使用三目运算符找到最大值并打印
		int max = ia > ib? ia: ib;
		System.out.println("最大值是：" + max);
		System.out.println("最大值是：" + (ia > ib? ia: ib));
	}
}

移位运算符（了解）

· << 左移运算符，用于将数据的二进制位向左移动，右边使用0补充

· >> 右移运算符，用于将数据的二进制位向右移动，左边使用符号位补充

· >>> 表示逻辑右移运算符，用于将数据的二进制位向右移动，左边使用0补充。

/*
    编程实现移位运算符的使用
 */
public class MoveBitTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个byte类型的变量并初始化
		byte b1 = 13;
		// 2.打印变量的数值
		System.out.println("b1 = " + b1); // b1 = 13
		
		System.out.println("---------------------------------------------------");
		// 3.移位运算符的使用
		// 13的二进制是：... 0000 1101  => 左移1位的结果是：... 0001 1010 => 换算为十进制整数是：26
		//byte b2 = b1 << 1; // 错误: 不兼容的类型: 从int转换到byte可能会有损失   自动提升为int类型，也就是32位二进制
		byte b2 = (byte)(b1 << 1); 
		System.out.println("b2 = " + b2); // 26
		System.out.println(b1 << 1); // 26    左移1位相当于当前整数的数值*2
		System.out.println(b1 << 2); // 52    左移2位相当于当前整数的数值*4
		
		System.out.println("---------------------------------------------------");
		// 13的二进制是：... 0000 1101 => 右移1位的结果是：... 0000 0110 => 换算为十进制整数是：6
		System.out.println(b1 >> 1); // 6     右移1位相当于当前整数的数值/2
		System.out.println(b1 >> 2); // 3     右移2位相当于当前整数的数值/4
		
		System.out.println("---------------------------------------------------");
		// 逻辑右移   对于非负数来说，逻辑右移和右移的效果一致
		System.out.println(b1 >>> 2); // 3  
	}
}

位运算符（了解）

· & 表示按位与运算符，按照二进制位进行与运算，同1为1，一0为0.

· | 表示按位或运算符，按照二进制位进行或运算，一1为1，同0为0.

· ~ 表示按位取反运算符，按照二进制位进行取反，1为0，0为1.

· ^ 表示按位异或运算符，按照二进制位进行异或运算，同为0，不同为1.

/*
    编程实现位运算符的使用
 */
public class BitTest {
	
	public static void main(String[] args) {
		
		// 1.声明两个byte类型的变量并初始化
		byte b1 = 11;
		byte b2 = 13;
		// 2.打印变量的数值
		System.out.println("b1 = " + b1); // b1 = 11
		System.out.println("b2 = " + b2); // b2 = 13
		
		System.out.println("---------------------------------------------------");
		// 3.实现位运算符的使用
		// b1的二进制为： 0000 1011          
		// b2的二进制为： 0000 1101
		System.out.println( b1 & b2);  // 按位与：同1为1，一0为0      按位与后的二进制为：0000 1001  => 转为十进制是：9
		System.out.println( b1 | b2);  // 按位或：一1为1，同0为0      按位或后的二进制为：0000 1111  => 转为十进制是：15
		System.out.println( b1 ^ b2);  // 按位异或：相同为0，不同为1  按位异或的二进制为：0000 0110  => 转为十进制是：6
		System.out.println( ~ b1);     // 按位取反：1为0,0为1         按位取反的二进制为：1111 0100 
		// 二进制1111 0100转为十进制 => 先减1: 1111 0011 => 按位取反：0000 1100 => 转为十进制：12  => 添加负号：-12
	}
}

运算符的优先级

· ()的优先级极高。

· =的优先级极低。

· 若无法确认优先级，则使用()来确保即可

在这里插入图片描述

微毂
关注
专栏目录
基础语法——数据类型
weixin_74093130的博客
10-13 316
一.Python数据类型 Python中有七种数据类型，分别包括数字，布尔值，元组，字符串，列表，字典，集合。 1.数字(number) 包含int(整型数)，float(浮点数)，complex(复数)。 2.布尔值(boolean) 此种数据类型通常只有两个值(True和False),分别代表真和假，同时也可以用于数学运算(True代表“1”，False代表“0”)。布尔值的运算:(一) 与运算：只有两个布尔值都为 True 时，计算结果才为 True。
c语言数组表达式必须是常量值,关于数组：表达式在c ++中必须有一个常量值错误...
weixin_35907598的博客
05-19 3384
本问题已经有最佳答案，请猛点这里访问。Possible Duplicate:Is there a way to initialize an array with non-constant variables? (C++)号我有以下代码：vector> vinciP;int myLines = -1;myLines = drawPolyLineFile("vinci.dat", vinciP)...
Scala教程（一）
weixin_45524021的博客
10-29 310
简介： Scala是一门多范式(multi-paradigm)的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。 Scala运行在Java虚拟机上，并兼容现有的Java程序。 Scala源代码被编译成Java字节码，所以它可以运行于JVM上，并可以调用现有的Java类库。 ...
c语言问题（表达式必须含有常量值）
2201_75471897的博客
11-30 479
部分代码及问题如上图。
Java中声明相同变量
weixin_30914981的博客
05-04 622
Java中，在不嵌套的程序块中可以多次声明相同变量。如下段程序是合法的。 { int x=1; } { int x=2; } 在嵌套的程序块中不允许重复声明同名的变量。像下面这段程序在c和c++语言中是允许的，但在Java中是禁止的。 { int x=1; { 　　int x=2; 　} } 转载于:https://www.cnblogs.com/sky...
Java基础数据类型与运算符
qq_54850622的博客
04-16 832
安装环境： 1.jdk 2.idea JDK:java开发工具 JRE：Java运行环境 JVM：Java虚拟机 在一个Java文件中，如果存在public class 这样的类，那么类名一定要和文件名是相同的 一个Java文件中只能有一个public class CTRL+shift+/：注释 数据类型与运算符 变量和类型 1.整型变量 在 Java 中, 一个 int 变量占 4 个字节. 和操作系统没有直接关系 4个字节，32位。一个符号位，31表示数值位 ，表示的数据范围是 -2^31 -&g
java基础知识整理（2）——数据类型 与 运算符
Bnsdmm_lk的博客
12-22 381
一、注释 1、定义 用于对程序进行说明的文字，就可以看成是注释。 2、注释的格式          A：单行注释                   **举例：//我们好          B：多行注释 **举例： /*          我们都是                   好孩子                   */          C：文档注释    ...
Java SE-基础篇-运算符、随机数（Random）、方法、数组-入门级讲解
08-14
本文将介绍Java SE中的基础概念，包括运算符、随机数生成、方法以及数组，这些都是初学者入门Java编程需要掌握的关键知识点。 1. 运算符： - 转义字符：在Java中，`\`是一个转义字符，可以用于创建特殊字符，如`\n...
javaSE基础数据类型、运算符-6
11-10
在Java SE基础知识中，数据类型和运算符是编程的核心部分，它们构成了程序的基本逻辑和计算。以下是关于"javaSE基础数据类型、运算符-6"的相关知识点详解： 首先，我们来了解一下Java中的基本数据类型。Java语言有...
JAVA SE基础篇-资料整理
03-29
### JAVA SE基础篇-资料整理 #### JAVA历史特点、开发环境 Java 作为一种跨平台的高级编程语言，自1995年由Sun Microsystems公司推出以来，迅速成为了软件开发领域的重要工具之一。Java 最初的设计目的是为了实现...
OCA-Java-Certified-Associate-Java-SE-8-Programmer-Certification-Exam-1Z0-808指南：OCA Java认证的Java SE 8程序员考试1Z0-808认证指南，由Packt发行
02-14
1. **基础语法**：包括变量、数据类型、运算符、控制流语句（如if、for、while）、数组和字符串的使用，这些都是构建任何Java程序的基础。 2. **类与对象**：理解面向对象编程的基本原理，如封装、继承和多态。学习...
Objects-Java-SE-11-Developer-1Z0-819-OCP-Course ---第1部分
02-17
1. **Java基础**：首先，课程可能会回顾Java的基础知识，包括Java环境的搭建、编写与运行第一个Java程序，以及了解Java的语法结构，如变量、常量、数据类型和运算符。 2. **类与对象**：作为面向对象编程的核心，...
C/C++报错合集（3）：C++ 表达式必须含有常量值参数
最新发布
颜安青的小世界
04-26 531
报错原因：C++中不允许使用变量作为数组的长度去定义数组，必须为常量值才可以，C++中所有的内存需求都是在程序执行前通过定义的常量来确定的。
Java 8中的可重复注释
最佳 Java 编程
06-07 334
使用Java 8，您可以对声明或类型重复相同的注释。 例如，要注册一个类仅应由特定角色在运行时访问，则可以编写如下内容： @Role("admin") @Role("manager") public class AccountResource { } 注意，现在@Role重复了几次。 出于兼容性原因，重复注释存储在容器注释中，因此，您不仅需要编写两个注释，还需要编写两个@Role和...
c++报错：表达式必须含有常量值
蓝多多的小仓库
11-03 7569
很早之前的问题了，今天记录一下。 错误代码： char a[s.length()]; 因为代码中s.length()不是一个常数，需要运行时才能确定分配内存的大小。DEV-C++使用的编译器是GCC，它允许使用变量作为数组的长度定义数组。而VC的编译器不是GCC，它不允许这样做。 因此将代码修改为： //char a[s.length()]; char* a = new char[s.length()]; 并在使用完毕后释放内存： delete[]a; a = NULL; .
Java基础语法
SHARECLUB
09-10 264
基础语法： 关键字 有着特殊用途和意义的关键字，有大小写之分。 标识符 用来命名变量、常量，有大小写之分，以数子、字母、下划线_、美元符号$，不能以数字开头。 变量 变量：变量就好比一个用来装东西的盒子，不同类型的盒子装的东西不一样。盒子就是变量，不同类型的盒子就是不同类型的变量，里面的东西就是变量的值。 优秀码农的习惯： 1、当变量由多个单词组成时，第一个单词的首个字母小写，其余...
java语法及其类型
xiaoxuan2020的博客
10-28 182
@ 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写...
关于c++报错：表达式必须含有常量值 的原因及解决办法---动态分配内存
热门推荐
weixin_42638401的博客
04-01 11万+
原因： c++中不允许使用变量作为数组的长度定义数组，必须为常量值，c++中所有的内存需求都是在程序执行前通过定义的常量来确定的。 但是 我们有时候需要在程序运行时才能确定内存需求的变量值，例如所需值是由用户输入的等 比如在下面这个（不完整的）代码中，子函数中定义的二维数组的大小需要由形参frame来确定，frame.rows是一个变量 same2数组的内存大小是由kind决定的，erk...
6 后端开发基础-MVC模式&三层架构【思想】
weixin_42749734的博客
11-30 2897
一 MVC模式 1.1 JSP发展史 早期只有servlet，只能使用response输出html标签，非常麻烦。 后来有了JSP，简化了servlet开发；如果过度使用JSP，在JSP页面中写了大量的java代码和html标签，造成难于维护，难于分工协作的场景。 再后来为了弥补过度使用jsp的问题，我们使用servlet+jsp这套组合拳，利于分工协作。 1.2 MVC介绍 MVC设计模式： Model-View-Controller简写。 MVC是软件工程中的一种软件架构模式，它是一种分离业务逻辑
Java SE基础学习：变量、循环、数据类型与运算符
"这是关于Java SE基础知识的笔记，涵盖了变量、条件语句、...这份笔记覆盖了Java SE编程的多个基础要点，包括语法、数据类型、控制结构、输入输出以及面向对象编程的基础知识，对于初学者来说是一份宝贵的参考资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值