Java变量详解

这里写目录标题

第一章、Java中的变量分类
- 1.1）变量分类
- 1.2）成员变量分类
- 1.3）成员变量和局部变量的区别
第二章、成员变量详解
- 2.1）成员变量作用域/权限修饰符
- 2.2）成员变量和成员属性的区别
- 2.3）成员变量初始化方式
- 2.4）成员变量初始化顺序

第一章、Java中的变量分类

在这里插入图片描述

概述：Java类的五个成员之一：变量
Java的基本单位是类，类中包含五个部分：变量、方法、构造器、初始化块、内部类

1.1）变量分类

①变量根据数据类型分类
两类：Java中的变量根据数据类型分为两类：基本数据类型变量和引用数据类型变量。
1、基本数据类型变量：基本数据类型是Java语言内置的数据类型，用于存储简单的数值。基本数据类型包括整型、浮点型、字符型和布尔型。

public class PrimitiveExample {
    public static void main(String[] args) {
        int num = 10; // 整型变量
        double salary = 1000.50; // 浮点型变量
        char grade = 'A'; // 字符型变量
        boolean isStudent = true; // 布尔型变量

        System.out.println("Number: " + num);
        System.out.println("Salary: " + salary);
        System.out.println("Grade: " + grade);
        System.out.println("Is student: " + isStudent);
    }
}

2、引用数据类型变量：引用数据类型是指存储对象引用的变量，而不是对象本身。引用数据类型包括类、接口、数组等。

public class ReferenceExample {
    public static void main(String[] args) {
        String str = "Hello, Java!"; // 字符串对象引用
        int[] numbers = {1, 2, 3, 4, 5}; // 整型数组对象引用

        System.out.println("String: " + str);
        System.out.print("Numbers: ");
        for (int num : numbers) {
            System.out.print(num + " ");
        }
    }
}

②变量根据变量定义位置分类
两类：变量根据定义位置的不同分为全局变量（成员变量）和局部变量。

1、全局变量（也称为成员变量）是在类中声明的变量，其作用域为整个类。全局变量可以是实例变量（非静态变量）或类变量（静态变量）。

2、局部变量：在方法、构造函数或代码块内部声明的变量，其作用域仅限于声明它的方法、构造函数或代码块。局部变量在方法、构造函数或代码块执行时创建，执行结束时销毁。

public class Example {
    // 全局变量（实例变量）
    String globalVar = "This is a global variable";

    public void exampleMethod() {
        // 局部变量
        int localVar = 10;
        System.out.println("Local variable: " + localVar);
        System.out.println("Global variable: " + globalVar);
    }

    public static void main(String[] args) {
        Example obj = new Example();
        obj.exampleMethod();
        System.out.println(obj.globalVar);
    }
}

1.2）成员变量分类

两类：成员变量分为类变量和实例变量。

Java成员变量和类变量的区别：
实例变量（非静态变量）：只能通过对象名调用（通过对象实例访问）。实例变量是属于类的每个对象实例的变量，存储在堆内存。每个对象都有自己的一组实例变量副本，它们在对象创建时被初始化。实例变量可以。

public class Person {
    String name; // 实例变量
    int age; // 实例变量

    public static void main(String[] args) {
        Person person1 = new Person();
        person1.name = "Alice";
        person1.age = 25;

        Person person2 = new Person();
        person2.name = "Bob";
        person2.age = 30;
    }
}

类变量（静态变量）：静态变量也称为类变量，可以直接通过类名调用。也可以通过对象名调用，这个变量属于类，存储在方法区栈中的静态区。静态变量只有一个副本，会被所有类的实例共享。可以直接通过类名访问静态变量，而不需要创建对象。

static int staticVar; // 静态变量，只会初始化一次

1.3）成员变量和局部变量的区别

①成员变量直接定义在类中，整个类可以使用。
②局部变量定义在方法块中，必须赋一个初始值，只有在方法中才可以使
③内存位置不一样。成员变量位于堆当中。局部变量位于栈当中。
④生命周期不同。成员变量随着对象创建而诞生，随着对象被回收消失。局部变量随着方法进栈诞生，随着方法出栈消失。

第二章、成员变量详解

2.1）成员变量作用域/权限修饰符

对于类的成员（包括成员变量和成员方法）而言，其能否被其他类所访问，取决于该成员的修饰词。

①其中public成员变量可以被任何类访问和使用。可以通过类名.成员变量名的方式来访问public成员变量。

②protected成员变量只能在类内部和子类中使用。在子类中，可以通过super关键字来访问父类的protected成员变量。

③空着不写：同类中，同包中

④private成员变量只能在类内部使用，要访问private成员变量必须通过类提供的公共方法来访问。
在这里插入图片描述

2.2）成员变量和成员属性的区别

①属性的官方定义：属性是指get或者set方法名，去掉get或者set后，把剩余的部分首字母改为小写后，即为这个类的属性。

②图中紫色P为类的属性，黄色f为成员变量。从图中可以看出age是成员变量，size和name为类的属性，不是类的成员变量。
在这里插入图片描述

2.3）成员变量初始化方式

①直接无值初始化，会给一个默认值

class Ver_1
{
   
    //成员变量初始化时不赋值会有默认值
    private boolean flag;   // false
	private int _int;       // 0

	private char _char;     //'0000'
	
	private float _float;   //Default value: 0.0
	private long _long;     //Default value: 0
	private double _double; //Default value: 0.0

	//引用类型默认值是 null
}

②直接赋值初始化

class Ver_1
{
    //成员变量，定义在类里
    int a = 10;

}

③构造方法初始化，在进入构造函数之前，默认初始化num为0，进入构造函数后赋值为20。

public class Ver_1{
  int num ;  
  public Ver_1(){
    num = 20;
  }
}

2.4）成员变量初始化顺序

①非静态成员变量，在构造函数之前初始化，并且按定义顺序初始化。

②静态代码块和静态成员变量执行顺序和代码中出现的顺序有关。

③静态成员变量优先于非静态成员变量，静态初始化只在Class对象第一次创建时发生一次。下面搬运了一段代码举例：

public class StaticInitialization {
	public static void main(String[] args) {
		System.out.println("Creating new Cupboard() in main");
		new Cupboard();
		System.out.println("Creating new Cupboard() in main");
		new Cupboard();
		t2.f2(1);
		t3.f3(1);
	}
	static Table t2 = new Table(); 
	static Cupboard t3 = new Cupboard(); 
}
class Bowl{
	Bowl(int i){
		System.out.println("Bowl"+i);
	}
	void f(int i){
		System.out.println("f"+i);
	}
}
class Table{
	static Bowl b1 = new Bowl(1); 
	Table(){
		System.out.println("Table()");
		b2.f(1);
	}
	void f2(int i){
		System.out.println("f2("+i+")");
	}
	static Bowl b2 = new Bowl(2); 	
}
class Cupboard{
	Bowl b3 = new Bowl(3);
	static Bowl b4 = new Bowl(4); 
	Cupboard(){
		System.out.println("Cupboard()");
		b4.f(2);
	}
	void f3(int i){
		System.out.println("f3("+i+")");
	}
	static Bowl b5 = new Bowl(5); 
}

输出结果如下：

Bowl1
Bowl2
Table()
f1
Bowl4
Bowl5
Bowl3
Cupboard()
f2
Creating new Cupboard() in main
Bowl3
Cupboard()
f2
Creating new Cupboard() in main
Bowl3
Cupboard()
f2
f2(1)
f3(1)