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 = 100;
int octal = 0144;
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 = 123;
byte b = (byte)i1; //强制类型转换为byte
```
- 4. 转换过程中可能导致溢出或损失精度。eg：
```
int i =128;   
byte b = (byte)i;  //因为byte类型时8位，最大值为127，所以当强制转换为int类型值128时候就会导致溢出。
```
- 5. ****** 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入 *****.eg:
```
(int)23.7 == 23;        
(int)-45.89f == -45
```
- 6. 强制类型转换: 条件是转换的数据类型必须是兼容的。格式：(type)value, 其中 type 是要强制类型转换后的数据类型，eg：
```
public class QiangZhiZhuanHuan{
    public static void main(String[] args){
        int i1 = 123;
        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=0;    // 类变量
    String str="hello world";  // 实例变量
    public void method(){
        int i =0;  // 局部变量
    }
}

类变量（静态变量，易用于常量定义）：独立于方法之外的变量，用 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 = 10000;
        System.out.println( DEPARTMENT + "平均工资: " + salary);
    }
}
注意：如果其他类想要访问该变量，可以这样访问：Employee.DEPARTMENT

类变量赋值方法

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

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

public class StaticTest {
    private static int staticInt = 2;  //类变量，声明时赋值
    private int random = 2; //成员变量

    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(1000);  //访问
      empOne.printEmp();
   }
}
```
局部变量：类的方法中的变量
- 局部变量声明在方法、构造方法或者语句块中；
- 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
- 访问修饰符不能用于局部变量；
- 局部变量只在声明它的方法、构造方法或者语句块中可见；
- 局部变量是在栈上分配的。
- 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。示例：
```
package com.runoob.test;
 
public class Test{ 
   public void pupAge(){
      int age = 0;  // 局部变量
      age = age + 7;
      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 = 2;
    private int random = 2;

    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）：修饰符运算符

posted on 2017-08-07 16:53 云雀sunshine 阅读(291) 评论(0) 编辑收藏举报