java零基础Ⅰ-- 3.运算符

最新推荐文章于 2024-06-12 23:05:18 发布
最新推荐文章于 2024-06-12 23:05:18 发布
阅读量177 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42469070/article/details/118873761
版权

java零基础Ⅰ-- 运算符

连接视频


运算符介绍

介绍

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

1、算术运算符
2、赋值运算符
3、关系运算符【比较运算符】
4、逻辑运算符
5、位运算符【需要二进制基础】
6、三元运算符



算术运算符

介绍

算术运算符是对数值类型的变量进行运算的，在Java程序中使用的非常多。


算术运算符一览

运算符运算范例结果
+正号+77
-负号b=11;-b-11
+加9+918
-减10-82
*乘7*856
/除9/91
%取模（取余）11%92
+ +
+ +		自增（前）：先运算后取值
自增（后）：先取值后运算		a=2;b=+ +a;
a=2;b=a+ +		a=3;b=3
a=3;b=2
- -
- -		自增（前）：先运算后取值
自增（后）：先取值后运算		a=2;b=- -a;
a=2;b=a- -		a=1;b=1
a=1;b=2
+字符串相加“zzp”+“123”“zzp123”

案例演示：

案例演示算术运算符的使用：ArithmeticOperator.java

1、+，-，*，/，%，++，- -，重点 /，%，+ +

取模（余）%公式： a % b = a - a / b * b

2、自增：+ +

作为独立的语句使用；
前 + + 和后 + + 都完全等价于 i=i+1;
作为表达式使用：
	前 + +： + +i 先自增后赋值
	后 + +： i+ + 先赋值后自增

3、- -，+，-，* 是一个道理，完全可以类推。

/**
 * 演示算术运算符的使用
 */
public class ArithmeticOperator{

	//编写一个main方法
	public static void main(String[] args){
		// 除号 / 使用
		System.out.println(10 / 4);//从数学来说看是2.5 实际在java中输出2 int类型
		System.out.println(10.0 / 4);//在java中输出2.5 因为10.0 是double类型
		double d = 10/4;//在java中 10/4 = 2 int类型, 最终2=>2.0 double类型
		System.out.println(d);//2.0
		
		System.out.println("============");
		
		// 取模（余） % 使用
		// 在 % 的本质 看一个公式 a % b = a - a / b * b
		System.out.println(10 % 3);//1

		// -10-(-10)/3*3 = -10 + 9 = -1
		System.out.println(-10 % 3);//-1
		// 10-10/(-3)*(-3) = 10 - 9 = 1
		System.out.println(10 % -3);//1
		// -10-(-10)/(-3)*(-3) = -10 + 9 = -1
		System.out.println(-10 % -3);//-1

		System.out.println("============");
		
		// ++ 自增的使用 作为独立的语句使用；
		int i = 10;
		i++;// 自增 等价于 i = i + 1;  i = 11; 
		++i;// 自增 等价于 i = i + 1;  i = 12;
		System.out.println("i=" + i);//i=12

		/*
			作为表达式使用：
			前 ++i： ++i 先自增后赋值
			后 i++： i++ 先赋值后自增 
		*/
		int j = 8;
		//int k = ++j;//等价 j=j+1;k=j;
		//System.out.println("k=" + k + "j=" + j);//k=9 j=9
		int k = j++;//等价 k=j;j=j+1;
		System.out.println("k=" + k + "j=" + j);//k=8 j=9
	}
}

面试题：

1、面试题1

int i = 1; // i -> 1
i = i++;//规则使用临时变量：(1)temp = i;(2) i = i+1;(3)i=temp; 
System.out.println(i);//1
问：结果是多少？为什么？

2、面试题2

int i = 1;
i = ++i;//规则使用临时变量：(1) i = i+1;(2)temp = i;(3)i=temp; 
System.out.println(i);//2

public class ArithmeticOperatorExercise01{

	//编写一个main方法
	public static void main(String[] args){

		// int i = 1;// i -> 1
		// i = i++;//规则使用临时变量：(1)temp = i;(2) i = i+1;(3)i=temp;
		// System.out.println(i);//1

		int i = 1;
		i = ++i;//规则使用临时变量：(1) i = i+1;(2)temp = i;(3)i=temp; 
		System.out.println(i);//2
	}

}

自增、自减

看看以下代码输出什么？

int i1 = 10;
int i2 = 20;
int i = i1 ++;//规则： i = i1 = 10; i1 = i1+1 = 11;
System.out.println("i=" + i);//10
System.out.println("i2=" + i2);//20
i = -- i2;//规则： i2 = i2 -1 = 19;i = i2 = 19;
System.out.println("i=" + i);//19
System.out.println("i2=" + i2);//19

public class ArithmeticOperatorExercise01{

	//编写一个main方法
	public static void main(String[] args){

		int i1 = 10;
		int i2 = 20;
		int i = i1 ++;//规则： i = i1 = 10; i1 = i1+1 = 11;
		System.out.println("i=" + i);//10
		System.out.println("i2=" + i2);//20
		i = -- i2;//规则： i2 = i2 -1 = 19;i = i2 = 19;
		System.out.println("i=" + i);//19
		System.out.println("i2=" + i2);//19
	}

}

练习：

1、假如还有59天放假，问：合xx个星期零xx天

2、定义一个变量保存华氏温度，华氏温度转换摄氏度的公式为：5/9*(华氏温度-100)，请求出华氏温度对应的摄氏温度。[234.5]

public class ArithmeticOperatorExercise02{

	//编写一个main方法
	public static void main(String[] args){
		//1.需求：
		//假如还有59天放假，问：合xx个星期零xx天
		//2.思路分析：
		//(1) 使用int 变量 days 保存天数
		//(2) 一个星期是7天 星期数weeks：days / 7 
		//				   零xx天leftDays：days % 7
		//(3) 输出
		//3.走代码
		int days = 59;
		int weeks = days / 7;//8
		int leftDays = days % 7;//3
		System.out.println(days+"天 合" + weeks + "个星期零" 
			+ leftDays + "天");//59天 合8个星期零3天

		//1.需求：
		//定义一个变量保存华氏温度，
		//华氏温度转换摄氏度的公式为：5/9*(华氏温度-100)，
		//请求出华氏温度对应的摄氏温度。[234.5]
		//2.思路分析：
		//(1) 先定义一个double huaShi 变量保存华氏温度
		//(2) 根据给出的公式，进行计算即可 5/9*(华氏温度-100)
		//    考虑数学公式和java语言的运算特性 5.0 /9*(华氏温度-100)
		//(3) 将得到的结果保存到double sheShi
		//3.走代码
		double huaShi = 234.6;
		double sheShi = 5.0 / 9 * (huaShi - 100);
		System.out.println("华氏温度" + huaShi +
			 " 对应的摄氏温度=" + sheShi);
	}
}

在这里插入图片描述



关系运算符

介绍

1、关系运算符的结果都是boolean类型，也就是要么是true，要么是false。

2、关系表达式 经常用在 if结构的条件中或循环结构中的条件中


关系运算符一览

运算符运算范例结果
==相等于8 == 7false
!=不等于8 != 7true
<小于8 <7false
>大于8 > 7true
<=小于等于8 <= 7false
>=大于等于8 >= 7true
instanceof检查是否是类的对象“zzp” instanceof Stringtrue

案例：

演示关系运算符的使用：

int a = 9;//提示：开发中，不可以使用 a,b a1,bc n1,n2..
int b = 8;
System.out.println( a > b );
System.out.println( a >= b );
System.out.println( a <= b );
System.out.println( a < b );
System.out.println( a == b );
System.out.println( a != b );
boolean flag = a > b;

public class RelationalOperator{

	//编写一个main方法
	public static void main(String[] args){

		int a = 9;//提示：开发中，不可以使用 a,b 
		int b = 8;
		System.out.println( a > b );//true
		System.out.println( a >= b );//true
		System.out.println( a <= b );//false
		System.out.println( a < b );//false
		System.out.println( a == b );//false
		System.out.println( a != b );//true
		boolean flag = a > b;
		System.out.println("flag=" + flag);//true
	}
}

细节说明

1）关系运算符的结果都是boolean类型，也就是要么是true，要么是false

2）关系运算符组成的表达式，我们称为关系表达式。a>b

3）比较运算符 “==” 不能写成 “=”



逻辑运算符

介绍

用于连接多个条件（多个关系表达式），最终的结果也是一个boolean类型值


逻辑运算一览

分为两组学习

1）短路与 && ，短路或 || ，取反 ！
2）逻辑与 & ，逻辑或 | ，^ 逻辑异或

aba&ba&&ba|b!aa^b
truetruetruetruetruefalsefalse
truefalsefalsefalsetruefalsetrue
falsetruefalsefalsetruetruetrue
falsefalsefalsefalsefalsetruefalse

说明逻辑运算规则：

  1. a&b：& 叫逻辑与：规则：当a 和 b 同时为true，则结果为true，否则为false
  2. a&&b：&& 叫短路与：规则：当a 和 b 同时为true，则结果为true，否则为false
  3. a|b：| 叫逻辑或，规则：当a 和 b，有一个为true，则结果为true，否则为false
  4. a||b：|| 叫短路或，规则：当a 和 b，有一个为true，则结果为true，否则为false
  5. !a：叫取反，或者非运算。当a为true，则结果为false，当a为false，结果为true
  6. a^b：叫逻辑异或，当a 和 b 不同时，则结果为true，否则为false

&& 和 & 基本规则

名称语法特点
短路与 &&条件1 && 条件2两个条件都为true，结果为true，否则为false
逻辑与 &条件1 & 条件2两个条件都为true，结果为true，否则为false

&& 和 & 使用区别

1、&&短路与：如果第一个条件为false，则第二个条件则不会判断，最终结果为false。

2、& 逻辑与：不管第一个条件是否为false，第二个条件都要判断，效率低

3、开发中，我们使用的基本短路与 &&，效率高

案例演示：

/**
 * 演示逻辑运算符的使用
 */ 
public class LogicOpertaor01{

	//编写一个main方法
	public static void main(String[] args){

		//&& 短路与  和 & 案例演示
		int age = 50;
		if(age > 20 && age < 90){ //true && true => true
			System.out.println("OK100");//
		}

		//& 逻辑与使用
		if(age > 20 && age < 90){ //true && true => true
			System.out.println("OK200");//
		}

		//区别
		int a = 4;
		int b = 9;
		//对于 &&短路与而言，如果第一个添加为false，后面条件的不再判断
		// if(a < 1 && ++b < 50){ //false  => false
		// 	System.out.println("OK300");
		// }
		// System.out.println("a=" + a + " b=" + b);//a=4 b=9
		//对于 &逻辑与而言，如果第一个添加为false，后面条件仍然会判断
		if(a < 1 & ++b < 50){ //false & true => false
			System.out.println("OK300");
		}
		System.out.println("a=" + a + " b=" + b);//a=4 b=10
	}
}

|| 和 | 基本规则

名称语法特点
短路或 ||条件1 || 条件2两个条件只要有一个成立，结果为true，否则为false
| 逻辑或条件1 | 条件2只要有一个条件成立，结果为true，否则为false

|| 和 | 使用区别

1、|| 短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true，效率高

2、| 逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低

3、开发中，我们基本使用 ||

案例演示：

/**
 * 演示 || 短路或 | 逻辑或 使用
 */ 
public class LogicOpertaor02{

	//编写一个main方法
	public static void main(String[] args){

		//|| 短路或  和 | 逻辑或 案例演示
		// || 规则：两个条件只要有一个成立，结果为true，否则为false
		int age = 50;
		if(age > 20 || age < 30){ //true || false => true
			System.out.println("OK100");//OK100
		}

		// | 逻辑或
		// | 规则：只要有一个条件成立，结果为true，否则为false
		if(age > 20 | age < 30){ //true || false => true
			System.out.println("OK200");//OK200
		}

		int a = 4;
		int b = 9;
		//区别：
		//(1)|| 短路或：如果第一个条件为true，
		//      则第二个条件不会判断，最终结果为true，效率高
		// if(a > 1 || ++b > 4){ //true || true  => true
		// 	System.out.println("OK300");
		// }
		// System.out.println("a=" + a + " b=" + b);//a=4 b=9
		
		//(2)| 逻辑或：不管第一个条件是否为true，
		//     第二个条件都要判断，效率低
		if(a > 1 | ++b > 4){ //true || true  => true
			System.out.println("OK400");
		}
		System.out.println("a=" + a + " b=" + b);//a=4 b=10
	}
}

!取反 基本规则

名称语法特点
! 非（取反）!条件如果添加本身成立，结果为false，否则为true

^案例演示

a^b：叫逻辑异或，当a 和 b 不同时，则结果为true，否则为false

^逻辑异或，System.out.println((4 < 1) ^ (6 > 3));//false ^ true ⇒ true

/**
 * !和^案例演示
 */ 
public class InverseOperator{

	//编写一个main方法
	public static void main(String[] args){

		// ! 操作是取反 true ==> false; false ==> true
		System.out.println( 60 > 20);//true
		System.out.println( !(60 > 20));//false

		//a^b：叫逻辑异或，
		//当a 和 b 不同时，则结果为true，否则为false
		// boolean b = (10 > 1) ^ ( 3 < 5);// true ^ true => false
		// System.out.println("b=" + b);//false
		boolean b = (10 > 1) ^ ( 3 > 5);// true ^ false => true
		System.out.println("b=" + b);//true
	}
}

练习题：
写下面的输出结果：

int x = 5;
int y = 5;

//注意: 
//(1)x++先比较: 5 == 6 = false;
//(2)后自增: x =  x + 1 = 6

if(x++ == 6 & ++y == 6){//逻辑与 false & true ==> false 
	x = 11;
}
System.out.println("x=" + x + " y=" + y);//x=6 y=6

int x = 5,y = 5;
if(x++ == 6 && ++y == 6){//短路与  false && true ==> true
	x = 11;
}
System.out.println("x=" + x + " y=" + y);//x=6 y=5

int x = 5,y = 5;
if(x++ == 5 | ++y == 5){//逻辑或  true | false ==> true
	x = 11;
}
System.out.println("x=" + x + " y=" + y);//x=11 y=6

int x = 5,y = 5;
if(x++ == 5 || ++y == 5){//短路或  true || false ==> true
	x = 11;
}
System.out.println("x=" + x + " y=" + y);//x=11 y=5

请写输出下面结果：

boolean x = true;
booelan y = false;
short z = 46;

// z++ == 46; 
//	(1) z == 46 ==> true
//	(2) z = z +1 = 47
// y = true
if( (z++ == 46 ) && (y = true) ){//短路与 true && true ==> true 
	z ++;// z ++ =  47 + 1 = 48
}

// x = false
// ++z == 49; 
//	(1) z = z + 1 = 49
// 	(2) z == 49 ==> true 
if( (x = false) || (++z == 49) ){//短路或 false  || true ==> true 
	z ++;// z++ = 49 + 1 = 50
}
System.out.println("z=" + z);//z=50



赋值运算符

介绍

赋值运算符就是将某个运算后的值，赋给指定的变量


赋值运算符的分类

基本赋值运算符 =

复合赋值运算符

+= ， -= ，、/= , %= 等，重点讲解一个 += ，其他一个道理
a += b; [等价：a = a + b;]
a -= b; [等价：a = a - b;]

案例演示

案例演示赋值运算符的基本使用。AssignOperator.java

1）赋值基本案例 [ int num1 = 10;]
2）+= 的使用

//演示赋值运算符的使用
public class AssignOperator{

	//编写一个main方法
	public static void main(String[] args){

		// 
		int n1 = 10;
		n1 += 4;// n1 = n1 + 4;
		System.out.println(n1);//14

		n1 /= 3;// n1 = n1 / 3;
		System.out.println(n1);//4
	}

}

赋值运算符的特点

1）运算顺序从右到左

int num = a + b + c;

2）赋值运算符的左边 只能是变量，右边 可以是变量、表达式、常量值

int num = 20;
int num2 = 78 * 34 - 10;
int num3 = a;

3）复合赋值运算符等价于下面的结果：

比如：a += 3; 等价于： a = a + 3; 其他类推

4）复合赋值运算符会进行类型转换。

byte b = 2; b += 3; b ++;

public class AssignOperator{

	//编写一个main方法
	public static void main(String[] args){
		//复合赋值运算符会进行类型转换
		byte b = 3;
		b += 2;// 等价: b = (byte)(b + 2);
		b++;// 等价: b = byte)(b + 1);
		System.out.println(b);// 5
	}
}



三元运算符

基本语法

条件表达式 ？ 表达式1 ： 表达式2；

运算规则：
1、如果条件表达式为true，运算后的结果是表达式1；
2、如果条件表达式为false，运算后的结果是表达式2；

案例演示

int a = 10;
int b = 99;
int result = a > b ? a++ : b++;

//三元运算符的使用
public class TernaryOperator{

	//编写一个main方法
	public static void main(String[] args){

		int a = 10;
		int b = 99;
		//(1)a > b ==> false 
		//(2) b--, 先返回 b 的值在 b-1
		//(3) 最后返回结果是 99
		int result = a > b ? a++ : b--;
		System.out.println("a=" + a);// 10
		System.out.println("b=" + b);// 98
		System.out.println("result=" + result);// 99
	}
}

使用细节

1、表达式1 和 表达式2 要为可以赋值接收变量的类型（或可以自动转换/或者强制转换）

2、三元运算符可以转成 if – else 语句

int res = a > b ? a++ : --b;
//等价于下面示例
if( a > b) res = a ++;
else res = --b;

//三元运算符细节
public class TernaryOperatorDetail{

	//编写一个main方法
	public static void main(String[] args){

		//表达式1 和 表达式2 要为可以赋值接收变量的类型（或可以自动转换/或者强制转换）
		int a = 3;
		int b = 8;
		//int c = a > b ? a : b;//ok
		//int c = a > b ? 1.1 : 3.4;//编译错误 double --> int 
		//int c = a > b ? (int)1.1 : (int)3.4;//ok
		double c = a > b ? a : b + 3;// ok int --> double
		System.out.println(c);// 11.0
	}
}

练习：

案例：实现三个数的最大值

public class TernaryOperatorExercise{

	//编写一个main方法
	public static void main(String[] args){

		//实现三个数的最大值
		int n1 = 55;
		int n2 = 33;
		int n3 = 123;
		//思路
		//1.先得到 n1 和 n2 中最大的数，保存到 max1
		//2.然后再 求出 max1 和 n3 中的最大的数，保存到 max2
		int max1 = n1 > n2 ? n1 : n2;
		int max2 = max1 > n3 ? max1 : n3;
		System.out.println("最大数=" + max2);//123

		// 使用一条语句实现
		int max = (1 > n2 ? n1 : n2) > n3 ? 
						(n1 > n2 ? n1 : n2) : n3;			
		System.out.println("最大数=" + max);//123
	}
}



运算符优先级

1、运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下面表格，上一行运算符总优先与下一行

.   ()   {}   ;   ,
R–>L++   - -   ~   !(data type)
L–>R*   /   %
L–>R+   -
L–>R<<   >>   >>>   位移
L–>R<   >   <=   >=   instanceof
L–>R==   !=
L–>R&
L–>R^
L–>R|
L–>R&&
L–>R||
L–>R?   :
R–>L=   *=   /=   %=
+=   -=   <<=   >>=
>>>=   &=   ^=   |=

2、只有单目运算符、赋值运算符是右向左运算的。

梳理小结：

1）() , {} 等；【int a=2, b=5】
2）单目运算：++ - -
3）算术运算符：* / %
4）位移运算符：<< >>
5）比较运算符：< > <= >= instanceof
6）逻辑运算符：& | && ||
7）三元运算符：? :
8）赋值运算符：+= -= <<= >>=



标识符的命名规则和规范

标识符概念

1、Java 对各种变量、方法和类等命名时使用的字符序列称为标识符

2、凡是自己可以起名字的地方都叫 标识符。【int num = 90;】


标识符的命名规则（必须遵守）

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

2、数字不可以开头。【int 3ac = 1;//错误】

3、不可以使用关键字和保留字，但能包含关键字和保留字。

4、Java 中严格区分大小写，长度无限制。【int totalNum = 10; int n = 90;】

5、标识符不能包含空格。【int a b = 90;//错误】

判断下面变量名是否正确

zzp     //正确
zzp123  //正确
1zzp 	//错误 不能以数字开头
h-s 	//错误 不能有 -
x h     //错误 有空格
h$4 	//正确
class 	//错误 class关键字
int 	//错误 int关键字
double  //错误 double关键字
public  //错误 public关键字
static  //错误 static关键字
goto    //错误 goto保留字
stu_name //正确

标识符命名规范

1、包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.zzp.spring

2、类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz【大驼峰】，比如：TankShotGame

3、变量名、方法名：多单词组成时，第一个字母首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz【小驼峰，简称 驼峰法】，比如：tankShotGame

4、常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ，比如：定义一个所得税 TAX_RATE


关键字

关键字的定义和特点

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

特点：关键字红所有字母都为小写

用于定义数据类型的关键字：

classinterfaceenumbyteshort
intlongfloatdoublechar
booleanvoid

用于定义数据类型值的关键字：

truefalsenull

用于定义流程控制的关键字：

ifelseswitchcasedefault
whiledoforbreakcontinue
return

用于定义访问权限修饰符的关键字：

privateprotectedpublic

用于定义类，函数，变量修饰符的关键字：

abstractfinalstaticsynchronized

用于定义类与类之间关系的关键字：

extendsimplements

用于定义建立实例及引用实例，判断实例的关键字：

newthissuperinstanceof

用于异常处理的关键字：

trycatchfinallythrowthrows

用于包的关键字：

packageimport

其他修饰符关键字：

nativestrictfptransientvolatileassert

保留字

介绍

Java 保留字：现有Java版本尚为使用，但可以版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字

byValue、cast、future、generic、inner、operator、outer、rest、var、goto、const。



键盘输入语句

介绍

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句类获取。需要一个 扫描器（对象），就是 Scanner


步骤：

1）导入该类的所在包，java.util.*

2）创建该类的对象（声明变量）

3）调用里面的功能

案例

要求：可以从控制台接收用户信息。【姓名，年龄，薪水】

import java.util.Scanner;//表示把 java.util下的Scanner类导入

public class Input{

	//编写一个main方法
	public static void main(String[] args){
		//演示接收用户的输入
		//步骤：
		// Scanner类 表示 简单的文本扫描器，在java.util 包
		//1、引入/引入 Scanner类所在的包
		//2、创建 Scanner 对象, new 创建一个对象
		// 	myScanner 就是 Scanner类创建的对象
		Scanner myScanner = new Scanner(System.in);
		//3、接收用户输入的值,使用相关的方法
		System.out.println("请输入名字");

		//当程序执行到 next 方法时，会等待用户输入...
		String name = myScanner.next();//接收用户输入的字符串
		System.out.println("请输入年龄");
		int age = myScanner.nextInt();//接收用户输入 int
		System.out.println("请输入薪水");
		double sal = myScanner.nextDouble();//接收用户输入 double
		System.out.println("人的信息如下：");
		System.out.println("名字=" + name + " 年龄=" 
						+ age + " 薪水=" + sal);
	}
}

在这里插入图片描述



进制

进制介绍

对于整数，有四种表示方式：

1、二进制：0,1，满2进1，以0b 或 0B开头

2、十机制：0-9，满10进1。

3、八进制：0-7，满8进1，以数字0开头表示。

4、十六进制：0-9 及 A（10）-F（15），满16进1，以0x 或 0X 开头表示。此处的A-F不区分大小写。

举例说明：

int n1 = 0b1010;//二进制 以0b 或 0B开头
int n2 = 1010;//十进制 
int n3 = 01010;//八进制 以数字0开头表示
int n4 = 0x10101;//十六进制 以0x 或 0X 开头表示

//演示四种进制
public class BinaryTest{

	//编写一个main方法
	public static void main(String[] args){
		// n1 二进制 以0b 或 0B开头
		int n1 = 0b1010;
		// n2 十进制 
		int n2 = 1010;
		// n3 八进制 以数字0开头表示
		int n3 = 01010;
		// n4 十六进制 以0x 或 0X 开头表示
		int n4 = 0x10101;
		System.out.println("n1=" + n1);//10
		System.out.println("n2=" + n2);//1010
		System.out.println("n3=" + n3);//520
		System.out.println("n4=" + n4);//65793
	}
}

进制的图示

十进制十六进制八进制二进制
0000
1111
22210
33311
444100
555101
666110
777111
88101000
99111001
10A121010
11B131011
12C141100
13D151101
14E161110
15F171111
16102010000
17112110001



进制的转换（基本功）

进制转换介绍

第一组：

  1. 二进制转十进制
  2. 八进制转十进制
  3. 十六进制转十进制

第二组：

  1. 十进制转二进制
  2. 十进制转八进制
  3. 十进制转十六进制

第三组：

  1. 二进制转八进制
  2. 二进制转十六进制

第四组：

  1. 八进制转二进制
  2. 十六进制转二进制

其他进制转十进制

  1. 二进制转十进制
  2. 八进制转十进制
  3. 十六进制转十进制

二进制转成十进制示例

规则：从最低位（右边）开始，将每个上的数提取出来，乘以2的（位数-1）次方，然后求和。

案例：请将 0b1011 传成十进制

# 从右边 开始<font color='red'>22</font>
0b1011 = 1*2的(1-1)次方 + 1*2的(2-1)次方 + 1*2的(3-1)次方 +  1*2的(4-1)次方

# 从右边 开始
0b1011
= 1 * 2的(1-1)次方 + 1 * 2的(2-1)次方 + 0 * 2的(3-1)次方 + 1 * 2的(4-1)次方
= 1 + 2 + 0 + 8
= 11


八进制转成十进制示例

规则：从最低位（右边）开始，将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和

案例：将 0234 转成十进制的数

# 从右边 开始 八进制
0234
= 4 * 8^0 + 3 * 8^1 + 2 * 8^2
= 4 + 24 + 128
= 156


十六进制转成十进制示例

规则：从最低位（右边）开始，将每个位上的数提取出来，乘以16的（位数-1）次方，然后求和

案例：请将 0x23A 转成十进制的数

# 从右边 开始 十六进制
0x23A
= 10 * 16^0 + 3 * 16^1 + 2 * 16^2
= 10 + 48 + 512
= 570

练习：
0b110001100 转成 十进制

0b110001100
= 0 * 2^1 + 0 * 2^1 + 1 * 2^2 + 1 * 2^3 + 0 * 2^4 + 0 * 2^5 + 0 * 2^6 + 1 * 2^7 + 2 * 2^8
= 0 + 0 + 4 + 8 + 0 + 0 + 0 + 128 + 256
= 396

02456 转成 十进制

02456
= 6 * 8^0 + 5 * 8^1 + 4 * 8^2 + 2 * 8^3
= 6 + 40 + 256 + 1024
= 1326

0xA45 转成 十进制

0xA45
= 5 * 16^0 + 4 * 16^1 + 10 * 16^2
= 5 + 64 + 2560
= 2629


十进制转换成二进制

规则：将该数不断除以2，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制。

案例：请将 34 转换成二进制

34 / 2 = 17 余 0
17 / 2 = 8  余 1
8 / 2 = 4   余 0
4 / 2 = 2   余 0
2 / 2 = 1   余 0 
1 / 2 = 0   余 1
结果：34转换成二进制= 0B0010 0010

十进制转换成八进制

规则：将该数不断除以8，直到商为0为止，然后将每步得到的余数倒过来，就是对应的八进制

案例：请将 131 转成八进制

131 / 8 = 16 余 3
16 / 8 = 2   余 0
2 / 8 = 0    余 2
结果：131转成八进制=0203

十进制转换成十六进制

规则：将该数不断除以16，直到商为0为止，然后将每步得到的余数倒过来，就是对应的十六进制。

案例：请将 237 转成 十六进制

237 / 16 = 14 余 13 ->D
14 / 16 = 0   余 14 ->E
结果： 237转成十六进制 =0xED

练习：
123 转成 二进制

123 / 2 = 61 余 1
61 / 2 = 30  余 1
30 / 2 = 15  余 0
15 / 2 = 7   余 1
7 / 2 = 3    余 1
3 / 2 = 1    余 1
1 / 2 = 0    余 1
结果：123转成 二进制=0B0111 1011

678 转成八进制

678 / 8 = 84 余 6
84 / 8 = 10  余 4
10 / 8  = 1  余 2
1 / 8 = 0    余 1
结果：678转成八进制=01246

8912 转成十六进制

8912 / 16 = 557 余 0
557 / 16 = 34   余 13  ->D
34 / 16 = 2     余 2
2 / 16 = 0      余 2
结果：8912转成十六进制=0x22D0

二进制转换成八进制、十六进制

二进制转换成八进制

规则：从低位（右边）开始，将二进制每三位一组，转成对应的八进制即可。

案例：请将 0b11010101 转换成八进制

0b 011(3) 010(2) 101(5)
=3 2 5
最终结果：0325


### 二进制转换成十六进制

规则：从低位（右边）开始，将二进制数每四位一组，转成对应的十六进制数即可。

案例：请将 0b11010101 转成十六进制

0b 1101(13) 0101(5)
= 13 5
最终结果：0xD5

练习：
请将 0b11100101 转成 八进制

0b 011(3) 100(4) 101(5)
最终结果：0345

请将 0b11100101 转成 十六进制

0b 1110(14) 0101(5)
最终结果：0xE5


八进制、十六进制转成二进制

八进制转换成二进制

规则：将八进制数每1位，转成对应的的一个3位的二进制数即可

案例：请将 0237 转成二进制

0 237
2: 010
3: 011
7: 111
最终结果：0b1001 1111

十六进制转换成二进制

规则：将八进制数的每一位，转换对应的4位的一个二进制即可。

案例：请将0x23B转换成二进制

0x23B
2: 0010
3: 0011
B: 1011
最终结果：0b0010 0011 1011

练习：
请将 01230 转成二进制

01230
1: 001
2: 010
3: 011
0: 000
最终结果：0b0010 1001 1000

请将 0xAB29 转成二进制

0xAB29
A: 1010
B: 1011
2: 0010
9: 1001
最终结果：0b1010 1011 0010 1001



位运算思考题

1） 请看下面代码段，回答a,b,c,d,e结果是多少?

public static void main(String[] args)
{
	//思路：
	// （1）获取 1 的原码： 00000000 00000000 00000000 0000 0001
	// 正数的原码，反码、补码都一样（三码合一）
	// （2）>>2向右移2位 00000000 00000000 00000000 0000 0000 01(舍弃)
	// 本质是: 1 / 2 / 2 = 0
	//(3)最终结果： a = 0;
	int a = 1 >> 2;//向右移2位
	
	//思路：
	//(1)获取 -1 的原码：10000000 00000000 00000000 0000 0001
	//		 转换为反码：11111111 11111111 11111111 1111 1110
	//	转换为补码（反码+1）：11111111 11111111 11111111 1111 1111
	//(2) >>2算术右移（补码）： 11111111 11111111 11111111 1111 1111 11(舍弃)
	//		 >> 低位溢出，符号位不变，并用符号位补溢出的高位
	// 补码转换为反码(-1)：11111111 11111111 11111111 1111 1110
	// 反码转换原码：10000000 00000000 00000000 0000 0001
	//(3) 最终结果： b = -1;
	int b = -1 >> 2;//算术右移
	
	//思路：
	//(1)获取1的原码：00000000 00000000 00000000 0000 0001
	// (2) <<2算术左移: 00000000 00000000 00000000 0000 0100
	//  本质是: 1 * 2 * 2 = 4
	//(3) 最终结果： c = 4;
	int c = 1 << 2;//算术左移
	
	//思路：
	//(1)获取-1的原码：10000000 00000000 00000000 0000 0001
	//		 转换为反码：11111111 11111111 11111111 1111 1110
	//	转换为补码（反码+1）：11111111 11111111 11111111 1111 1111
	//(2) <<2算术右移（补码）： 11111111 11111111 11111111 1111 1100
	//		符号位不变，低位补0
	// 补码转换为反码(-1)：11111111 11111111 11111111 1111 1011
	// 反码转换原码：10000000 00000000 00000000 0000 0100
	//(3) 最终结果： d = -4;
	int d = -1 << 2;
	
	//思路：
	// （1）获取3的原码：00000000 00000000 00000000 0000 0011
	// (2)>>>无符号右移2位：00000000 00000000 00000000 0000 0000 11(舍弃)
	//(3) 最终结果： e = 0;
	int e = 3 >>> 2;// >>>无符号右移2位
	
	//a,b,c,d,e结果是多少
	System.out.println("a="+ a);//0
	System.out.println("b=" + b);//-1
	System.out.println("c=" + c);//4
	System.out.println("d="+ d);//-4
	System.out.println("e=" + e);//0
}

2）请回答在java中，下面的表达式的结果是：（位操作）

//思路：
//（1）获取2的原码：00000000 00000000 00000000 0000 0010
//(2) ~2区分操作 11111111 11111111 11111111 1111 1101 补码
// 补码转反码-1 ： 11111111 11111111 11111111 1111 1100
// 反码转原码： 10000000 00000000 00000000 0000 0011
//(3) 最终结果： -3;
~2 = -3;// 按位取反

//思路:
//(1)获取2的原码：00000000 00000000 00000000 0000 0010
//(2))获取3的原码：00000000 00000000 00000000 0000 0011
//(3) &按位与操作：00000000 00000000 00000000 0000 0010
// 最终结果： 2
2 & 3 = 2;// 2 按位与

//思路:
//(1)获取2的原码：00000000 00000000 00000000 0000 0010
//(2))获取3的原码：00000000 00000000 00000000 0000 0011
//(3) |按或或操作：00000000 00000000 00000000 000 00011
// 最终结果： 3
2 | 3 =3;

//思路:
//(1)获取-5的原码：10000000 00000000 00000000 0000 0101
// 转换为反码： 11111111 11111111 11111111 1111 1010
// 反码转换为补码（+1）：11111111 11111111 11111111 1111 1011
//(2) ~取反操作：00000000 00000000 00000000 0000 0100
// 最终结果： 4
~ -5 = 4;

//思路:
//(1)获取13原码: 00000000 00000000 00000000 0000 1101
//(2)获取7原码： 00000000 00000000 00000000 0000 0111
//(3) &按位与操作：00000000 00000000 00000000 0000 0101
// 最终结果： 5
13 & 7 = 5;

//思路:
//(1)获取5的原码：00000000 00000000 00000000 0000 0101
//(2))获取4的原码：00000000 00000000 00000000 0000 0100
//(3) |按或或操作：00000000 00000000 00000000 0000 0101
// 最终结果： 5
5 | 4 = 5;

//思路:
//(1)获取-3的原码：10000000 00000000 00000000 0000 0011
// 转换反码：11111111 11111111 11111111 1111 1100
// 转换补码+1: 11111111 11111111 11111111 1111 1101
//(2)获取3的原码: 00000000 00000000 00000000 0000 0011
//(3) ^按位异或操作：11111111 11111111 11111111 1111 1110 补码
// 转换反码 -1：11111111 11111111 11111111 1111 1101
// 转换为原码：10000000 00000000 00000000 0000 0010
// 最终结果： -2
-3^3 = -2;//^按位异或 3



二进制在运算中的说明

1、二进制是逢2进位制，0、1是基本算符。

2、现代的电子计算机技术全部采用的是二进制，因为它只使用0、1两个数字符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制（Binary）数用0和1两个数字及其组合来表示任何数。进位规则是“逢2进1”，数字1在不同的位上代表不同的值，按从右到左的次序，这个值以二倍递增。



原码、反码、补码(重点、难点)

对于有符号的而言：

1、二进制的最高位的符号位：0 表示正数，1表示负数（口诀：0 -> 0 1 -> -）

2、正数的原码，反码、补码都一样（三码合一）

3、负数的反码 = 它的原码符号位不变，其它位取反（0 -> 1, 1 -> 0）

4、负数的补码 = 它的反码 + 1，负数的反码 = 负数的补码 -1

5、0 的反码，补码都是0

6、java没有无符号数，换言之，java中的数都是有符号的

7、在计算机运算的时候，都是以补码的方式来运算的

8、当我们看运算结果的时候，要看他的原码



位运算符

java中有7个位运算（&、|、^、~、>>、<<和 >>>）

分别是 按位与&、按位或|、按位异或^、按位取反~，它们的运算规则是：

名称描述
按位与&两位全为1，结果为1，否则为0
按位或|两位有一个为1，结果为1，否则为0
按位异或^两位一个为0，一个为1，结果为1，否则为0
按位取反~0 --> 1 ,1 --> 0

比如： 2&3 ？ ~-2 ？ 2|3 ？ 2^3 ?

//位运算
public class BitOperator{

	//编写一个main方法
	public static void main(String[] args){

		//推导过程
		//1.先得到 2的补码 
		//       => 2的原码 00000000 00000000 00000000 0000 0010
		//          2的补码 00000000 00000000 00000000 0000 0010
		//2.3的补码 ==> 3的源码 00000000 00000000 00000000 00000011
		//    			3的补码 00000000 00000000 00000000 0000 0011
		//3.按位&
		//	2的补码 00000000 00000000 00000000 0000 0010
		//	3的补码 00000000 00000000 00000000 0000 0011
		//         00000000 00000000 00000000 0000 0010  & 运算后的补码
		//    运算的原码 也是 00000000 00000000 00000000 0000 0010
		//   	结果就是
		System.out.println(2&3);//2


		//推导过程
		//1.先得到 -2的原码	10000000 00000000 00000000 0000 0010
		//2. -2的 反码 		11111111 11111111 11111111 1111 1101
		//3. -2的补码(反码+1)11111111 11111111 11111111 1111 1110
		//4. ~ -2取反操作	00000000 00000000 00000000 0000 0001
		//5.运算后的源码 就是 00000000 00000000 00000000 0000 0001  => 1
		System.out.println(~ -2);//1

		//推导过程
		//1.先得到2的补码：	00000000 00000000 00000000 0000 0010
		//2.~2 按位取反 补码	11111111 11111111 11111111 1111 1101
		//3. 运算后的反码	 负数的反码 = 负数的补码 -1	
		//					11111111 11111111 11111111 1111 1100
		//4. 运算后的原码    它的原码符号位不变，其它位取反（0 -> 1, 1 -> 0）
		//					10000000 00000000 00000000 0000 0011 ==> -3
		System.out.println(~2);//-3

		//推导过程
		//1.获取得到2的补码 	00000000 00000000 00000000 0000 0010
		//2.获取得到3的补码	00000000 00000000 00000000 0000 0011
		//     按位或|		00000000 00000000 00000000 0000 0011
		//运算的原码 也是 	00000000 00000000 00000000 0000 0011
		System.out.println(2|3);//3

		//推导过程
		//1.获取得到2的补码 	00000000 00000000 00000000 0000 0010
		//2.获取得到3的补码	00000000 00000000 00000000 0000 0011
		//		按位异或^	00000000 00000000 00000000 0000 0001
		//运算的原码 也是 	00000000 00000000 00000000 0000 0001
		System.out.println(2^3);//1
	}
}

还有3个位运算符 >>，<< 和 >>>

运算规则：

1、算术右移 >>：低位溢出，符号位不变，并用符号位补溢出的高位

2、算术左移 <<：符号位不变，低位补0

3、 >>> 逻辑右移也叫无符号右移，运算规则是：低位溢出，高位补0

4、特别说明：没有 <<< 符号

案例：BitOperator02.java

//1 => 00000000 00000000 00000000 0000 0001
//>>2: 00000000 00000000 00000000 0000 0000 01
// 本质是= 1 / 2 / 2 = 0
int a = 1 >>2;//算术右移
//1 => 00000000 00000000 00000000 0000 0001
//<<2: 00000000 00000000 00000000 0000 0100
// 本质是= 1 * 2 * 2 = 4
int c = 1 <<2;//算术左移

public class BitOperator02{

	//编写一个main方法
	public static void main(String[] args){

		int a = 1 >>2;
		int c = 1 <<2;
		System.out.println("a="+ a);//0
		System.out.println("c="+ c);//4
		int b = 4 <<3;
		// 0000 0100 
		// <<3 0010 0000
		// 4 * 2^3
		System.out.println("b="+ b);//32
		System.out.println(15 >> 2);//15/2^2 =3 
	}
}



作业

1、计算下列表达式的结果

10 / 3 = ?;//3
10 / 5 = ?;//2
10 % 2 = ?;//0
//a % b 当 a 是小数时，公式 = a - (int)a / b * b
//注意：有小数运算，得到的结果是近似值
-10.5 % 3 = ?;//-10.5 - (-10)/3*3 = -10.5 - (-9) = -1.5
-10.4 % 3 = ?;//-10.4 - (-10)/3*3 = -10.5 - (-9) = -1.40000000004

2、试说出下面代码的结果

int i = 66;
//执行 i = i +1 => 67 ==> i = 67
// 67 + 67 = 134
System.out.println(++i + i);//134

3、在Java中，以下赋值语句正确的是（C、D）；

A) int num1 = (int) "18";//错误 应该使用 Integer.parseInt("18")
B) int num2 = 18.0; //错误 double --> int
C) double num3 = 3d;//正确 double 变量尾可加 D 或者 d 或不加
D) double num4 = 8;//正确 int --> double 
E) int i = 48;char cn = i + 1;//错误  i + 1 => int -> char
F) byte b = 19;short s = b + 2;//错误 b + 2=> int --> short

4、试写出将String转换成double类型的语句，以及将char类型转换成String的语句，举例说明即可

String str = "18.8";//注意，字符串要可以被转成 double
double d1 = Double.parseDouble(str);

char c1 = '中';
String str2 = c1 + "";
weixin_42469070
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第2章-JAVA语言基础.ppt
11-23
JAVA语言基础是Java编程语言的基础知识，包括变量、数据类型、运算符、表达式、赋值语句、强制类型转换、逻辑运算符、位运算符、三目条件运算符、复杂赋值运算符等。 变量和数据类型 在JAVA语言中，变量是存储数据...
第三课 java算术运算
weixin_47067063的博客
11-03 334
java算术运算 文章目录java算术运算一、数据类型中补充的小问题1、定义long、float时要注意2、byte值的问题3、数据类型转换之默认转换4、java语言中的字符char可以存储一个中文汉字吗？为什么？二、运算符*运算符的优先级1、算术运算符2、赋值运算符3、比较运算符4、逻辑运算符5、位运算符6、三目运算符三、键盘的录入 一、数据类型中补充的小问题 1、定义long、float时要注意 在定义long或者float类型变量的时候，要加L或者f。整数默认是int类型，浮点数默认是double b
PHP编程基础--PHP运算符.ppt
05-30
三、三元运算符 三元运算符作用于三个操作数之间，其语法格式如下： 上述语句表示，如果表达式1为true，则返回表达式2的值，否则返回表达式3的值，具体示例如下： 三、三元运算符 示例中，程序执行第3行语句时，$a...
Java基础精品课02-变量和运算符.zip
05-20
Java基础精品课02-变量和运算符.zip
Java运算符和表达式--学习笔记.docx
07-05
JAVA学习笔记 Java知识点总结
JAVA程序设计课件-JAVA运算符.pptx
12-01
JAVA程序设计（OCJA认证）
简单的项目部署脚本（转载）
u010230019的博客
06-09 625
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1281
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 427
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 422
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
【Java02】Java中数组的定义与初始化
饮冰室
06-10 525
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
KK爱Coding的博客
06-11 283
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
笨蛋学算法之LeetCodeHot100_3_最长连续序列（Java）
YSL_Monet的博客
06-12 113
开启我的第三篇LeetCodeHot100算法之路---最长连续序列
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
最新发布
2301_77061352的博客
06-12 729
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
Invalid keystore format，获取安全码SHA1值出错
yfy1907的博客
06-11 172
Invalid keystore format 错误
【Hydro】SCS-CN方法中径流曲线数的确定（下）
```On Earth, Be Water, By Coding```
06-11 50
在[【Hydro】SCS-CN方法中径流曲线数的确定（上）](https://blog.csdn.net/qq_25262697/article/details/133796329)中已经介绍了SCS-CN在SWAT和HMS中的应用，以下会补充SCS-CN在XPSWMM、InfoWorks ICM中的应用。以及使用软件计算SCS-CN的步骤。
eclipse插件开发中，获取一个java工程中的所有import的包名，并打印出来
liudong200618的博客
06-11 192
这段代码将遍历指定Java工程中的所有源代码文件，并打印出每个文件中的所有import语句。确保在开发Eclipse插件时，你的插件项目已经正确配置了对Eclipse JDT的依赖。
【雷丰阳-谷粒商城 】【分布式基础篇-全栈开发篇】【08】【商品服务】Object划分_批量删除
Keep Reading Keep Writing Keep Thinking
06-11 432
【雷丰阳-谷粒商城 】【分布式基础篇-全栈开发篇】【08】【商品服务】Object划分_批量删除
springboot连接多个库
sunyingboaini的博客
06-11 175
一个SpringBoot项目，同时连接两个数据库：比如一个是Mysql数据库，一个是oracle数据库（啥数据库都一样，连接两个同为oracle的数据库，或两个不同的数据库，只需要更改对应的driver-class-name和jdbc-url等即可）注意：连接什么数据库，要引入对应数据库的包。
零基础入门c语言-王桂林.pdf
10-24
《零基础入门C语言-王桂林.pdf》是一本教授C语言基础知识的教材。C语言是一种广泛应用于计算机编程的高级程序设计语言，对于零基础的学习者而言，这本教材将会是一个良好的起点。 在该教材中，王桂林老师从零开始，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值