chapter3

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量140 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73970077/article/details/129775520
版权

**java的基础知识积累**

除号使用

System.out.println(10/4);//2;
double d = 10 / 4;
System.out.println(d);//2.0
System.out.println(10.0/4);//2.5

取模使用

a % b = a - a / b * b

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

取模实质是要利用公式

a % b = a - a / b * b;

自增自减

int j = 8;
int k = j++;//等价 k = j;j = j + 1;
int r = ++j;//等价 j = j + 1;r = j

下面是算术运算符的习题

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

int i = 1;
i = ++i;
System.out.println(i);//2

	(1)i = i + 1;
	(2)temp = i;
    (3)i = temp;

int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.println("i= " + i);//10
System.out.println("i2= " + i2);//20
i = --i2;
System.out.println("i= " + i);//19
System.out.println("i2= " + i2);//19

1.假如还有59天放假，问：合多少星期零几天
   //下面是练习

public class ArithmeticOperatorExercise {

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

	int days = 59;
	int leftdays = days % 7;
	int xq = 59/7;
	System.out.println(days + "天 合" + xq + "星期零" + leftdays +"天");
	}
}
2.定义一个变量保存华氏温度，华氏温度转换赦制度的公式为：5/9*(华氏温度-100)，请求出华氏温度对应的温度
    double hs = 234.5;
	double ss = 5.0 / 9 * (hs - 100);//此处要是5.0，否则计算机默认整除运算
	System.out.println(hs + "华氏温度是" + ss + "摄氏度");

解释执行

在这里插入图片描述

关系运算符

  1. 关系运算符的结果都是Boolean型，要么是true要么是false
  2. 关系运算符组成的表达式叫关系表达式
  3. 等于号(==)和赋值号(=)不可混淆
int a = 9;
int b = 8;
System.out.println(a > b);//T
System.out.println(a >= b);//T
System.out.println(a < b);//F
System.out.println(a <= b);//F
System.out.println(a == b);//F
System.out.println(a != b);//T
boolean flag = a > b;//T
System.out.println("flag = " + flag);//T

在这里插入图片描述

逻辑运算符

aba&b
(逻辑与)		a&&b
(短路与)		a|b
(逻辑或)		a||b
(短路或)		!a
(取反)		a^b
(逻辑异或)
truetruetruetruetruetruefalsefalse
truefalsefalsefalsetruetruefalsetrue
falsetruefalsefalsetruetruetruetrue
falsefalsefalsefalsefalsefalsetruefalse
  • 看表时，画一条竖线，一条横线
    • 横线经过a和b的真假
      • 竖线经过a和b运算的符号
        • 交叉点即为结果真假

  1. a&b(a&&b)

    同真为真，否则为假（基本上使用短路与（&&）效率更高）

    区别：

    短路与(&&)如果第一个条件为假，第二个条件不再判断(不运算第二个条件)，结果自动为假

    逻辑与(&)第一个条件为假，第二个条件要去判断(需要运算第二个条件)，但结果仍为假

  2. a|b(a||b)

    有真则真，否则为假、

    区别：
    短路或(||)第一个条件为真了，不会再执行后面的条件，最终结果为真，效率高

  3. !a

    ​ a真为假，a假为真

  4. a^b

    a和b不同时为真，否则为假

逻辑运算符练习

int x = 5;
int y = 5;
if(x++ == 6 & ++y ==6) {//第一个自增不管是最后结果是真还是假，都会实现
	x = 11;
}
System.out.println("x = " + x "y = " + y );//6 6

int x =5, y = 5;
if(x++ == 6 && ++y ==6) {
    x = 11;
}
System.out.println("x = " x + "y = " + y);//6 5

int x = 5, y= 5;
if(x++ == 5 | ++y ==5) {
	x = 11;	
}
System.out.println("x = " + x "y = " + y );//11 6

int x = 5, y= 5;
if(x++ == 5 || ++y ==5) {
	x = 11;	
}
System.out.println("x = " + x "y = " + y );//11 5

boolean x = true;
boolean y = false;
short z = 46;
if((z++ == 46)&&(t = true)) z++;//48
if((x = false) || (++z == 49)) z++;//49+1(虽然是短路或，但第一个条件是假，只有真才能使它短路)
System.out.println("z = " + z);//50

赋值运算符

运算顺序(从右到左)

复合运算符会进行类型转换

byte b = 3;
b += 2;//等价  b = (byte)(b + 2)  -->此时不等价于 b = b + 1

三元运算符

条件表达式？表达式1：表达式2
为真返回1，为假返回2(一真大师)

public class TernaryOperator {
	//编写一个main方法
	

	public static void main(String[] args) {

		int a = 10;
		int b = 99;
		int result = a > b ? a++ : b--;
		System.out.println(result);//99(先赋值再--)
	}
}

public class TernaryOperator {
	//编写一个main方法
	

	public static void main(String[] args) {

		int a = 10;
		int b = 99;
		int result = a < b ? a++ : b--;
		System.out.println("result " + result);//10
		System.out.println("a = " + a);//11
		System.out.println("b = " + b);//99
	}
}

细节

  • 表达式1和表达式2要为可以赋给变量的类型(或可以自动转换/强制转换)
  • 可以转换为if-else语句
//实现三个数的最大值
		int x = 100;
		int y = 150;
		int z = 300;

		//自己写的
		int ret = x > y ? (x > z ? x : z) : (y > z ? y : z);

		//推荐使用,这里思路更清晰
		//比如冒泡法等可以优化代码
		int max1 = x > y ? x : y;
		int max2 = max1 > z ? max1 : z;

		//结果都是相同的
		System.out.println("ret = " + ret);

运算符的优先级

  1. 只有单目运算符、赋值运算符是从右向左运算的
  2. 有大致的概念即可
. () {} : ,
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= *= /= %=
+= -= <<= >>=
>>>= &= ^= |=
  1. () {} 等不可分割的存在的符号
  2. 单目运算符
  3. 算术运算符
  4. 位移运算符
  5. 逻辑运算符
  6. 三元运算符
  7. 赋值运算符

标识符的命名规则和规范

1.规则

  1. 凡是可以自己起名字的地方都叫标识符
  2. 由26个英文字母大小写，0~9 _ 或$组成
  3. 数字不可以开头
  4. 不可以使用关键字和保留字，但能包含关键字和保留字
  5. 严格区分大小写，长度无限制
  6. 标识符不可含空格
xixi     √
xixi12   √
1xixi    ×
xi-xi    ×(此处包含了减号)   int a-b = 10;(×)
xi xi    ×
xi$4     √
class    ×
int      ×
double   ×
public   ×
static   ×
goto     ×(goto是一个保留字)
stu_name √

2.规范(更加专业)

  1. 包名：多单词组成时所有的字母都小写

    com.xixi.src

  2. 类名、接口名：多单词组成时，所有单词的首字母大写

    XxxYyyZzz [大驼峰]

  3. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写

    xxxYyyZzz [小驼峰 简称驼峰法]

    tankShotGame

  4. 常量名：所有字母都大写。多单词时每个单词用下划线连接

    xxx_yyy_zzz

    TAX_RATE

关键字

有特殊含义，专门用途的字符串(单词)

使用时会自动高亮

不可再作为标识符，不可再用于定义变量和方法名

保留字

现有java版本尚未使用，但以后的版本可能会作为关键字使用。自己命名标识符时应当避免使用

byValue cast future generic inner operator outer rest var goto const

键盘输入语句

扫描器(对象)用于接受用户输入的数据

Scanner

  1. 导入该类的所在包， java.util.*
  2. 创建该类的对象(声明变量)
  3. 调用里面的功能
public class Input {
	//编写一个main方法
	

	public static void main(String[] args) {
	  	//演示接受用户的输入
	  	

	  	//创建一个Scanner对象，new创建一个对象
	  	//scanner 就是Scanner类的对象
	  	Scanner scanner = new Scanner(System.in);

	  	System.out.println("请输入名字");
	  	//程序到这里时，会等待用户输入
	  	String name = scanner.next();//接受用户的输入的字符串
	  	System.out.println("请输入年龄");
	  	int age = scanner.nextInt();//接受用户的输入的int
	  	System.out.println("请输入薪水");
	  	double sal = scanner.nextDouble();//接受用户的输入的double
	  	System.out.println("人的信息如下");
	  	System.out.println("名字 = " + name 
	  		+ " 年龄 = " + age + " 薪水 = " + sal);

  	}

}

进制

  1. 二进制，满二进一（以0b或者0B开头）

    int n1 = 0b1010;//10

  2. 十进制

  3. 八进制（以数字0开头）

    int n2 = 01010;//520
//f   -->15
//10  -->16

  4. 十六进制 0-9及A(10)-F(15){a(10)-f(15)} 满十六进一（ 以数字0x开头）

    int n3 = 0x10101;//65793

    进制转换

    • 其他进制转十进制
    1. 二进制转十进制

    从最低位(右边)开始，将每个位上的数提取出来，乘以2的(位数-1)次方
    然后求和

    0b110001100 = 4 + 8 + 2 ^ 7 + 2 ^ 8 = 12 + 128 + 256 = 396

    1. 八进制十进制

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

    0234 = 4 * 8 ^0 + 3 * 8 ^1 + 2 * 8 ^ 2 = 4 + 24 + 128 = 156

    0246 = 6 + 4 * 8 + 2 * 8 * 8 = 6+32+128=166

    1. 十六进制转十进制

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

    0x23A = 10 * 16 ^ 0 + 3 * 16 ^1 + 2 * 16 ^ 2 = 10 + 48 + 512 = 570

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

    • 十进制转其他进制
    1. 十进制转二进制

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

    34 = 0b00100010

    123 = 0b0111011

    1. 十进制转八进制

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

    131 = 0203

    678 = 01246

    1. 十进制转十六进制

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

    237 = 0xED

    8912 = 0x22D0

    在这里插入图片描述

    • 二进制转八进制和十六进制
    1. 二进制转八进制

    从低位开始，将二进制位每三位一组，转成对应的八进制数

    0b 011(3) 010(2) 101(5)—>0325

    0b011(3) 100(4) 101(5)—>0345

    1. 二进制转十六进制

    从低位开始，将二进制位每四位一组，转成对应的十六进制数

    0b 1101(13) 0101(5)—>0xD5

    0b0011(3) 1001(9) 0110(6)—>0x396

    • 八进制和十六进制转二进制

      1. 八进制转二进制

        将八进制数每一位，转成对应的一个三位的二进制数即可

        0 2(010) 3(011) 7(111)—->0b010011111

        0 1(001) 2(010) 3(011) 0(000)—>0b001010011000

      2. 十六进制转二进制

        将十六进制数每一位，转成对应的一个四位的二进制数即可

        0x 2(0010) 3(0011) B(1011)—>0b001000111011

        0x A(1010) B(1011) 2(0010) 9(1001)—>0b1010101100101001

        ​

    原码、反码、补码

    1. 二进制的最高位是符号位：0表示正数，1表示负数(符号位直接向右旋转90% 0—>0 1—>-)
    2. 正数的原码、反码、补码都一样(三码合一)
    3. 负数的反码=它的原码符号位不变，其他位取反
    4. 负数的补码=它的反码+1，负数的反码 = 负数的补码-1
    5. 0的反码补码都是0
    6. java没有无符号数，java的数都是有符号的
    7. 在计算机运算时，都是以补码的方式来运算的(利用补码运算，使正数和负数统一起来)
    8. 当我们看运算结果时，要看原码

位运算符

1.& | ^ ~

  • 按位与(&)：两位全为1、结果为1，否则为0

  • 按位或(|)：两位有一个为1，结果为1，否则为0

  • 按位异或(^)：两位一个为0，一个为1，结果为1，否则为0

  • 按位取反(~)：0-1 1-0（符号位也需要取反）

    public class BitOperator {
	//编写一个main方法
	

	public static void main(String[] args) {

		System.out.println(2&3);//2
		//原2 00000000 00000000 00000000 00000010
		//正数原反补相同
		//补2 00000000 00000000 00000000 00000010
		
		//原3 00000000 00000000 00000000 00000011
		//补3 00000000 00000000 00000000 00000011
		
		//00000000 00000000 00000000 00000010
		//00000000 00000000 00000000 00000011
		
		//00000000 00000000 00000000 00000010(&后的补码，而这个数是正数，则即是原码)
		//打印出的就是 2
		System.out.println(~-2);//1
		//原10000000 00000000 00000000 00000010
		//反11111111 11111111 11111111 11111101
		//补11111111 11111111 11111111 11111110
		
		//00000000 00000000 00000000 00000001(取反后的补码)
		//java取反符号位同样改变
		
		//  
		System.out.println(~2);//-3
		//00000000 00000000 00000000 00000010
		
		//11111111 11111111 11111111 11111101
		//11111111 11111111 11111111 11111100
		//10000000 00000000 00000000 00000011//-3
		
		System.out.println(2|3);//3
		//00000000 00000000 00000000 00000010
		//00000000 00000000 00000000 00000011
		//00000000 00000000 00000000 00000011//3
		
		System.out.println(2^3);//1
		//000000000 000000000 00000000 00000010
		//000000000 000000000 00000000 00000011
		//000000000 000000000 00000000 00000001//1
		
		System.out.println(~-5);//4
		//10000000 00000000 00000000 00000101
		//11111111 11111111 11111111 11111010
		//11111111 11111111 11111111 11111011
		//
		//00000000 00000000 00000000 00000100//4
		
		System.out.println(13&7);//5
		//13原00000000 00000000 00000000 00001101
		//7原 00000000 00000000 00000000 00000111
		//    00000000 00000000 00000000 00000101//5
		
		System.out.println(5|4);//5
		//5原 00000000 00000000 00000000 00000101
		//4原 00000000 00000000 00000000 00000100
		//结果00000000 00000000 00000000 00000101//5
		
		System.out.println(-3^3);//-2
		//-3原10000000 00000000 00000000 00000011
		//-3反11111111 11111111 11111111 11111100
		//-3补    11111111 11111111 11111111 11111101
		//
		//3原(补) 00000000 00000000 00000000 00000011
		//结补    11111111 11111111 11111111 11111110
		//
		//结反    11111111 11111111 11111111 11111101
		//结原    10000000 00000000 00000000 00000010//-2
	}
}
2.>> << >>>

  • 算术右移(>>)：低位溢出，符号位不变，用符号位补溢出的高位

    int a = 1 >> 2;// (标记a)000000(标记b)01----> 00(标记a)000000(标记b)  
//本质： 1 / 2 / 2
//标记b后的01已被吃掉
//标记a前面一个0是符号位，一个是补位

  • 算术左移(<<)：符号位不变，低位补0

    int c = 1 << 2;// 00(标记a)000001(标记b)----> (标记a)000001(标记b)00  
//本质：1 * 2 * 2
//标记a前的两个0已被左移吃掉了
//标记b后的两个0用于补位

  • 逻辑右移(>>>)：也叫无符号右移，低位溢出，高位补0

  • 特别说明：无<<<符号

public class BitOperator02 {
	//编写一个main方法
	

	public static void main(String[] args) {

		System.out.println(1 >> 2);//0  1 / 2 / 2
		System.out.println(1 << 2);//4  1 * 2 * 2
		System.out.println(4 << 3);//32  4 * 2 * 2 * 2
		//00000100
		//0010000  32
		System.out.println(15 >> 2);//3   15 / 2 / 2 

		System.out.println(1 >> 2);//0

		System.out.println(-1 >> 2);//-1
		//10000000 00000000 00000000 00000001
		//11111111 11111111 11111111 11111110
		//11111111 11111111 11111111 11111111
		//
		//11111111 11111111 11111111 11111111
		//11111111 11111111 11111111 11111110
		//10000000 00000000 00000000 00000001
		System.out.println(1 << 2);//4
		
		System.out.println(-1 << 2);//-4
		//10000000 00000000 00000000 00000001
		//11111111 11111111 11111111 11111110
		//11111111 11111111 11111111 11111111
		//
		//11111111 11111111 11111111 11111100
		//11111111 11111111 11111111 11111011
		//10000000 00000000 00000000 00000100//-4
		System.out.println(3 >>> 2);//0

	}
}

10000000 00000000 00000000 00000001
//11111111 11111111 11111111 11111110
//11111111 11111111 11111111 11111111
//
//11111111 11111111 11111111 11111111
//11111111 11111111 11111111 11111110
//10000000 00000000 00000000 00000001
System.out.println(1 << 2);//4

	System.out.println(-1 << 2);//-4
	//10000000 00000000 00000000 00000001
	//11111111 11111111 11111111 11111110
	//11111111 11111111 11111111 11111111
	//
	//11111111 11111111 11111111 11111100
	//11111111 11111111 11111111 11111011
	//10000000 00000000 00000000 00000100//-4
	System.out.println(3 >>> 2);//0

}

}
沉梦书远
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Coursera课程Python for everyone：chapter3
GarfieldEr007的专栏
02-16 3861
Chapter 3 10 试题 1.  What do we do to a Python statement that is immediately after an if statement to indicate that the statement is to be executed only when the if s
Chapter3.html
09-11
Chapter3.html
word目录里出现Equation Chapter 3 Section 1字样
weixin_46832764的博客
01-20 812
网上找的方法将MTE格式隐藏也不行啊。
Chapter 3、静态代理
ConstXiong
06-02 4695
为了不修改原 ServiceImpl 的业务代码，而对其进行扩充（统计、打印耗时）和拦截（判断是否登录），可以使用代理。 代码如下 1、让 ServiceImpl 处理原先核心的业务逻辑 package constxiong.cxproxy.chapter3.service; import java.util.HashMap; import java.util.Map; /** * ...
C++郑莉笔记 chapter3 函数
weixin_45886798的博客
03-12 1231
chapter_3 函数 函数的定义与声明 函数的参数 默认参数 值传递 地址传递 引用传递 含有可变数量形参的函数 函数重载 函数重载的要求(参数类型不同，参数个数不同，包含默认参数时需注意) 发生重载时函数调用的匹配规则 函数调用方式与关系 主调函数与被调函数 嵌套调用 递归调用 C++数学函数库 cmath ...
[rospack] Error: package 'chapter3_tutorials' not found
wangchongqt的博客
04-22 3173
ｒｏｓ错误之一 解决办法：　source ~/catkin_ws/devel/setup.bash
Chapter 3, Exercise 3.2.3
BuXiao的专栏
09-15 567
Chapter 3, Exercise 3.2.4
BuXiao的专栏
09-15 393
【索引】Chapter 3. Data Structures
不慌不忙、不急不躁
08-23 914
AOAPC I: Beginning Algorithm Contests -- Training Guide (Rujia Liu) Chapter 3. Data Structures
Head First Python 学习笔记-Chapter3：文件读取和异常处理
生命在于折腾
08-18 2188
第三章中主要介绍了简单的文件读取和简单的异常处理操作。
信号与系统 chapter3 冲激函数的尺度变换
热门推荐
weixin_44754436的博客
08-24 1万+
在chapter2里我们简单的示例了一个阶跃函数做尺度变换的例子，在这一节里我们会对冲激函数做尺度变换，同样很简单 关于δ(at)\delta(at)δ(at) 它的证明如下，使用换元法即可得到： 始终利用的是冲激函数只在t=0t=0t=0处有意义 如果它发生了左右时移，我们第一步同样的也是要把ttt前面的系数化为1，再分析 δ(at−t0)=δ(a(t−t0a))\delta(at-t_0)=\delta(a(t-\frac{t_0}{a}))δ(at−t0​)=δ(a(t−at0​​)) 到这一步就
计算机专业英语chapter 3PPT课件.pptx
10-09
计算机专业英语chapter 3PPT课件.pptx
chapter3transmitter.pptx
10-14
chapter3transmitter.pptx
chapter3.sql
11-15
chapter3.sql
Chapter 3.py
09-21
Chapter 3.py
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 564
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 804
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1096
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 782
@Transactional中使用线程锁导致了锁失效与解决方案
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值