Java 学习（4）：基本数据类型，变量类型

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

--- 基本数据类型

--- 变量类型

基本数据类型

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。

Java 的两大数据类型:

内置数据类型 ：Java语言提供了八种基本类型。六种数字类型（四个整数型(byte, short, int, long)，两个浮点型(float, double)），一种字符类型(char)，还有一种布尔型(boolean)。各类数据类型范围查询：

public class PrimitiveTypeTest {

    public static void main(String[] args) {

        // byte

        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);

        System.out.println("包装类：java.lang.Byte");

        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);

        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);

        System.out.println();  

        // short

        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);

        System.out.println("包装类：java.lang.Short");

        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);

        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);

        System.out.println();  

        // int

        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);

        System.out.println("包装类：java.lang.Integer");

        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);

        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);

        System.out.println();  

        // long

        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);

        System.out.println("包装类：java.lang.Long");

        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);

        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);

        System.out.println();  

        // float

        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);

        System.out.println("包装类：java.lang.Float");

        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);

        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);

        System.out.println();  

        // double

        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);

        System.out.println("包装类：java.lang.Double");

        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);

        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);

        System.out.println();  

        // char

        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);

        System.out.println("包装类：java.lang.Character");

        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台

        System.out.println("最小值：Character.MIN_VALUE="

                + (int) Character.MIN_VALUE);

        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台

        System.out.println("最大值：Character.MAX_VALUE="

                + (int) Character.MAX_VALUE);

    }

}

数值类型的基本类型的取值范围

实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析。

- 引用数据类型 ：在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，eg: Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
  - 对象、数组都是引用数据类型。
  - 所有引用类型的默认值都是null。
  - 一个引用变量可以用来引用与任何与之兼容的类型。
Java 在程序运行时，常量是不会被修改的量（在 Java 中使用 final 关键字来修饰常量），声明方式和变量类似：
```
final double PI = 3.1415927; //通常使用大写字母表示常量
```
byte、int、long、和 short 都可以用十进制、16进制以及8进制的方式来表示。当使用常量的时候，前缀0表示8进制，而前缀0x代表16进制。例如：
```
int decimal = ;

int octal = ;

int hexa =  0x64;
```
字符串常量和字符常量都可以包含任何Unicode字符。例如：char a = '\u0001';
```
符号    字符含义

\n    换行 (0x0a)

\r    回车 (0x0d)

\f    换页符(0x0c)

\b    退格 (0x08)

\s    空格 (0x20)

\t    制表符

\"    双引号

\'    单引号

\\    反斜杠

\ddd    八进制字符 (ddd)

\uxxxx    16进制Unicode字符 (xxxx)
```
Java语言支持一些特殊的转义字符序列
自动类型转换 ：整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。转换从低级到高级。
```
低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double 
```
数据类型转换必须满足如下规则：必须满足转换前的数据类型的位数要低于转换后的数据类型.
- 1. 不能对 boolean 类型进行类型转换。
- 2. 不能把对象类型转换成不相关类的对象。
- 3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
```
/* 强制类型转换

1. 条件是转换的数据类型必须是兼容的。

2. 格式：(type)value type是要强制类型转换后的数据类型 实例： */

int i1 = ;

byte b = (byte)i1; //强制类型转换为byte
```
- 4. 转换过程中可能导致溢出或损失精度。eg：
```
int i =;

byte b = (byte)i;  //因为byte类型时8位，最大值为127，所以当强制转换为int类型值128时候就会导致溢出。
```
- 5. ****** 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入 *****.eg:
```
(int)23.7 == ;

(int)-45.89f == -
```
- 6. 强制类型转换: 条件是转换的数据类型必须是兼容的。格式：(type)value, 其中 type 是要强制类型转换后的数据类型，eg：
```
public class QiangZhiZhuanHuan{

    public static void main(String[] args){

        int i1 = ;

        byte b = (byte)i1;//强制类型转换为byte

        System.out.println("int强制类型转换为byte后的值等于"+b);  //结果：int强制类型转换为byte后的值等于123

    }

}
```
- 7. 隐含强制类型转换
  - 1. 整数的默认类型是 int。
  - 2. 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f.

变量类型

在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：

type identifier [ = value][, identifier [= value] ...];  //type为数据类型,identifier是变量名

Java语言支持的变量类型有：

public class Variable{

    static int allClicks=;    // 类变量

    String str="hello world";  // 实例变量

    public void method(){

        int i =;  // 局部变量

    }

}

类变量（静态变量， 易用于常量定义 ）：独立于方法之外的变量，用 static 修饰。

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法构造方法和语句块之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
静态变量在程序开始时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过： ClassName.VariableName 的方式访问。

类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

import java.io.*;

public class Employee {

    private static double salary;  //类变量salary 是静态的私有变量

    public static final String DEPARTMENT = "开发人员";  // 类变量，static final 修饰，变量名一般大写，表明DEPARTMENT是一个常量

    public static void main(String args[]){

        salary = ;

        System.out.println( DEPARTMENT + "平均工资: " + salary);

    }

}
注意：如果其他类想要访问该变量，可以这样访问：Employee.DEPARTMENT

类变量赋值方法

无final修饰，可声明时赋值，构造器中赋值，静态语句块或静态方法赋值；

有final修饰，可声明时赋值，声明与赋值分开可在静态语句块中赋值。

public class StaticTest {

    private static int staticInt = ;  //类变量，声明时赋值

    private int random = ; //成员变量

    public StaticTest() {

        staticInt++;

        random++;

    }

    public static void main(String[] args) {

        System.out.println("类变量与对象变量的值变化");

        StaticTest test = new StaticTest();

        System.out.println("  实例1：staticInt:" + test.staticInt + "----random:" + test.random);

        StaticTest test2 = new StaticTest();

        System.out.println("  实例2：staticInt:" + test.staticInt + "----random:" + test.random);

        
　　     System.out.println("静态变量赋值");

        System.out.println("  静态语句块起作用:" + A.staticA);

        A a = new A();

        System.out.println("  构造器起作用:" + a.staticA);

        a.toChange();

        System.out.println("  静态方法1起作用:" + A.staticA);

        a.toChange2();

        System.out.println("  静态方法2起作用:" + A.staticA);

        System.out.println("常量赋值");

        System.out.println("  静态语句赋值:" + B.staticB);

    }

}

class A {

    public static  String  staticA ="A" ;  

    static{  staticA ="A1"; }  //静态语句块修改值

    public A(){  staticA ="A2"; }  //构造器修改值

    //静态方法起作用

    public static void toChange(){  staticA ="A3"; }

    public static void toChange2(){  staticA ="A4"; }

}

class B {

    public static final String  staticB ;  // 声明与赋值分离

    static{  staticB ="B"; }  //在静态语句中赋值

}

实例变量：独立于方法之外的变量 ，不过没有 static 修饰：
- 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
- 当一个对象被实例化之后，每个实例变量的值就跟着确定；
- 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
- 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
- 实例变量可以声明在使用前或使用后；
- 访问修饰符可以修饰实例变量；
- 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
- 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
- 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
```
import java.io.*;

public class Employee{

   public String name;     // 公有 实例变量，对子类可见

   private double salary;  // 私有 实例变量，仅在该类可见

   public Employee (String empName){    //在构造器中对name赋值

      name = empName;

   }

   public void setSalary(double empSal){   //设定salary的值

      salary = empSal;

   }

   public void printEmp(){   // 打印信息

      System.out.println("名字 : " + name );

      System.out.println("薪水 : " + salary);

   }

   public static void main(String args[]){ //程序执行入口

      Employee empOne = new Employee("RUNOOB");  //创建实例

      empOne.setSalary();  //访问

      empOne.printEmp();

   }

}
```
局部变量：类的方法中的变量
- 局部变量声明在方法、构造方法或者语句块中；
- 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
- 访问修饰符不能用于局部变量；
- 局部变量只在声明它的方法、构造方法或者语句块中可见；
- 局部变量是在栈上分配的。
- 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。示例：
```
package com.runoob.test;

public class Test{

   public void pupAge(){

      int age = ;  // 局部变量

      age = age + ;

      System.out.println("小狗的年龄是: " + age);

   }

   public static void main(String args[]){

      Test test = new Test();

      test.pupAge();

   }

}
```

Java 中 静态变量（类变量） 和 实例变量 区别

  静态变量属于类，该类在不产生对象时，也可以通过类名就可以调用静态变量。

  实例变量属于该类的对象，必须产生该类对象，才能调用实例变量。

在程序运行时的区别：

  实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量；

  静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。

总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用！！

eg: 对于下面的程序，无论创建多少个实例对象，永远都只分配了一个 staticInt 变量，并且每创建一个实例对象，这个 staticInt 就会加 1；但是，每创建一个实例对象，就会分配一个 random，即可能分配多个 random ，并且每个 random 的值都只自加了1次。

public class StaticTest {

    private static int staticInt = ;

    private int random = ;

    public StaticTest() {

        staticInt++;

        random++;

        System.out.println("staticInt = "+staticInt+"  random = "+random);

    }

    public static void main(String[] args) {
        System.out.println(staticInt);  //类变量：无需创建类对象（即，无需实例化），就可以直接访问

        StaticTest test = new StaticTest();

        StaticTest test2 = new StaticTest();

    }

}

/*输出结果为：

staticInt = 3  random = 3

staticInt = 4  random = 3 */

Pre-article： Java 学习（3）：java 对象和类

Next：Java 学习（5）：修饰符运算符