2021-05-01

最新推荐文章于 2024-07-10 21:37:49 发布

CjShelby

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量120

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_44717803/article/details/116323157

版权

1.整数类型：
byte
在内存中占1个字节，表示范围：-2的7次 ~ 2的7次-1
short
内存中占2个字节，表示范围：-2的5次 ~ 2的15次-1
int(推荐使用 int 类型)
内存中占4个字节，表示范围：-2的31次 ~ 2的31-1
long
内存中占8个字节，表示范围是：-2的63次 ~ 2的63次-1
注意：
在Java程序中直接写出的整数数据叫做常量
默认为int
若想表达更大的直接量，则在直接量的后面加上L
例如：
int num = 25025050L ;
整数类型的笔试考点
int a1 = 25;
byte b1 = a1; //不可以这样自复制，int 的字节数大于byte 的字节数，从大转到小可能内存精度会溢出。
解决方案
转换类型
int a1 = 25;
byte b1 = (byte)a1; //表示从int类型转换到byte类型。
2.浮点类型
功能：
用于描述小数数据的类型：float 和 double ，小数数据叫做小数常量，小数默认位 double 类型。
float
内存占4个字节，叫做单精度浮点数，可表示7位有效数字。
范围：-3.403E38 ~ 3.403E38。(表示-3.403*10的38次方)
float编程使用：
float f1 = 3.1415926F; // 如果小数最后一位不加 F 则默认位 double类型
System.out.println(f1); // 3.1415925 这是因为单精度有效位数只有7位，所以结果会把最后以为减一。
double(推荐使用)
内存占8个字节，叫双精度浮点数，可表示15位有效数字。
范围：-1.798E308 ~ 1.798E308。(-1.798*10308次方)
考点笔试
打印一个两个浮点数之和
System.out.println(0.1+0.2); // 0.3000000004 出现这种结果是因为小数默认为double类型，所以这两个小数必须加 F
解决方案：System.out.println(0.1F+0.2F); // 加F结果才会现实中的 0.1+0.2 = 0.3，但运算时还是会出现误差。
3.布尔类型
功能：
用于描述真假信息的类型,内存空间所占大小没有明确规定，可认为时1个字节。
boolean
数值只有两个值：
tyue 和 false
4.基本数据类型之间的转换
自动类型转换
从小类型到大类型之间的转换。
byte<short/char<int<long<float<double
强制类型转换
从大类型到小类型之间的转换。
格式
目标类型变量名 = (目标类型) 要转换的源类型变量名；
注意：
强转有风险，操作需谨慎！
5.算术运算符
+ 表示加法
- 表示减法
* 表示乘法
/ 表示除法
% 表示取余数
注意事项：
当两个整数相除时，结果值保留整数部分，丢弃小数部分。
例如：a = 2 ,b = 5,System.out.println(5/2); //数学里等于：2.5 ,结果等于：2
0 不能作为除数。
希望保留小数部分
方案一
使用强制转换将其中一个操作数转为double类型运算即可。
int dOne = 5;
int dTwo = 2;
System.out.println("结果：" + (double)dOne/(double)dTwo); // 2.5
System.out.println("结果：" + dOne/(double)dTwo) // 2.5
方案二(推荐使用)
让其中一个操作数乘以1.0即可。
System.out.println("结果："+5*1.0/2); // 2.5
6.字符串连接运算符
+
功能：
可以实现字符串的连接。同时可以实现字符串与其他数据类型"相连"。
区分：只要 + 号两边的操作数中有一个操作数是字符串类型，则该 + 就被当作来连接符来用，否则就是 + 加法运算符。
例如：
//8
System.out.println(aHour+minuts+miao);
//116
System.out.println(aHour+""+minuts+miao);
//116
System.out.println(""+aHour+minuts+miao);
//26
System.out.println(aHour+minuts+""+miao);
//8
System.out.println(aHour+minuts+miao+"");

7.关系/比较运算符
>
是否大于
>=
是否大于等于
<
是否小于
<=
是否小于等于
==
是否等于运算符
!=
是否不等于运算符
8.自增减运算符
++
自增
功能：
用于使得当前变量自身的数值加1。
--
自减
功能：
用于使得当前变量自身的数值减1。
例如：
// 声明变量
int a = 10;
System.out.println("a = "+ a );
System.out.println("-------------------------------------");
// 实现自增自减
a++;
System.out.println("a = "+ a );
++a;
System.out.println("a = "+ a );
System.out.println("-------------------------------------");
a--;
System.out.println("a = "+ a );
--a;
System.out.println("a = "+ a );
前后加加的区别
a++
后加加
表示先让变量 a 的数值作为整个表达式最终结果，然后再让 a 变量自身的数值加1。
例如：
System.out.println(a++); // 10
System.out.println(a); // 然后再加 11
++a
前加加
表示先让变量自身的数值加1，然后再让变量的数值作为整个表达式的结果。
例如：
System.out.println(a++); // 12
System.out.println(a); // 12
自增减运算笔试考点
int b = a++;
System.out.println(b); // 12
System.out.println(a); // 13
int bo = ++a;
System.out.println(bo);// 14
System.out.println(a); // 14
System.out.println(a++ + ++a); // 30
System.out.println(a); //16
注意：
只能用于变量，常熟不可以！
10.逻辑运算符
&&
逻辑与，相当于 "并且" ,全真为真，一假全为假。
||
逻辑或，相当于 "或者"，一真为真，全假才为假。
！
逻辑非，相当于 "取反"，真的为假，假的为真。
功能：
主要用于连接多个关系运算符作为最终的表达式，用于实现多条件的连接。
例如：
if(num >=oneHundued && num <= nientyHundued){
System.out.println("显示输出的是三位正整数: "+ num);
}
注意：
逻辑运算符的操作数均为boolean表达式。
11.条件/三目运算符
格式：
条件表达式？表达式1：表达式2
例如：
System.out.println((num >=oneHundued && num <= nientyHundued)? "是三位数":"不是三位数"); // 结果: 是三位数
功能：
判断条件是否成立，若成立则执行表达式1，否则执行表达式2。
12.赋值运算符(重点)
=
赋值运算符
功能：
用于将 = 右边的数据赋值给 = 左边的变量，覆盖变量原来的数值。
注意：
赋值表达式本身也有值，其本身之值即为所赋之值。
复合赋值运算符：
+=
例如：
i1 = i1 + 5; // 简化写法 (推荐初学者使用)
System.out.println(i1);
i1 += 4;
System.out.println(i1);
-=
*=
/=
%=
赋值运算符的(笔试考点1)
byte b1 = 10;
System.out.println(b1);
b1 = b1+2; // 错误写法：byte + int 还是int
b1 = b1 + (byte)2; // 错误写法： byte + byte 还是int 主要是因为编译器的优化导致。
解决方案：
使用强制类型转换
byte b1 = 10;
System.out.println(b1);
b1 = (byte)(b1+2);
System.out.println(b1); // 12
笔试考点2
int a =45;
a == 2 ; // 表示判断两个数是否相等。(不推荐使用此写法)
2 == a ; // 表示2和a两个数是否相等。(在写法中推荐使用此写法)
为什么要这样写：
主要是因为怕写成类似这样的： a = 2 ; //少写了一个等号。不小心就写成了赋值了。
13.移位运算符(了解即可)
<<
左移
功能：
用于将数据的二进制位先左移动，右边使用0补充。
提示：
当整数向左移时，相当于当前整数的数值*2倍。
例如：
// 1.声明变量
byte b1 = 13;
System.out.println(b1);
System.out.println("------------------");
//2. 移位运算符的使用
System.out.println(b1<<1); // 左移1位：13*2
System.out.println(b1<<2); // 相当于13*4=52
>>
右移
功能：
用于将数据的二进制位向右移动，左边使用符号部位。
提示：
当整数向右移时，相当于当前整数的数值/2倍。
例如：
byte b1 = 13;
System.out.println(b1>>1); // 相当于：13/2=6
System.out.println(b1>>2); // 相当于： 13/4=3
>>>
无符号右移
功能：
用于将数据的二进制位向右移动，左边使用0补充。
提示：
无符号右移，对于非负数来说，无符号右移和右移的效果一致。
例如：
System.out.println(b1>>>1); // 6
System.out.println(b1>>>2); // 3

14.位运算符(了解即可)
&
按位异或
功能：
按照二进制位进行与运算
规律：
同1位1，一0为0
|
按位或
功能：
按照二进制进行或运算
规律：
一1为1，同 0 为 0
~
按位取反
功能：
按照二进制进行取反
规律：
1为0，0为1
^
按位异或
功能：
按照二进制进行异或运算
规律：
同0为0，不同为1
15.运算符的优先级
()的优先级极高。
= 的优先级极低。
若无法确认优先级，则使用()来确保即可。
16.分支结构的概念
何时使用：
但需要进行条件判断并做出选择时，使用分支结构。
if分支结构
格式：
if(条件表达式){
语句块；
}
规律：
判断条件表达式是否成立
若成立，则执行语句块；
若不成立，则执行跳过语句块；
if else 分支结构
格式
if(条件表达式){
语句块1；
}else{
语句块2；
}
规律：
判断条件表达式是否成立
若成立，则执行语句块1；
若不成立，则执行语句块2；
if else if else 分支结构
格式
if(条件表达式1){
语句块1；
}
else if(条件表达式2){
语句块2；
}else {
语句块n;
}
规律：
判断表达式1是否成立
若成立，则执行语句块1；
若不成立，则判断条件表达式2是否成立
若不成立，则执行语句块2；
热不成立，则执行语句块n;

17.switchcase分支结构的概念
格式：
switch(变量/表达式){
case 字面值1：语句1；break；
case 字面值2：语句2；break;
}
...
default:语句块n;
}
规律：
计算变量/表达式的数值 => 判断是否匹配字面值1
若匹配，则执行语句块1 => 执行break跳出当前结构
若不匹配，则判断是否匹配字面值2
若匹配，则执行语句块2 => 执行break跳出当前结构
若不匹配，则执行语句块n
switchcase分支结构实现等级判断
18.循环结构的概念
何时要用：
再Java程序中若希望重复执行一段代码时，就需要使用循环结构。
for循环
格式：
for(初识化表达式; 条件表达式; 修改初始值表达式){
循环体；
}
规律：
执行初始化表达式 => 判断条件表达式是否成立
成立则执行循环体 =>修改初始值表达式 => 判断条件表达式是否成立
若不成立，则循环结束
continue关键字
功能：
用于结束本次循环而开始下一次循环。
break关键字
功能：
退出当前语句块
在循环体中用于退出循环
break关键字跳出多层循环
如果要退出外层循环体，需要使用标号的方式
outer : for(...){
for(...){
break outer;
}
}
for(;;)
这种没有循环条件的循环叫做无限循环，称 "死循环"。
双重for循环的格式:
功能：
用于打印多行多列。
for(初识化表达式1；条件表达式2；修改初始值表达式3){
for(初识化表达式4；条件表达式5；修改初识值表达式6){
循环体；
}
}
19.while循环
格式：
while(条件表达式){
循环体；
}
规律：
判断条件表达式是否成立
热成立，则执行循环体，=>判断条件表达式是否成立，若不成立，则循环体结束。
注意：
在（）或{}中声明的变量叫块变量，作用范围是从声明开始一直到语句块结束。
while循环和for循环比较
完全可以互换，当然推荐使用for循环。
区别：
while循环更适合于明确循环条件但不明确循环次数的场合中。
for循环更适合于明确循环次数或范围的场景中。
while(true)等价于for(;;)都表示无限循环。
do while循环(熟悉即可)
do{
循环体；
}while(条件表达式);
规律：
执行循环体 => 判断条件表达式是否成立
若成立，则执行循环体 =>判断条件表达式是否成立
若不成立，则循环结束
do while循环和 while 循环的区别：
do while 循环主要用于至少执行一次循环体的场景中。(先执行，在判断)
循环笔记考点：
十动然拒
int i = 1;
while (i<=999) ; {
System.out.println("I LOVE YOU!");
i++;
}
此程序相当于：
while(i<=999){
; // 每次执行到这个分号就啥也不干，一直死循环，不执行下面的输出语句。
}
{
System.out.println("I LOVE YOU!");
i++;
}
20.数组以及应用
1.何时使用
当需要在Java程序中记录多个类型相同的数据内容时，则声明一个一维数组即可，一维数组本质上就是在内存空间中申请一段连续的存储单元。
注意：
数组是相同数据类型的多个元素的容器，元素按线性顺序排列，在Java语言中体是引用数据类型。
2.一维数组的声明方式：
格式：
数据类型[] 数组名称 = new 数据类型[数组长度]; (动态方式声明一维数组)
如何获取数组长度：
调用数组的length属性可以获取数组的长度：
例如：数组名 . length ；// 获取数组长度
下标：
可以通过下标的方式访问数组中的每一个元素。
需要注意的是：数组的下标从0开始，对于长度为n的数组，下标的范围是长度-1。
3.一维数组的初始化
静态初始化：
格式：
数据类型[] 数组名称 = {初始值1，初识值2,...}
// 声明数组的同时就对数组进行初始化
int[] arrTwo = {1, 2, 3, 4, 5, 6, 7, 8};
// 特殊的写法, 依然是静态初始化的写法
boolean[] arr4 = new boolean[]{true,false,true,false,true};
基本类型的数组(数据类型为基本类型) 创建后，其元素的初始值：byte,short,char,int,long 为0；
float,double 为0.0
boolen 为 false.
例如：
double[] dbs = new double[8];
// 3.打印数组中的每一个数值
for (int i = 0; i < dbs.length; i++) {
System.out.println(dbs[i]); // 0.0，0.0 .....0.0
}
4.内存结构之栈区
栈区：
功能：
用于存放程序运行过程中所有的局部变量。
一个运行的Java程序从开始到结束会有多次变量的声明。
堆区：
功能：
JVM会在其内存空间中开辟一个为"堆"的存储空间
用于存储使用 new 关键字创建的数组和对象。
5.数组的优缺点：
优点：
可以直接通过下标(或索引)的方式访问指定位置的元素，速度很快。
缺点：
数组要求所有元素的类型相同。
数组要求内存空间连续，并且长度一旦确定就不能修改。(优缺点共存)
增加和删除元素时，可能移动大量元素，效率低。
使用到的超前知识：
java.base
java.lang
类摘要：Class System System类包含几个有用的类字段和方法。
方法摘要：
功能：
将一个数组的数组元素拷贝到另一个数组里。
public static void arraycopy(Object src, int srcPos, Object dest , int destPos , int length )；
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
例如：
System.arraycopy(arr1,1,arr2,0,3);
6.一维数组之间拷贝的笔试考点：
arr2 = arr1 ;
// 1. 表示将变量 arr1 的数值赋值变量 arr2 ,覆盖变量arr2中原来的数值。
// 2. 数组名 arr1 的内存中存放的是数据在堆去中的内存地址信息，赋值后让 arr2 变量中存放了arr1 所指向堆区的内存地址
// 3. 也就是让 arr2 和 arr1 指向了同一块堆区空间，在本质上就是改变指向而已。
7.数组工具类的概念
java.util.Arrays类
功能：
可以实现对数组中元素的遍历，查找，排序等操作。
常用方法如下：
1.static String toString(int[] a) : 输出数组中的内容。
2.static void fill(int[] a,int val) : 将参数指定元素赋值给数组中所有元素。
3.static boolean equls(boolean[] a,boolean a2 ) : 判断两个数组元素和次序是否相同。
4.static void sort(int[] a) ：对数组中的元素进行从小到大排序。
5.static int binarySearch(int [] a,int key) : 从数组中查找参数指定元素所在的位置。
8. 二维数组的概念
本质上就是由多个一维数组摞在一起组成的数组，二维数组中的每个元素都是一维数组，而一维数组中的每个元素才是数据内容。
二维数组的声明和使用
格式：
数据类型[][] 数组名称 = new 数据类型[行数][列数];
二维数组的初始化方式
格式：
数据类型[][] 数组名称 = {{元素1,元素2,...}...};
考点：
int[][] arr3 = new int[3][];
arr3[0] = new int[3];
arr3[1] = new int[4];
arr3[2] = new int[5];

CjShelby

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
2021-05-01

1.整数类型： byte 在内存中占1个字节，表示范围：-2的7次 ~ 2的7次-1 short 内存中占2个字节，表示范围：-2的5次 ~ 2的15次-1 int(推荐使用 int 类型) 内存中占4个字节，表示范围：-2的31次 ~ 2的31-1 long 内存中占8个字节，表示范围是：-2的63次 ~ 2的63次-1 注意：在Ja...
复制链接

扫一扫