Java 中的类字段和实例字段
本文将学习 Java 编程语言的基本术语，如 Java 中的局部变量、输入参数、类字段和实例字段。
Java 中的局部变量
范围绑定到块、方法或构造函数的变量称为局部变量。比如说，我们有一个方法，testing。
我们声明一个 val 变量并将 10 分配给这个方法。在 main 块内写入 print 语句。
public class Experiment {
public static void testing() {
int val = 10;
}
public static void main(String[] args) {
// try printing the local variable of the function demo
System.out.printf("%d", val);
}
}
输出：
error: cannot find symbol
System.out.printf("%d", val);
^
symbol: variable val
location: class Experiment
1 error
尽管此代码中存在变量 val，但我们得到了一个错误。这里，变量 val 是 testing() 方法的局部变量。
由于它是在方法 testing 中定义的，所以它的范围是有限的。当 print 语句试图在这个范围之外访问这个变量时，我们会得到一个错误。
现在，在方法 testing 中声明 print 语句并从 main 块调用该方法。
public class Experiment {
public static void testing() {
int val = 10;
System.out.printf("%d", val);
}
public static void main(String[] args) {
// call the method
testing();
}
}
输出：
10
这一次，print 语句从其范围内访问变量。
现在尝试找出这段代码中的局部变量。
public class Treat {
public static void main(String[] args) {
for (int i = 0, i < 1; i++) {
System.out.println("You will get a Cake if you answer correctly!");
}
}
}
变量 i 是一个局部变量。它的范围仅限于 for 循环。
请注意有关局部变量的以下几点：
- 我们不能使用诸如
public、protected和private之类的访问修饰符来声明局部变量。 - 这些变量在堆栈级别内部实现。
Java 中的输入参数
某些信息需要执行，而其他信息可能不需要。看看这个方法 welcome。
public class Greet {
// a function that does not need any parameter or information
public static void welcome() {
System.out.println("Hello, we are happy you visited.");
}
public static void main(String[] args) {
// call the function
welcome();
}
}
输出：
Hello, we are happy you visited.
我们在不传递任何值的情况下调用该方法。我们不向此方法提供任何信息，它可以正常执行。
public class Test {
// a function that needs some information/parameter
public static void hello(int x) {
int a;
System.out.println("Hello, we are happy you visited.");
if (x < 18) {
a = 18 - x;
System.out.printf("Please come back after %d years.", a);
}
}
public static void main(String[] args) {
int age = 2;
// call the function
hello(age);
}
}
输出：
Hello, we are happy you visited.
Please come back after 16 years.
如果我们不传递 age 的值，方法 hello 将无法正确执行。
该方法通过括号内定义的变量 x 接收此值。变量 x 只不过是一个输入参数，或者简单地说，一个参数。
Java 中的输入参数或参数是用于定义方法以帮助方法运行的变量。
不要将参数与参数混合。它们具有相同的价值，但它们不是一回事。
public class Test {
// function to add ages
public static int totalAge(int age1, int age2) {
return age1 + age2;
}
public static void main(String[] args) {
int a1 = 10;
int a2 = 12;
int total = totalAge(a1, a2);
System.out.println("Sum of ages: " + total);
}
}
输出：
Sum of ages: 22
这里，age1 和 age2 是输入参数。
Java 中的类字段
类中的任何变量都可以在 Java 中称为字段。price、quantity 和 name 等所有变量都是字段。
但是，请注意变量 quantity 以 static 关键字开头。在定义中带有关键字 static 的此类字段在 Java 中称为类字段。
类字段在 Java 中也称为类变量或静态字段。
class Cake {
int price;
static int quantity;
string name;
}
Java 中类字段的属性
以下几点是一个类字段：
- 必须使用
static关键字声明类字段。
public static NameOfClass {
static datatype name_of_variable;
}
- 类的许多实例共享类字段，因此类字段是内存高效的。用非常简单的话来说，一个实例字段的值对于 Java 中一个类的所有实例都是相同的。
- 我们可以使用类的实例和类名本身来访问 Java 中的类字段。请注意，访问任何静态字段不一定需要实例。
class Cake {
int price;
static int quantity = 10;
String name;
public static void main(String[] args) {
// create the object of Cake class
Cake c1 = new Cake();
// Access the class field using the object
System.out.println(c1.quantity);
// Access the class field using the class
System.out.println(Cake.quantity);
}
}
输出：
10
10
在上面的例子中，我们使用像这样的 dot 运算符 - c1.quantity 使用对象访问类字段。同样，要按类访问变量，请使用类名 Cake.quantity。
Java 中的实例字段
public class Cake {
int cost;
String flavor;
public Cake(int cost, String flavor) {
this.cost = cost;
this.flavor = flavor;
}
public int expense() {
return cost;
}
public static void main(String[] args) {
Cake cake1 = new Cake(1000, "Choco lava");
Cake cake2 = new Cake(2000, "Pineapple");
System.out.println(cake1.expense());
System.out.println(cake2.expense());
}
}
输出：
1000
2000
在类 Cake 中，我们有两个变量 - cost 和 flavor。我们创建 cake1 和 cake2。
这些可以为不同对象取不同值的变量称为实例变量或实例字段。
Java 中 Instance Field 的属性
java 中的实例字段也称为非静态变量。以下是关于实例字段的几点。
- 实例字段不是用 Java 的
static关键字声明的。
public class ClassName {
datatype variable_name;
}
- 它们不与所有实例共享。在 Java 中，每个实例都可以有其唯一的实例字段值。
- 你看到了我们如何在类本身的帮助下访问类字段。好吧，这对于 Java 中的实例字段来说是不正确的。我们需要一个
instance/object来访问 Java 中的实例字段。 - 我们可以将任何访问说明符与 Java 中的实例字段一起使用。请参阅此文档以了解有关 Java 中的字段的更多信息。