基本数据类型与运算符

Java
后端
发布日期:   2019-12-22

开发细节

  1. 一个源文件最多只能有一个public类,但其他类不受限制.

  2. 如果源文件包含一个public类,则文件名必须按该类名命名.

  3. 一个源文件中最多只能有一个public类.其他类的个数不限,也可以将main方法写在非public类中,然后指定运行非public类,这样入口方法就是非public的main方法.

  4. 文档注释：

    //javadoc标签
/** 
    * @author
    * @version
*/

//命令行        
//javadoc -d 文件夹名 -xx -yy Demo.java
javadoc -d d:\\temp -author -version Demo.java

  5. 代码规范：

    1. 类、方法的注释，要以javadoc的方式来写。
    2. 非Java Doc的注释，往往是给代码的维护者看的，着重告诉读者为什么这样写，如何修改，注意什么问题等。
    3. 运用tab操作，实现缩进，默认整体向右边移动，用shift+tab整体向左移
    4. 运算符和 = 两边习惯性各加一个空格。
    5. 源文件使用utf-8编码。

img

DOS原理

Dos系统：

  1. 接受指令
  2. 解析指令
  3. 执行指令

相对路径：从当前目录开始定位，形成的一个路径

绝对路径：就是完整路径，从顶级目录例如D:\开始定位，形成的路径

常用dos命令：

  1. 查看当前目录是有什么内容：dir

    dir dir d:\abc\test100

  2. 切换到其他盘下：cd

    cd /D d:切换到D盘

  3. 切换到当前盘的其他目录下（使用绝对路径和相对路径演示）

    cd d:\abc2\test200 cd ..\..\abc2\test200

  4. 切换到上一级：cd ..

  5. 切换到根目录：cd\

  6. 查看指定的目录下所有的子级目录：tree

  7. 清屏：cls

  8. 退出：exit

  9. md[创建目录]，rd[删除目录],copy[拷贝文件],del[删除文件],echo[输入内容到文件],move[剪切]

基本类型

变量

  1. 变量必须先声明，后使用，即有顺序。
  2. 该区区域的数据/值可以在同一类型范围内不断变化。
  3. 变量在同一个区域内不能重名。
  4. 变量三要素：变量名，值，数据类型。

＋号的使用

  1. 当左右两边都是数值型，则做加法运算。
  2. 当左右两边有一方为字符型，则做拼接运算。
  3. 运算顺序是从左到右的。
System.out.println(100+98);//198
System.out.println("100"+98);//10098
System.out.println(100+3+"hello");//103hello
System.out.println("hello"+100+3);//hello1003

数据类型

  1. 基本数据类型：数值型：整数类型：

    byte[1] \ short[2] \ int[4] \ long[8]

  2. 基本数据类型：数值型：浮点类型：

    float[4] \ double[8]

  3. 基本数据类型：字符型：

    char[2]，存放单个字符’a’

  4. 基本数据类型：布尔型：

    boolean[1]

  5. 引用数据类型：类（class）、接口（interface）、数组（[ ]）

注：【2】表示存放两个字节

整型细节

  1. Java的整型常量默认为int，声明long型常量须后加”l“或者”L“

  2. int n1 = 1;//4个字节
int n2 = 1L;//不对的
long n3 = 1L;//对的

  3. Java程序中变量常声明为int。

  4. 计算机中最小存储单位：bit。计算机中基本存储单元：byte。一个byte=8个bit。

浮点数细节

  1. 浮点数 = 符号位+指数位+尾数位

  2. Java的浮点型常量默认为double，声明float型常量须后加”f”或者“F”

  3. float n1 = 1.1;//不对的
float n2 = 1.1f;//对的

  4. 通常使用double。

  5. 浮点型使用陷阱：2.7和8.1 / 3 比较

    ​ 后者结果是2.6999999997，是以精度显示的。

    所以当我们对运算结果是小数的进行相等判断时，要小心

    double num11 = 2.7;
double num12 = 8.1 / 3; //2.7
System.out.println(num11);//2.7
System.out.println(num12);//接近2.7的小数，而不是2.7
//错误写法
if( num11 == num12)
{
    System.out.println("相等");
}
//正确的写法：
if( Math.abs(num11 - num12) < 0.000001 )
{
    System.out.println("差值非常小,到我的规定精度,可以认为相等.");
}

//细节:如果是直接查询得到的小数或者直接赋值,是可以判断相等

字符型细节

  1. 字符常量是用单引号括起来的单个字符.

  2. Java允许使用转义字符’\‘来将其后的字符转变为特殊字符型常量. 例如: char c3 = ‘\n’; 表示换行符

  3. 在java中,char的本质是一个整数,在默认输出时,是Unicode码对应的字符.

    char c1 = 97;
System.out.println("c1"); //a

char c2 = 'a';
System.out.println((int)c2); //输出'a' 对应的 数字

System.out.println('a' + 10); //107

  4. //测试
char c5 = 'b' + 1; //98+1 == 99
System.out.println((int)c5); //99
System.out.println(c5);//99对应的字符 c

  5. 字符类型本质:

    字符型存储到计算机中,需要将字符型对应的码值(整数)找出来,比如’a’ 存储 ==> 码值97 ==> 0110 0001

  6. ASCII编码表是一个字节表示,一个128个字符,实际上一个字节可以表示256个字符,只用128个.

  7. Unicode编码表 固定大小的编码 使用两个字节来表示字符,字母和汉字统一都是占用两个字节.

  8. utf - 8 编码表.大小可变的编码字母占一个字节,汉字使用3个字节.(表示的汉字更多)

  9. gbk编码表,字母占一个字节,汉字占2个字节.

数据类型自动转换

img

  1. 有多种类型的数据混合运算时,系统首先自动将所有数据转换成容量最大的那种数据类型,然后再进行计算.

  2. (byte , short)与char 之间不会相互自动转换.

    //当把具体数赋给byte时,先判断该数是否在byte范围内,如果是就可以
byte b1 = 10; //对,-128~127

int n2 = 1;//n2 是int
byte b2 = n2;//错误,原因:如果是变量赋值,先判断类型
char c1 = b1;//错误,原因:byte不能自动转成char

  3. byte, short, char 他们三者可以计算,在计算时首先转换为int类型.

    byte b2 = 1;
byte b3 = 1;

short s1 = 1;
short s2 = b2+s1;//错误,b2 + s1 => int
//只要出现byte\short\char都会转换成先int再计算
byte b4 = b2 + b3; //错误:b2 + b3 => int

  4. 自动提升原则:表达式结果的类型自动提升为 操作数中最大的类型.

强制类型转换

  1. 使用时,要加上强制转换符( ),但可能造成精度的损失!!!

  2. 强转符合只针对最近的操作数有效,往往使用小括号提升优先级

    int x = (int)10*3.5*6*1.5;//编译错误:double -> int
int x = (int)(10*3.5*6*1.5); //44

基本数据类型和String类型的转换

  1. 基本类型转String类型

    img

  2. String类型转基本数据类型

    通过基本类型的包装类调用parseXX方法

    img

运算符

//  / 除法的使用
System.out.println(10 / 4); // 2
System.out.println(10.0 / 4);//2.5
double d = 10 / 4; //2.0

//  % 取模,取余
// 在 % 的本质 看一个公式 a % b = a - a / b * b
//当a是小数时, 即公式 = a - (int)a / b * b
System.out.println(10 % 3); //1
System.out.println(-10 % 4);//-1
System.out.println(10 % -3);// 1
System.out.println(10 % 4);// -1

//  ++的使用
//  ++作为单独语句使用都是 i = i + 1;
//  ++作为表达式使用:前++ : ++i先自增后赋值/后++ : i++先赋值后自增
int i = 1;
i = i++;
System.out.println(i);
//java规则使用到了临时变量:(1)temp = i;(2)i=i+1;(3)i=temp;

1.  result = 59 / 7 // 8
    result = 59 % 7 // 4   8个星期4天
    
2.  double huas = 234.5;
    double ss = 5/9*(234.5-100);

逻辑运算符

&& 和 & 使用区别

  1. &&短路与: 如果第一个条件为false, 则第二个条件不会判断,最终结果为false, 效率高.
  2. & 逻辑与: 不管第一个条件判断是不是false,第二个条件还是会判断,效率低.
  3. 开发中,我们使用短路与&& ,效率高

|| 和 |使用区别

img

赋值运算符

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

byte b = 3;
b += 2;//b = b + 2;  实际上真正等价于 b = (byte)(b + 2);
b++;// 等价于 b = (byte)(b + 1);
//如果直接写
b = b + 2;//是错误的,类型是int型

三元运算符

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

运算规则:

  1. 如果条件表达式为true, 运算后的结果是表达式1;

  2. 如果条件表达式为false, 运算后的结果是表达式2;

    口诀: 一真大师

int a = 10;
int b =99;
int result = a > b? a++:b--
    //条件表达式为假/运行b--
    //结果为:先返回b的值,然后在 b-1
    //返回结果为99

细节:

  1. 表达式1和表达式2要为可以赋给接收变量的类型(或自动转换)

    int a = 3;
int b = 8;
int c = a > b? 1.1 : 2.3//语法错误
int c = a > b? (int)1.1 : (int)2.3//可以的
double d = a > b? a : b + 3;//可以的,满足int -> double

  2. 三元运算符是一个整体

    Object obj1 = true? new Integer(1) : new Double(2.0);
System.out.println(obj1);
//输出的是1.0,而不是1 
//注意三元运算符是一个整体,会优先转换成最高精度的类型,再计算输出等

  3. 三元运算符可以转换从if(…)else 语句

    //实现三个数的最大值
int n1 = 553;
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);

四种进制

二进制, 满2进1. 以0b或0B开头.

//二进制转换成八进制
//从低位开始,将二进制数每三位一组,转成对应的八进制数即可

//二进制转换成十六进制
//从低位开始,将二进制数每四位一组,转成对应的十六进制数即可

十进制, 满10进1.

//十进制转换成二进制
//将该数不断除以2,直到商为0为止,然后将每步得到的余数倒过来,就是对应的二进制

//十进制转换成八进制
//将该数不断除以8,直到商为0为止,然后将每步得到的余数倒过来,就是对应的二进制

//十进制转换成十六进制
//将该数不断除以16,直到商为0为止,然后将每步得到的余数倒过来,就是对应的二进制

八进制, 0-7, 满8进1. 以数字0开头表示.

//八进制转换成十进制
//从最低位(右边)开始,将每个位上的数提取出来,乘以8的(位数-1)次方,求和
eg:0234转成十进制的数
    0234 = 4*8^0 + 3*8^1 + 2*8^2 =
    4 +24 +128 =156

//八进制转换成二进制
//将八进制数每1位,转成对应的一个3位的二进制数

十六进制, 0-9及A-F, 满16进1. 以0x或0X开头表示

//十六进制转换成十进制
//从最低位(右边)开始,将每个位上的数提取出来,乘以16的(位数-1)次方,求和
eg:0x23A转成十进制的数
    0x23A = 10*16^0 + 3*16^1 + 2*16^2 = 570 
    
//十六进制转换成二进制
//将十六进制数每1位,转成对应的一个4位的二进制数

原码\反码\补码

  1. 二进制的最高位(最左边)是符号位: 0表示正数, 1表示负数(老韩口诀:旋转90° 0 -> 0 1 -> -)
  2. 正数的原码, 反码, 补码都一样(三码合一)
  3. 负数的反码 = 它的原码符号位不变, 其他位取反(0 -> 1, 1 -> 0)
  4. 负数的补码 = 负数的反码 + 1, 负数的反码 = 负数的补码 - 1
  5. 0的反码,补码都是0
  6. java没有无符号数,换言之, Java中的数都是有符号的
  7. 在计算机运算的时候, 都是以补码的方式来运算的
  8. 当我们看运算结果的时候, 要看他的原码(!!!)

位运算符

7个位运算符(& , | , ^ , ~ , >> , << , >>>)

按位与&

img

按位或 | : 两位中有一个为1,结果为1

按位异或^ : 两位不同时为1, 相同为0

算术右移 >> :低位溢出, 符号位不变, 并用符号位补溢出的高位 (如果是正数的话 本质是右移几位就除几次2)

算术左移 << :符号位不变, 低位补0 (如果是正数的话 本质是左移几位就乘几次2)

img

img

逻辑右移也叫无符号右移 >>> : 低位溢出, 高位补0

经典面试题

//计算 -10.5%3 = ?
//a % b 当a是小数时,公式 = a - (int)a/b*b
//-10.5%3 = -10.5 - (-10)/3*3 = -10.5 + 9 = -1.5
//注意: 有小数运算,得到结果是近似值
System.out.println(-10.5%3);

程序流程控制

switch

  1. switch 关键字, 表示switch分支
  2. 表达式 对应一个值
  3. case 常量1: 当表达式的值等于常量1, 就执行 语句块1
  4. break: 表示退出switch
  5. 如果和case 常量1匹配, 就执行语句块1, 如果没有匹配, 就继续匹配case 常量2
  6. 如果一个都没有匹配上, 执行default

switch细节

  1. 表达式数据类型, 应和case后的常量类型一致, 或者是可以自动转成可以相互比较的类型, 比如输入的是字符, 而常量是int

    char c = 'a';
switch(c){
    case 20 :
            System.out.println("ok");
            break;
    case 'a':
            System.out.println("ok1");
    default :
            System.out.println("ok2");
}

  2. switch(表达式)中表达式的返回值必须是:(byte, short, int, char, enum[枚举], String)

  3. case子句中的值必须是常量, 而不能是变量

  4. default子句是可选的

  5. break语句是用来在执行完一个case分支后使程序跳出switch语句块, 如果没有写break, 会出现穿透现象(程序会顺序执行到switch结尾)

return

当return用在方法时, 表示跳出方法, 如果使用在main, 表示退出程序

谁调用(接收), 就返回给谁

int returnRes = p1.getSum(10,20);
//把方法 getSum 返回的值 ,赋给 变量 returnRes
文章作者: 冬瓜冬瓜排骨汤
文章链接: http://dd-smile.github.io/2019/12/22/java-note-000/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 冬瓜冬瓜排骨汤 !
Java
  目录