JAVA预习计划-数据类型

变量和类型

变量是存在内存里面的

输入设备比如键盘，输出设备比如屏幕

外存储器相当于磁盘，u盘之类的

那么内存储器 也就是内存 也叫做 RAM 这个是变量存储的地方，也就是运行程序用的

整型变量

和c语言不一样，int在哪也就四个字节。

局部变量在未进行初始化的时候是不可以使用的。

int的取值范围

首先康康单位之间的关系

4个字节为32个比特位，而第一位是符号位，所以取值范围为-2^31 — 2^31-1（去掉0）

也可以用一个圆来表示，更加直观

最大值最小值

Integer.MAX_VALUE

Integer.MIN_VALUE

public class HelloWorld{

   public static void main(String[] args) {
      //int类型就4个字节 
      int max = Integer.MAX_VALUE;
      int min = Integer.MIN_VALUE;
   	System.out.println("HelloWord");
      System.out.println(max);
      System.out.println(min);
   }    
}

运行结果为

 给MAX_VALUE+1会变成最小值

给MIN_VALUE-1会变成最大值

长整型变量

public static void main1(String[] args) {
     long a = 10L;
     System.out.println("a = " + a);
     System.out.println("max=" +Long.MAX_VALUE);//拼接
     System.out.println("min=" +Long.MIN_VALUE);
     int b = 3;
     int c = 4;
     System.out.println(b+c);
     //注意：任何类型的数据和字符串进行拼接 结果就是字符串
     //可以加括号（b+c）
     System.out.println("hhh"+b+c);

赋值的时候值的后面要加上L；包装类是Long

双精度浮点型

和c语言一样，包装类是Double

单精度浮点型

赋值的时候后面要加 f ，值得注意的是double不可赋值给float 这点也体现了Java的安全性。

字符类型变量

也一样

包装类型是Character

public class HelloWorld {
public static void main(String[] args) {
   char a = 'a';
   char b = '高';
   char c = 97;
   System.out.println(a);
   System.out.println(b);
   System.out.println(c);
}
}

字节类型

1个字节范围在-127 - 128之间

public class HelloWorld {
   public static void main(String[] args) {
   
      byte a = 12;
      byte c = 21;
      System.out.println(a+" "+c);
      System.out.println(Byte.MAX_VALUE);
      System.out.println(Byte.MIN_VALUE);
      System.out.println(Byte.MAX_VALUE+1);
   }
  
}

  按照int类型举一反一，byte最大值+1应该是最小值，但是println默认打印的是int类型不是byte类型，所以不可以。

类型提升

小于四个字节的数据类型运算的时候会发生类型的提升

这样会报错

byte b = 20;
byte c = 10;
byte d = b+c;

这样的情况需要强制转换类型来避免

byte d = (byte)(b+c);

 即可

如图，会报错

      byte d = Byte.MAX_VALUE+1;
      System.out.println(d);

短整型

没差别

布尔类型

只有两种取值，true 和 false 

没有0为假，非0为真的说法

public class HelloWorld {
  public static void main(String[] args) {
   boolean value = true ;
   System.out.println(value);
  }
}

总结

Java当中的8种基本数据类型分别是以下的:

字节数       1           2                2                4             8          4          8          没有规定     

数据类型  byte     char            short           int          long     float    double     boolean

包装类     Byte   Character     Short       Integer       long    Float    Double    Boolean

字符串类型

与c语言不同，不用创建字符数组就可以打印字符串

public class HelloWorld {
  public static void main(String[] args) {
    String str = "\"hello\"";//"hello"
   System.out.println(str);
  }
}

转义字符

String str = "\"hello\"";//"hello"

在符号前面加 \ 即可

字符串拼接

字符串可以用 + 拼接

String a = "hello"; 
String b = "world"; 
String c = a + b; 
System.out.println(c); 

还可以用字符串与整数进行拼接

String str = "result = "; 
int a = 10; 
int b = 20; 
String result = str + a + b; 
System.out.println(result); 
// 执行结果
result = 1020

只要 + 存在，就是拼接行为

因此我们可以很方便的使用 System.out.println 同时打印多个字符串或数字

int a = 10; 
int b = 20; 
System.out.println("a = " + a + ",b = " + b)

常量

字面常量

10 // int 字面值常量(十进制) 
010 // int 字面值常量(八进制) 由数字 0 开头. 010 也就是十进制的 8 
0x10 // int 字面值常量(十六进制) 由数字 0x 开头. 0x10 也就是十进制的 16 
10L // long 字面值常量. 也可以写作 10l (小写的L) 
1.0 // double 字面值常量. 也可以写作 1.0d 或者 1.0D 
1.5e2 // double 字面值常量. 科学计数法表示. 相当于 1.5 * 10^2 
1.0f // float 字面值常量, 也可以写作 1.0F 
true // boolen 字面值常量, 同样的还有 false 
'a' // char 字面值常量, 单引号中只能有一个字符
"abc" // String 字面值常量, 双引号中可以有多个字符. 

被final修饰的常量

放在变量的数据类型前，但是不可以二次改变

final int a = 10；
a = 99 ； //不可以进行二次修改

类型转换

int 和 long/double 相互赋值

可以由小赋大，但是反过来不可以。

int a = 10; 
long b = 20; 
a = b; // 编译出错, 提示可能会损失精度. 
b = a; // 编译通过. 
int a = 10; 
double b = 1.0; 
a = b; // 编译出错, 提示可能会损失精度. 
b = a; // 编译通过.

int 和 boolean 相互赋值

int a = 10; 
boolean b = true; 
b = a; // 编译出错, 提示不兼容的类型
a = b; // 编译出错, 提示不兼容的类型

毫不相干的类型不可以转换。

强制类型转换

可以解决一些情况，但可能会丢失精度。

和c语言一样，但是毫不相干的类型是不可以强转的。

int a = 0; 
double b = 10.5; 
a = (int)b; 
int a = 10; 
boolean b = false; 
b = (boolean)a; // 编译出错, 提示不兼容的类型.

理解数值提升

int 和 long 混合运算

int a = 10; 
long b = 20; 
int c = a + b; // 编译出错, 提示将 long 转成 int 会丢失精度
long d = a + b; // 编译通过

long类型和int类型结合会统一提升为long类型。

也就是说字节数小的会自动提升为字节数大的。

想要int接收就得强转。

byte 和 byte 的运算

java会自动将小于4个字节数的数据类型在计算时转换为int类型。

byte a = 10; 
byte b = 20; 
byte c = a + b; 
System.out.println(c); 
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
 byte c = a + b;

因此想计算就需要强转

byte c = (byte)(a+b);

int和string之间的类型转换

int转string

int a = 10；
String str1 = a+"";
String str2 = String.valueof(a);

string转int

String str = "100"; 
int num = Integer.parseInt(str);