Java学习笔记01 -- 数据类型-CSDN博客

本文链接：https://blog.csdn.net/xiexing_zxy/article/details/138417579

数据类型

Java数据类型分为基本数据类型和引用数据类型

基本数据类型分为

赋值型
字符型
布尔型

赋值型:又分为整形和浮点型

整形就是用来存放整数的数据类型: byte , short , int , long

它们的取值范围分别是:

整形内存空间(8位等于1字节) 取值范围
byte 8位 -128 ~ 127
short 16位 -32768 ~ 32767
int 32位 -2147483648 ~ 2142147483647
long 64位 -9223372036854775808 ~ 9223372036854775807
(注意：Java默认的整形是int型，声明long形常量后面必须加“ l ” 或者 “ L ”)
浮点型就是用来存放小数的数据类型: float , double

它们的取值范围分别是:

浮点型内存空间取值范围
float 32位 1.4E-45 ~ 3.4028235E38
double 64位 4.9E-324 ~ 1.7976931348623157E308
(注意：Java默认的浮点形是double型，声明float形常量后面必须加“ f ” 或者 “ F ”)
```
//浮点数使用陷阱
double num1 = 2.7;
double num2 = 8.1/3;
System.out.println(num1);//2.7
System.out.println(num2);//无限接近2.7
//重点:对运算结果是小数的进行相等判断时要小心
//细节:不是计算得到而是直接赋予，可以判断相等
```

整形	内存空间(8位等于1字节)	取值范围
byte	8位	-128 ~ 127
short	16位	-32768 ~ 32767
int	32位	-2147483648 ~ 2142147483647
long	64位	-9223372036854775808 ~ 9223372036854775807

浮点型	内存空间	取值范围
float	32位	1.4E-45 ~ 3.4028235E38
double	64位	4.9E-324 ~ 1.7976931348623157E308

字符型

字符型char用于存储单个字符，占用16位(两个字节)的内存空间。在定义字符型变量时要以单引号表示:

//例子
    char a1 = 65;
    System.out.println(a1);//输出65代表的那一个字符，结果为A (这里涉及到了ASC||码值，可以上网去查)

字符型的本质: 字符型存储到计算机中需要将字符对应的码值找出来
a ==> 码值97 ==> 二进制 ==> 存储
二进制 ==> 97 ==> a ==> 显示

布尔型

布尔类型又称逻辑类型，通过boolean来定义布尔型变量，只有true和false两个值，分别代表布尔型中的 “真” 和 “假”。

boolean类型不参与转换

//例子
boolean a1 = true;//定义一个布尔型变量 a1=真
	if(ai==ture){//if判断a1是否为真
        System.out.println("真");//为真输出这句话
    }else{
        System.out.println("假");//否则为假输出这句话
    }

数据类型的装换

自动类型转换

精度小的数据类型转换为精度大的数据类型

（char > int > long > float > double）

（byte > short > int > long > float > double）

//例子
    int a = 'a';//char类型转换int
    double b = 100;
    System.out.println(a);//结果为a对应的整数97
    System.out.println(b);//整数转小数输出会加小数点,结果100.0
    //byte,short,char之间不会相互自动转换

byte,short,char三者可以运算，在计算时首先转为int类型

//例子	
	byte a1 = 10;
	byte a5 = 10;
	short a2 = 10;
	//byte a6 = a1 + a2;   错误，因为是int类型
	//short a3 = a1 + a2;   错误：a1+a2等于int类型
	int a4 = a1+ a2;
	System.out.println(a4);

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

//例子
    byte q1 = 1;
    short q2 = 10;
    int q3 = 20;
    double q4 = 50.5;
    double q5 = q1 + q2 + q3 +q4;
    //int q6 = q1 + q2 + q3 +q4;
    System.out.println(q5);//输出为最大的数据类型double，否者报错

强制类型转换

将容量大的转换为容量小的，但可能造成精度降低或者溢出，要注意

//例子1
	int a = (int)1.9;//把double类型数据强制转换为int类型
	System.out.println(a);//结果为1

	int a1 = 1000;
	byte b = (byte)a1;
	System.out.println(b);//造成数据溢出

//例子2
		char c1 = 97;
		int z = 97;
		//char c2 = z;  char类型可以保存int的常量，不能保存int变量，需要强转
		char c3 = (char)z;
		System.out.println(c3);//结果为a
		//byte,short,char在计算时首先转为int类型,需要强转

//例子3
	//强转符号只针对最近的操作数有效，往往会使用小括号提升优先级
		/*int x = (int)10*3.5+6*2.5;
		 * System.out.println(x);
		 * 只把10转换成了int类型，后面输出的结果还是double
		 */

		int x = (int)(10*3.5+6*2.5);
		//先算的结果=50，然后 转换(int)50 结果=50
		System.out.println(x);

基本数据类型和String转换

语法：基本类型的值 + " " 即可

int a1 = 100;
float f1 = 1.1f;
double b1 = 4.5;
boolean c1 = true;
String s1 = a1 + "";//int型a1的值加上"" 赋给String s1
String s2 = f1 + "";
String s3 = b1 + "";
String s4 = c1 + "";
System.out.println(s1+"\n"+s2+"\n"+s3+"\n"+s4+"\n");

运算符

算数运算符
关系运算符
逻辑运算符
赋值运算符
三元运算符
位运算符

算数运算符

// 	+ 号的使用
System.out.println(10+4);//结果=14

// 	- 号的使用
System.out.println(10-4);//结果=6

// 	* 号的使用
System.out.println(10*4);//结果=40

// 	/ 号的使用
System.out.println(10/4);//在java中结果等于2
System.out.println(10.0/4);//结果=2.5
double d = 10/4;//先算出结果等于2
System.out.println(d);//输出d把2在赋值给double，结果等于2.0

% (取模，取余) 的使用：得出的结果是那个数的余数

//例子
    System.out.println(10%7);//结果等于3，%取的是10/7的余数
    System.out.println(25%12);//结果=1
    System.out.println(100%30);//结果=10
    System.out.println(56%17);//结果=5
    System.out.println(-89%15);//结果=-14
    System.out.println(10%-3);//结果=1

在%的本质 =>公式：a%b=a-a/b*b
10%-3 => 10-10 /-3 * -3 =>10-(-3)*3=>10-9

关系运算符

关系运算符（比较运算符）:只返回两个值 (true真) 或 (false假)

==（相等）	!=（不相等）
<（小于）	>（大于）
<=（小于等于）	>=（大于等于）

//例子
    int a = 10;
    int b = 9;
    System.out.println(a==b);//结果(false假)
    System.out.println(a!=b);//结果(ture真)
    System.out.println(a<b);//结果(false假)
    System.out.println(a>b);//结果(ture真)
    System.out.println(a<=b);//结果(false假)
    System.out.println(a>=b);//结果(ture真)
    boolean flag = a > b;
    System.out.println("flag="+flag);//结果flag=(ture真)

逻辑运算符

逻辑运算符:用于连接多个条件(多个关系表达式)最终结果也是boolean值

短路与 (&&)	短路或 (\|\|)	取反 (!)
逻辑与 (&)	逻辑或 (\|)	逻辑异或 (^)

短路与(&&) 逻辑与(&) 的使用

//例子		
    int age = 50;
    if(age > 20 && age < 92){
        System.out.println("输出这句话");
    }
    //短路与(&&)规则：当a和b都为(ture真),则结果为(ture真),否则为(false假)

    int day = 50;
    if(day > 20 & day < 92){
        System.out.println("继续输出这句话");
    }
    //逻辑与(&)规则：当a和b都为(ture真),则结果为(ture真),否则为(false假)

    /*  &&	和 & 的使用区别
     * 短路与(&&):如果第一个条件为false，则第二个条件不会判断，最终结果为false(效率高)
     * 逻辑与(&):不管第一个条件是否为false，第二个条件都要判断，效率低
     * 在开发中，基本都是使用短路与(&&)，因为效率高
     */

短路或(||) 逻辑或(|) 的使用

//例子		
    int age = 50;
    if(age > 20 || age < 30){
        System.out.println("输出这句话"); 
    }
    //短路或(||)的规则:a和b中只要有一个为true，结果为true，否则为false

    int day = 50;
    if(day > 20 | day < 30){
        System.out.println("继续输出这句话");
    }
    //逻辑或(|)的规则:a和b中只要有一个为true，结果为true，否则为false
    /*  ||	和	|的使用区别
     * 短路或(||):如果第一个条件为(真)true，则第二个条件不会判断，最终结果为true(效率高)
     (如果第一个条件为(假)false,则继续判断第二个条件，如果为真结果(真)true)
     * 逻辑或(|):不管第一个条件是否为(真)true，第二个条件都要判断，效率低
     * 在开发中，基本都是使用短路或(||)，因为效率高
     */

取反(!) 逻辑异或(^) 的使用

//例子		
    int a = 10;
    int b = 20;
    if(!(a<b)) {//a<b为真，取反操作为假所以不会输出这句话
        System.out.println("输出这句话");
    }
    System.out.println(60>20);
    System.out.println(!(60>20));
    //取反(!)的规则:如果条件本身成立，则结果为假false，否则为真true

    int age = 50;
    int num = 60;
    if((age < 60) ^ (num > 50)) {//(age < 60)为真，(age01 > 50)为真
        System.out.println("输出这句话");//根据逻辑异或(^)的规则所以不会输出这句话
    }
    boolean c = (10>5) ^ (20<30);
    //          a(true)  b(true)
    System.out.println("c="+c);
    //逻辑异或(^)的规则:当a和b不同时结果为真true，否则为假false

赋值运算符

基本赋值运算符： =
复合赋值运算符：+= -= = /= %=*

//例子
    int a = 10;
    int b = 20;
    a += b;//是a = a + b;的简写，其他复合运算符的使用是一个道理
    System.out.println(a);

    /*赋值运算符的特点
     * 运算顺序从右往左
     * 赋值运算符的左边，只能是变量，右边可以是变量，表达式，常量值
     * 复合赋值运算符会进行类型转换
     */
    //复合赋值运算符在进行运算的时候会有一个强制转换
    byte c = 2;
    c += 3;//等价 b=(byte)(b+2);
    c++;//b=(byte)(b+1);
    System.out.println(c);

三元运算符

三元运算符
基本语法: 条件表达式?表达式1:表达式2;
如果条件表达式为true(真),运算后的结果是表达式1;
如果条件表达式为false(假),运算后的结果是表达式2;

//例子
    int a = 10;
    int b = 20;
    int c = a>b ? a++ : b--;//因为10>20为false(假)使用会执行表达式2,b--
    //  条件表达式   1     2
    System.out.println(c);//先赋值，再自减

    /*三元运算符细节
     * 表达式1和表达式2要为,可以赋给接收变量的类型(或可以自动转换/强制转换)
     */
    int s = 5;
    int z = 10;
    //int w = s<z ? 1.1 : 3.4;
    int w = s<z ? (int)1.1 : (int)3.4;
    double q = s<z ? 1.1 : 3.4;
    System.out.println(w);
    System.out.println(q);
    //三元表达式可以转换成if--else语句
    if(s<z) {
        System.out.println(1.1);
    }else {
        System.out.println(3.4);
    }

位运算符

/*
 * 安位与   (&): 两位全为1,结果为1
 * 安位或   (|): 两位有一个为1,结果为1,否则为0
 * 安位异或(^): 两位一个为0,一个为1,结果为1,否则为0
 * 安位取反(~): 0>1 , 1>0
 * 
 * >>  <<  >>>
 * 
 */
/* 1.先得到2的补码=>00000000 00000000 00000000 00000010
 *  再得到2的原码=>00000000 00000000 00000000 00000010
 *  
 *(计算机运算的时候都是以补码的方式来运算的,
 *  当我们看运算结果的时候要看它的原码)
 *  
 * 2.得到3的补码=>00000000 00000000 00000000 00000011
 *  再得到3的原码=>00000000 00000000 00000000 00000011
 *  
 *  安位&：
 *       0000000000000 00000000 000 00000010
 *       00000000 00000000 00000000 00000011
 *  结果:00000000 00000000 00000000 00000010 补码
 *  再转成原码:
 *  00000000 00000000 00000000 00000010
 */

System.out.println(2&3);//2

/*1.先得到-2的原码=> 10000000 00000000 00000000 00000010
 *2. -2的 反码 => 11111111 11111111 11111111 11111101
 *3. 12的 补码 => 11111111 11111111 11111111 11111110
 *4. ~-2操作=>   00000000 00000000 00000000 00000001
 *5. 运算后的原码 00000000 00000000 00000000 00000001=>1
 */
System.out.println(~-2);//1

/*1.得到2的补码 => 00000000 00000000 00000000 00000010
 *2. ~2操作 => 11111111 11111111 11111111 11111101
 *3.运算后的反码 =>11111111 11111111 11111111 11111100  运算后的补码
 *4.运算后的原码 => 10000000 00000000 00000000 00000011
 */
System.out.println(~2);

/* 算数右移 >>: 低位溢出，符号位不变，并用符号位补溢出的高位
 * 算数左移 <<: 符号位不变，低位补0
 * 逻辑右移>>>: 低位溢出，高位补零
 */
int a = 1>>2;//00000000 00000000 00000000 00000000 (01扔掉)
//    1 / 2 / 2
int b = 1<<2;//00000000 00000000 00000000 00000100
//    1 * 2 * 2 
System.out.println(a);//0
System.out.println(b);//4

++（自增）和 - -（自减）

//++的使用：独立使用前++和后++一样
int i=10;
i++;//自增  等价于i=i+1  结果=11
++i;//自增  等价于i=i+1  结果=12
System.out.println(i);

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

int a = 8;
int b = a++;// 先赋值b=a; 再自增a=a+1;
System.out.println("a="+a+"b="+b);//9  8

//--的使用，和++同理
 int c =10;
 c--; //c=10-1;  c=9;
 --c;//c=9-1;  c=8;
 System.out.println(c);//8

 int y = 10;
 int o = --y;  //y=y-1; k=y;
 System.out.println("y="+y+"o="+o);//9  9

 int p = 10;
 int q = p--;  //q=10; p=10-1;
 System.out.println("p="+p+"q="+q);//9  10

演示一个接收用户输入

package demo2;

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

public class day8 {

	public static void main(String[] args) {
		/*演示接收用户的输入：
		 * 先引入Scanner类所在的包
		 * 创建Scanner对象 new一个对象
		 * myScanner 就是 Scanner 对象的名字(这个名字可以是任意的)
		 */
		Scanner myscanner = new Scanner(System.in);
		//接收用户输入，使用相关方法
		System.out.println("请输入名字");
		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+"\n"+"年龄:"+age+"\n"+"薪水:"+sal+"\n");
	}
}