Java中的實例變數

Java程式中的實例是在類別或函數中呼叫物件時建立的，類別或函數使用變數來為每次呼叫物件時分配記憶體儲存單元，並建立實例。對實例執行的任何變更或操作都會自動反映在實例變數和對應的記憶體單元中。這種類型的變數有多種資料類型支持，即 int、char、long、short、boolean、float、double、byte 和 object。

文法：

開始您的免費軟體開發課程

網頁開發、程式語言、軟體測試及其他

<datatype>  <variable_name>;
<datatype>  <variable_name> = <initializing_value>;

變數主要有3種類型：

• 局部變數
• 實例變數
• 類別/靜態變數

Java 中的實例變數

實例變數在類別中宣告/定義，但在建構子、方法和區塊之外。之所以這樣稱呼實例變量，是因為它們是特定於實例（物件）的，並且不在實例（物件）之間共享，並且對特定實例的變數所做的更改不會反映在其他實例上。當為堆中的物件分配記憶體時，將為每個實例變數建立一個槽。物件的實例變數在使用“new”建立物件時創建，並在物件銷毀時銷毀。物件使用它們來保存狀態。

文法：

public class Employee {
public String Name; // instance variable with public Access.
private int salary ; // instance variable with private access.
public static String company; // not an instance variable as it is Static and the value it holds is
//   not instance but class specific.
}

宣告實例變數

實例變數有預設值；因此，與局部變數不同，它們無需初始化即可宣告。變數的預設值取決於它們的資料類型。

Characteristics of Instance Variable in Java

• Instance variables are visible to the constructor, method(s) and block(s). It is usually recommended to declare them as private, but the users can change the level of visibility by declaring it with various access modifiers suitable for their program.
• The variable name generally calls instance variables, but when these variables are used within a static method, they should be called using a fully specified name with the variable’s reference.
  Syntax:

  Objectreference.variable_name

  登入後複製
• Instance variables of a base class can be used by the subclasses depending on the access level given to the variable.
• Instance variables can be declared final to protect the constness of a declared variable. final instance variables are initialized while declaration and can’t be modified. They can also be declared and initialized in block and constructor.
• The instance variable can use the default access modifier.
• Instance variables can be declared. If a variable is declared as transient, it is not serialized into a byte stream. Its state changes are not stored. In deserialization, when the object is created back from the byte stream, transient variables hold their respective data type’s default values.
• Instance variables cannot have abstract, synchronized, strictfp or native modifiers as these are applicable to methods only.
• Instance variables cannot be declared static if declared, they become class level variables.

Examples of Instance Variable in Java

Examples of the instance variable in java are given below:

Example #1

Code:

import java.io.*;
public class Employee {
// this instance variable can be accessed any child class since it is public.
public String Name;
// Since salary is a private variable, it  is visible in this class only.
private int salary;
// static variable  is same among the instances
public static String company;
// The name variable is initialized in the constructor
public Employee (String eName) {
Name = eName;
}
public void setSalary(int eSal) {
salary = eSal;
}
public void printEmp() {
System.out.println("name  : " + Name );
System.out.println("salary :" + salary);
System.out.println("Company :" + Employee.company);
}
public static void main(String args[]) {
Employee.company = "Google";
Employee employee_one = new Employee("Jack");
employee_one .setSalary(100000);
employee_one .printEmp();
Employee employee_two = new Employee("Jill");
employee_two .setSalary(200000);
employee_two .printEmp();
}
}

Output:

In the above example, we can see the difference between instance variables and static variables. We have created two objects for employees. The name and salary of the objects are different, but the company is the same for both. This is because it is a static variable and the rest are instance variables.

By changing the line “private int salary; “ in the above code to “ private final int salary = 500;”. We’re changing the behavior of the variable. Since we’re trying to modify a final variable, the compiler throws the following error.

Output:

Example #2

Code:

import java.io.*;
public class DefaultValues {
boolean val1;
double val2;
float val3;
int val4;
long val5;
String val6;
public static void main(String[] args) {
System.out.println("Default values are :");
DefaultValues d = new DefaultValues();
System.out.println("Val1 = " + d.val1);
System.out.println("Val2 = " + d.val2);
System.out.println("Val3 = " + d.val3);
System.out.println("Val4 = " + d.val4);
System.out.println("Val5 = " + d.val5);
System.out.println("Val6 = " + d.val6);
}
}

The above code snippet on execution results in the below output. As mentioned earlier, instance variables have default values if they are not initialized while declaring. This program prints the default values of all the data types.

Output:

Example #3

Code:

import java.io.*;
public class Test implements Serializable
{
// Normal variables
int val1 = 10;
int val2 = 20;
// Transient variables
transient int val3 = 30;
// Use of transient has no impact here
transient static int val4 = 40;
transient final int val5 = 50;
public static void main(String[] args) throws Exception
{
Test input = new Test();
// serialization
FileOutputStream fos = new FileOutputStream("abc.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(input);
// de-serialization
FileInputStream fis = new FileInputStream("abc.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Test output = (Test)ois.readObject();
System.out.println("val1 = " + output.val1);
System.out.println("val2 = " + output.val2);
System.out.println("val3 = " + output.val3);
System.out.println("val4 = " + output.val4);
System.out.println("va15 = " + output.val5);
}
}

Executing the above program results in the below-given output. variable val3 is declared transient, so its value was not stored into the byte stream when the Test object was serialized.whereas val4 and val5 are not instance variables because they violate the rules of instance variables. Hence their states remain unaffected.

Output:

以上是Java中的實例變數的詳細內容。更多資訊請關注PHP中文網其他相關文章！