Java基础（二）：基本数据类型和变量类型

一、java基本数据类型：

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

　　Java 的两大数据类型：1、内置数据类型；2、引用数据类型。

1、内置数据类型：

　　Java语言提供了八种基本类型。六种数字类型（四个整数型：byte、short、int、long，两个浮点型：float、double），一种字符类型：char，还有一种布尔型：boolean。

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

　　对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。比如：

// 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);  

2、引用数据类型：

　　在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。

　　（1）对象、数组都是引用数据类型。

　　（2）所有引用类型的默认值都是null。

　　（3）一个引用变量可以用来引用与任何与之兼容的类型。例子：Site site = new Site("Runoob")

3、Java常量：

　　常量在程序运行时，不会被修改的量。在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：final double PI = 3.1415927;

　　常量使用全大写。

4、自动类型转换：

　　整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。转换从低级到高级。

　　数据类型转换必须满足如下规则：

（1）不能对boolean类型进行类型转换。

（2）不能把对象类型转换成不相关类的对象。

（3）在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

（4）转换过程中可能导致溢出或损失精度，例如：因为byte类型时8位，最大值为127，所以当强制转换为int类型值128时候就会导致溢出。

int i =128;
byte b = (byte)i;

（5）浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

(int)23.7 == 23;
(int)-45.89f == -45

　　自动类型转换必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

public class ZiDongLeiZhuan{
        public static void main(String[] args){
            char c1='a';//定义一个char类型
            int i1 = c1;//char自动类型转换为int
            System.out.println("char自动类型转换为int后的值等于"+i1);
            char c2 = 'A';//定义一个char类型
            int i2 = c2+1;//char 类型和 int 类型计算
            System.out.println("char类型和int计算后的值等于"+i2);
        }
}
//c1的值为字符'a',查ascii码表可知对应的int类型值为97，'A'对应值为65，所以i2=65+1=66。

5、强制类型转换：

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

　　（2）格式：(type)value  ——  type是要强制类型转换后的数据类型。实例：

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

6、隐含强制类型转换

　　（1）整数的默认类型是 int。

　　（2）浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。

　　 Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析。超出数据范围时会报溢出错误。

二、引用类型理解：

　　引用类型是一个对象类型，它的值是指向内存空间的引用，就是地址，所指向的内存中保存着变量所表示的一个值或一组值。

1、一般的数据类型：

int a；
a = 250； // 声明变量a的同时，系统给a分配了空间。

2、引用类型就不是了，只给变量分配了引用空间，数据空间没有分配，因为不知道数据是什么。

　　错误例子：

MyDate today；
today.day = 4； // 发生错误，因为today对象的数据空间未分配。

　　引用类型变量在声明后必须通过实例化开辟数据空间，才能对变量所指向的对象进行访问。

MyDate today；          //将变量分配一个保存引用的空间
today = new MyDate（）；     // 这句话是2步：首先执行new MyDate（），给today变量开辟数据空间，然后再执行赋值操作

3、引用变量赋值：

MyDate a，b；        // 在内存开辟两个引用空间
a = new MyDate（）；      // 开辟MyDate对象的数据空间，并把该空间的首地址赋给a
b = a；                  // 将a存储空间中的地址写到b的存储空间中

注意：在判断一个实例引用的类型时，使用的是实际类型，而不是声明的类型。在下面的代码中：

Vehicle v2 = new Car();    // v2 是 Car 类型，而不是 Vehicle 类型

class Vehicle {}

public class Car extends Vehicle {//Car类型继承Vehicle类型
    public static void main(String args[]){
        Car c1 = new Car();       // c1 是 Car 类型

        Vehicle v2 = new Car();    // v2 是 Car 类型
        Vehicle v3 = new Vehicle();   // v3 是 Vehicle类型

        //Car 是 Vehicle类型, Vehicle 不是 Car 类型
        boolean result1 =  c1 instanceof Vehicle;    // true
        boolean result2 =  v2 instanceof Car;        // true
        boolean result3 =  v2 instanceof Vehicle;    // true
        boolean result4 =  v3 instanceof Car;          // false
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
        System.out.println(result4);
   }
}

 三、Java变量类型：

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

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

　　（1）类变量：独立于方法之外的变量，用 static 修饰。

　　（2）实例变量：独立于方法之外的变量，不过没有 static 修饰。

　　（3）局部变量：类的方法中的变量。

public class Variable{
    static int allClicks=0;    // 类变量
    String str="hello world";  // 实例变量
    public void method(){
        int i =0;  // 局部变量
    }
}

1、Java 局部变量：

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

　　在以下实例中age是一个局部变量。定义在pupAge()方法中，它的作用域就限制在这个方法中。

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();
   }
}

　　如果将上面代码处换成 int age; age = age + 7; age 变量没有初始化，那么在编译时会出错。

2、实例变量：

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

import java.io.*;
public class Employee{
   // 这个实例变量对子类可见
   public String name;
   // 私有变量，仅在该类可见
   private double salary;
   //在构造器中对name赋值
   public Employee (String empName){
      name = empName;
   }
   //设定salary的值
   public void setSalary(double empSal){
      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();
   }
}

3、类变量（静态变量）：

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

import java.io.*;
public class Employee {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量
    public static final String DEPARTMENT = "开发人员";
    public static void main(String args[]){
    salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

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

4、Java 中静态变量和实例变量区别：

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

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

　　在程序运行时的区别：

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

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

public class StaticTest {
    private static int staticInt = 2;
    private int random = 2;
    public static void main(String[] args) {
        System.out.println(staticInt);//类变量可在类中直接使用
        StaticTest test = new StaticTest();
        System.out.println(test.random);//实例变量需实例化后才能使用
    }
}

　　（2）无论创建多少实例对象，永远只分配一个静态变量；而每创建一个实例对象，都会分配一个实例变量。

　　例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个 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) {
        StaticTest test = new StaticTest();
        StaticTest test2 = new StaticTest();
    }
}

　　执行以上程序，输出结果为：

staticInt = 3  random = 3
staticInt = 4  random = 3

 5、理解静态变量：

　　static全局变量与普通的全局变量：static全局变量只初使化一次，防止在其他文件单元中被引用;

　　static局部变量和普通局部变量：static局部变量只被初始化一次，下一次依据上一次结果值；

　　static函数与普通函数：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝。

　　静态变量并不是说其就不能改变值，不能改变值的量叫常量。 其拥有的值是可变的 ，而且它会保持最新的值。说其静态，是因为它不会随着函数的调用和退出而发生变化。即上次调用函数的时候，如果我们给静态变量赋予某个值的话，下次函数调用时，这个值保持不变。

　　怎么理解静态变量呢？简单来说静态变量就是一个类的公有属性。在这里可以打个拙劣的比方：假设"班里的学生"是一个类，班里的任何一个同学都相当于一个对象。那么所有学生的学费是一样的对吧？"学费"就相当于一个"静态变量"，其特征是它不属于任何一个"对象"（即学生）的专有属性，是大家"公有"的，若是变了，那就所有的同学的学费都会变。我们假设每个同学都有修改学费的权力，那么任何一个同学修改了学费（这个静态变量），所有同学的学费就都会变。

　　另外：静态方法只能使用类的静态变量。