java基础2

1. java中的数据类型

1. 基本数据类型和引用数据类型

// 数据类型： ①基本数据类型， ②引用数据类型
// 除了8中基本数据类型之外，其他都是应用类型
public class DateTypeDemo{
    public static void main(String[] args){
        int a;
        a = 10;
        System.out.println(a);  // 输出的是a的数据值， 因为a是基本数据类型
        int[] arr = new int[10]; // 数组创建之后，每个元素初始化为0。
        System.out.println(arr); // [I@43a25848] , 输出的是变量arr 对应的 数据的引用地址， 因为arr 中保存的是引用地址。   // arr是引用类型
        Scanner scanner = new Scanner(System.in);  //  变量scanner是引用类型。
        System.out.println(scanner);  //  变量scanner是引用类型
        double m = 1.5;
        System.out.println(m); // 基本数据类型
    }
}

2. java中的8种基本数据类型

2. int类型的使用

• int是最常用的整数类型。一个int类型占用4个字节（32位），

  最大表示范围为：-2147483648 ~ 2147483647

• 整数类型的直接量（literal）默认是int类型。

  int a =100;

  int b = 10000000000; // 编译错误：直接量超出了整整型的范围

• 整数直接量，需要注意一下两点：

  ​ -整数直接量默认是int类型，那么就不能超过int 类型能表示的数据范围。

  ​ -整数直接量，除了可以用十进制表示以外，还可以用十六进制表示（以0x或0X开头），八进制表示（以0开头）。

• 两个int整数相除（/），结果取整，舍弃小数部分（非四舍五入），结果还是整数

	// eg1:
	int a = 5/3;  // 取整
	// eg2:
	int currentProgress = 33;
	int totalProgress / totalProgress * 100; // 结果percent = 0
	System.out.println(percent+"%");  // 0%
	percent = 100*currentProgress / totalProgress;  // 结果66
	System.out.println(percent+"%");  // 66%

• 整数运算要防止溢出

  -整数运算的过程中，运算结果，如果超过了整数能表示的最大范围，会发生溢出。

  ​ 正数过大溢出，结果变为负数；负数过小溢出，结果变为正数

		// 整数运算要防止溢出
		int max = Integer.MAX_VALUE;
		System.out.println("---------正数溢出变为负数---------");
		System.out.println(max + 1); // -2147483648
		int min = Integer.MIN_VALUE;
		System.out.println("----------负数溢出变为正数---------------");
		System.out.println(min - 1); // 2147483647
		// 通过改变参与运算的数据类型，避免溢出。
		//  *** java中规定，数据运算的结果，以范围大的数据类型为准。
		// max + 1L： 参与运算的数据结果，以大类型为准。
		long max1 = (long)(max1 + 1L); // int 运行的结果就是int类型， int + long运算结果就是long类型
		long min1 = (long)(min1 - 1L);
		System.out.println("最大值+1：" + max1);  //2147483648
		System.out.println("最小值-1：" + min1); //-2147483649

java中规定，数据运算的结果，以范围大的数据类型为准

		int k1 = 30;
		long k2 = 300;
		float k3 = 3.3F;  // 字面量后加F ， 就表示是float类型,如果不加，则编译错误：大类型转 小类型需要强转
		double k4 = 2.5; // 字面量2.5 ， 默认是double类型。
		// k1 + k2 是long
		long sum = k1 + k2;
		// k1 + k2 + k3 是float
		float sum1 = k1 + k2 + k3;
		// k1 + k2 + k4 是double
		double sum2 = k1 + k2 + k4;
		// k1 + k2 + k3 + k4 是double
		double sum3 = k1 + k2 + k3 + k4;
		

3. long类型的使用

• 如果要表示的整数已经超过了int的范围，那么可以用long类型定义变量，保存数据。

  ​ long类型数据范围（8个字节，64位）：

  ​ -9223372036854775808~9223372036854775807

  ​ long类型直接量的表示，需要在数据后面加上一个L或l；

  ​ eg: long data1 = 10000000000; // 编译错误： 100亿

  ​ long data2 = 10000000000L;

  ​ long data3 = 10000000000l;

• 通过long类型来存储系统当前毫秒数，jdk提供了一个方法（System.currentTimeMillis()），来获取从1970.1.1日零时至今的毫秒数，返回结果为long。

  eg： long times = System.currentTimeMillis();

  ​ System.out.println(times);

• 对于较大的整数运算（超出int范围），可以使用long型。

public static void main(String[] args){
      long time = System.currentTimeMillis();
    System.out.println(time);
    // int time1 = time;  // 数据类型不匹配（大范围的数据值，不能直接赋值给小范围的）
    // 强制数据类型转换。 （可能会溢出）
    int time1 = (int)time;  // 解决了语法错误。因为time数值大于int的最大值，所以这里溢出。
    System.out.println(time1); //1741132227
    // 对于较大的整数运算（超出int范围），可是使用long型
    // 三个1000相乘*10
    long one = 1000*1000*1000*10;
    System.out.println(one); 1410065408 --- 溢出了
    long two = 1000*1000*1000*10L;
    System.out.println(two); // 10000000000-- 100亿。运算结果由大的数据范围决定。
    // 2个1000*1000*10；
    //在Java中,表达式的计算顺序是从左往右的,也就是先计算左侧的结果,再计算右侧的结果
    long three = 1000*1000*10000*10L; //还没计算到10L就已经溢出 ，虽然10L字面量是float类型
    System.out.println(three); // 14100654080 -- 溢出了
    long four = 1000L*1000*10000*10; // 开头计算就遇到float类型，范围扩大，不会溢出
    System.out.println(four); // 100000000000 , 先保证运算结果就是long了，避免数据的溢出
  }

4. double & float的使用

• 所谓的浮点类型就是小数类型，包含double和float。

  浮点类型的默认直接量是double类型。

  如果要使用float类型，需要在数据后面加F或f。

  double类型的精度比float类型的精度高，因此，一般用double类型。

  eg

  float f1 = 3.3F;

  double money = 3.5;

• double类型数据运算的时候，会有舍入误差。

  由于舍入误差，导致浮点数不能精确运算。二进制中无法表示1/10，就像十进制中无法精确表示1/3，所以二进制表示浮点数存在误差

  eg:

  double a = 3.0;

  double b = 2.9;

  double c = a - b;

  System.out.println©;

public class DoubleDemo{
  public static void main(String[] args){
      double a = 1.5;
    // float b = a;  // a 是大的数据类型， 直接赋值给小类型，出现错误。
    float b = (float)a; // 强制类型转换
    // float c = 1.5; //编译错误：java中默认浮点数是double类型
    float c = 1.5F; // 在数据类型之后添加F/f， 让直接量是float类型
    double d = 2.0F; // 小类型的数据，可以直接赋值大类型的数据。
    float e = 2;  // 2 是int（直接量）类型，小类型的数据，可以直接赋值大类型的数据
    // double 类型数据运算的时候，会有舍入误差。
    double a1 = 3.0;
    double a2 = 2.9;
    System.out.println(a1-a2); // 0.10000000000000009
    System.out.println(a1+a2); //
    System.out.println(a1*a2); //
    System.out.println(a1/a2); //
    System.out.println("---------BigDecimal类型的使用-----------");
    BigDecimal bigDecimal = new BigDecimal("3.0");
    BigDecimal bigDecimal1 = new BigDecimal("2.9");
    BigDecimal bi = bigDecimal.subtract(bigDecimal1); // subtract  -- 减法
    System.out.println(bi);
    System.out.println("---------BigInteger类型的使用-----------");
    BigInteger bigInteger = new BigInteger("92233720368547758070");//long的最大值:9223372036854775807
    System.out.println(bigInteger);
    BigInteger bigInteger1 = new BigInteger("100");
    BigInteger bi1 = bigInteger.divide(bigInteger1); // divide -- 除法运算
    System.out.println(bi1);
  }
}

5. char类型的使用

• 字符类型实质上是一个16位的无符号整数，这是整数对应的字符编码

  Java字符类型采用Unicode字符集编码。Unicode字符编码是国际上通用的定长字符集，所有字符都是16位。

  字符直接量，可以采用字符集的形式，比如’中‘；

  或者采用Unicode编码的方式，比如char c = ‘A’ ; int a = 10 + c; // 75(65+10)

• 字符直接量赋值

  整数赋值（0~65536）

  Unicode编码赋值

  ​ eg: char a = ‘A’;

  ​ char a = 65;

  ​ char a = ‘\u0045’;

• char类型–转义字符：转义字符（\)：对于不方便输出的字符，采用转义字符表示。

  

// char类型的使用
char c1 = 'a';  // 'a' -- 单引号表示char类型。
// char c2 = "a"; // 编译错误： -- 双引号表示String类型。
// char的本质是整数
int a1 = c1;  // c1 的本质及时整数
a1 = c1 + 1; // char类型可以做数学运算
// int是4个字节，char是2个字节。大数据不能直接赋值给小数据。
// char c2 = a1;  // 编译错误
char c2 = (char)a1;
System.out.println("c2:"+c2);

// short ： 短整型 ， 2 个字节
short s1 = 99;
char c3 = (char)s1;
// byte ：整形， 1个字节

byte s2 = 100;
char c4 = (char)s2;
System.out.println("c3:"+c3);
System.out.println("c4:"+c4);

6. 变量使用

// ***变量命名遵循java得到命名规则，先定义变量，再使用变量。在使用变量之前，需要先对变量进行初始化
public class Demo1{
    public static void main(String[] args) {
        // 1. 一条语句声明三个整形变量：a , b , c
        int a, b ,c;
        // 2. 输出变量
        // Sysytem.out.println(a); // 编译错误：先初始化，再使用
        // 3.给变量b赋值为5，给变量c赋值为6；
        // b = 5，c = 6； // 编译错误：赋值语句结束，要使用“；”，不能使用”，“
        // 4.声明boolean类型变量b，初始化为false
        // boolean b = false;  // 编译错误：同代码区域内，不允许变量名重复
		// 5.声明boolean类型变量m，赋值为b>c
        // boolean m = b > c; // 编译错误：先初始化，再使用
        // 6.声明double类型变量A， 赋值为5.
        double A = 5;
        // 7. 输出double类型变量B的值
        double B;
        // System.out.println(B);// 编译错误：先初始化，再使用
        // 8. 声明long类型变量 *，赋值为10
        // long * = 10; // 编译错误：不符合变量命名规则（只能出现：字母，数字，_,$）
        // 9.声明long类型变量goto，赋值为20
        // long goto = 20;  // 编译错误：不能使用关键字做变量名。
        // 10.一条语句声明三个在整型变量，a1，a2，a3， 分别赋值为1,2,3，输出三个数据的乘积。
        int a1=1,a2=2,a3=3;
        System.out.println("乘积："+a1*a2*a3);
        // 11.声明一个String类型变量address， 赋值为"hello world";
        String address = "hello world";
		// 12.输出变量addrses
        // System.out.println(addrses); // 编译错误： 先定义变量，再使用变量 
    }
}