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语言支持的变量类型有：

类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

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

举例：

package hello;

//首先要知道变量应该是赋值以后才能使用的，但是有些不必人为赋值就有默认初始值，但是有些要人为定义初始值
//所以有些直接使用的并不是没有赋值，而是系统自定义了初始值，所以不会报错

public class Variable {
    public String instance = "实例变量";
    public static String variable = "静态变量";    //静态变量的定义方式
    public static String CONST = "静态常量";    //静态常量的定义方式 
    public static void main(String[] args) {
        String local = "局部变量";    //类似这个就是局部变量，不可用访问修饰符修饰，没有默认初始值
        System.out.println(local);    //局部变量就是在方法或语句块中的变量
        Global global = new Global();    //类似这个就是实例变量，也称全局变量
        System.out.println(global.instance);    //实例变量就必须先把类new一个出来才能使用,因为他是在类中,方法外的
        System.out.println(variable);    //来瞅瞅静态变量，也叫类变量，静态变量的访问方式1(在自己类的时候)
        System.out.println(Global.variable);    //静态变量的访问方法2(不在自己类的时候)
    }
}

class Global{
    public String instance = "实例变量";    //实例变量在一个类的里面,语句块的外面
    public static String variable = "静态变量";
    Global(){    //在类的内部使用自己的实例变量：要么老老实实new一个出来,就像上面那个
        //第二种方法就是在函数里面使用实例变量，注意，如果方法是静态方法参照方法1
        System.out.println(instance);
        System.out.println(variable);
    }
    public void Instance() {
        System.out.println(instance);    //静态变量访问方法1(在自己类的时候),静态常量和静态变量访问相同
        System.out.println(Variable.CONST);
    }
}

类的静态数据成员值被所有对象共享，任何对象都可以访问类的静态数据成员。但是他们使用的是同一个数据，操作的是同一块内存，无论哪个对象修改了它，对其他对象来说，他已经变了

类变量可在类中直接使用，实例变量需实例化后才能使用。

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

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

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"; }
}