Answers:
要定义全局变量,您可以使用静态关键字
public class Example {
public static int a;
public static int b;
}
现在您可以通过调用从任何地方访问a和b
Example.a;
Example.b;
static
关键字使变量全局访问,而他们的类加载。
Global
为其他名称(TestClass
?),以免给人以Global
Java关键字之类的印象。安全胜过遗憾:)
你不知道 那是设计使然。即使可以,也不应该这样做。
话虽如此,您可以在名为Globals的类中创建一组公共静态成员。
public class Globals {
public static int globalInt = 0;
///
}
但您实际上不应该:)。认真..不要这样做。
另一种方法是创建这样的接口:
public interface GlobalConstants
{
String name = "Chilly Billy";
String address = "10 Chicken head Lane";
}
任何需要使用它们的类都只需实现接口:
public class GlobalImpl implements GlobalConstants
{
public GlobalImpl()
{
System.out.println(name);
}
}
很多好的答案,但是我想举这个例子,因为它被认为是另一个类访问一个类的变量的更合适的方法:使用getter和setter方法。
之所以以这种方式使用getter和setter而不是仅仅将变量公开的原因如下。可以说,您的var将是一个全局参数,您永远不要希望有人在程序执行期间更改它(例如,当您与团队一起开发代码时),例如网站的URL。从理论上讲,这可能会更改,并且在您的程序中可能会多次使用,因此您希望使用全局变量来一次更新所有变量。但是您不希望其他人进入并更改此变量(可能没有意识到它的重要性)。在那种情况下,您仅不包括setter方法,而仅包括getter方法。
public class Global{
private static int var = 5;
public static int getVar(){
return Global.var;
}
//If you do not want to change the var ever then do not include this
public static void setVar(int var){
Global.var = var;
}
}
坦白地说,Java OO程序中没有“ GLOBAL”的概念
不过,您的问题背后还有一些真相,因为在某些情况下,您想在程序的任何部分运行方法。例如,Phrase-O-Matic应用程序中的--- random()方法;该方法应可从程序的任何位置调用。
因此,为了满足上述条件,“我们需要具有类似于全局的变量和方法”
声明全球变量。
1.Mark the variable as public static final While declaring.
宣告一种全球方法-2.45155。
1. Mark the method as public static While declaring.
因为我将全局变量和方法声明为静态,所以您只需在以下代码的帮助下即可在任意位置调用它们
类名.X
注意:根据要求,X可以是方法名称或变量名称,而ClassName是在其中声明它们的类的名称。
除了常量之外,什么都不应该是全局的。
public class MyMainClass {
public final static boolean DEBUGMODE=true;
}
将其放在您的主类中。在其他.java文件中,可通过以下方式使用它:
if(MyMainClass.DEBUGMODE) System.out.println("Some debugging info");
确保当您将代码从剪裁室地板移开并释放时,请删除或注释掉此功能。
如果您使用随机分配器等主力方法,建议您创建一个“工具箱”包!所有编码器都应该有一个,然后只要您想在.java中使用它,只需将其导入即可!
Java中没有真正的全局变量。每个静态变量都必须属于某个类(例如System.out),但是当您决定将其放入哪个类时,可以从同一类加载器加载的所有位置引用它。
请注意,在更新时应始终保护静态变量,以避免出现竞争情况。
public class GlobalImpl {
public static int global = 5;
}
您可以随时随地致电:
GlobalImpl.global // 5
正如您可能从答案中猜到的那样,Java中没有全局变量,唯一可以做的就是创建带有静态成员的类:
public class Global {
public static int a;
}
您可以在Global.a
其他地方使用它。但是,如果您使用Java 1.5或更高版本,则可以使用import static
魔术使它看起来更像一个真正的全局变量:
import static test.Global.*;
public class UseGlobal {
public void foo() {
int i = a;
}
}
和瞧!
现在,这并不是最佳做法,因此您可以在广告中看到:不要在家中这样做
通常,全局变量(假设您将其与C,Cpp进行比较)定义为 public static final
喜欢
class GlobalConstant{
public static final String CODE = "cd";
}
枚举在这种情况下也很有用:
例如 Calendar.JANUARY
)
final
,那也就是Global变量的含义,但这当然取决于您要共享的方式,您使用的位置以及所有内容,
CODE
此示例中的类型是什么?它在哪里定义?
创建一个独立的文件,例如 使用第一个解决方案的Example.java,就好了。您也可以在应用程序中执行此操作,例如,全局变量对于您当前的应用程序来说是特殊的,等等:
在开头创建一个类,并在其中声明变量:
class Globals {
static int month_number;
static String month_name;
}
然后,您可以从应用程序的任何位置访问这些变量(将它们用作“ Globals.month_number”等)。
如果需要更新全局属性,则可以将简单的getter / setter包装器类用作全局变量。典型示例如下所示。
public class GlobalHolder {
private static final GlobalHolder INSTANCE = new GlobalHolder();
private volatile int globalProperty;
public static GlobalHolder getInstance() {
return INSTANCE;
}
public int getGlobalProperty() {
return globalProperty;
}
public void setGlobalProperty(int globalProperty) {
this.globalProperty = globalProperty;
}
public static void main(String[] args) {
GlobalHolder.getInstance().setGlobalProperty(10);
System.out.println(GlobalHolder.getInstance().getGlobalProperty());
}
}
按照这个概念,全局变量(也称为实例变量)是类级别的变量,即,它们是在类内部但在方法外部定义的。为了使它们完全可用并直接使用它们,请提供static关键字。因此,如果我正在编写用于简单算术运算的程序,并且它需要一个数字对,则两个实例变量将定义为:
public class Add {
static int a;
static int b;
static int c;
public static void main(String arg[]) {
c=sum();
System.out.println("Sum is: "+c);
}
static int sum() {
a=20;
b=30;
return a+b;
}
}
Output: Sum is: 50
此外,在实例变量之前使用static关键字使我们不必一次又一次为相同变量指定数据类型。只需直接写变量。
static
不会“使其完全可用”。第一段是胡说八道。例子是不好的做法。
没有static
这也是可能的:
class Main {
String globalVar = "Global Value";
class Class1 {
Class1() {
System.out.println("Class1: "+globalVar);
globalVar += " - changed";
} }
class Class2 {
Class2() {
System.out.println("Class2: "+globalVar);
} }
public static void main(String[] args) {
Main m = new Main();
m.mainCode();
}
void mainCode() {
Class1 o1 = new Class1();
Class2 o2 = new Class2();
}
}
/*
Output:
Class1: Global Value
Class2: Global Value - changed
*/
面向对象的程序设计是在理解变量的范围与封装那些变量的类对象紧密排斥的基础上构建的。
创建“全局变量”的问题在于它不是Java的行业标准。它不是行业标准,因为它允许多个类处理异步的数据,如果您正在运行多线程应用程序,则在线程安全性方面会变得更加复杂和危险。使用全局变量无效的原因还有多种,但如果要避免这种情况,建议您使用面向方面的编程。
面向方面的编程通过称为“建议”的东西来使父类负责范围,从而消除了这个问题,该建议在代码中增加了额外的行为,而无需实际对其进行修改。它提供了解决交叉问题或全局变量使用的解决方案。
Spring是一个利用AOP的Java框架,尽管它传统上用于Web应用程序,但是核心应用程序可以在整个Java框架(包括8.0)中通用。这可能是您想要探索的方向。
我认为全局变量的限定条件是可以在代码中的任何位置访问和更改全局变量,而无需关心静态/实例调用或将任何引用从一个类传递给另一个类。
通常如果你有A班
public class A {
private int myVar;
public A(int myVar) {
this.myVar = myVar;
}
public int getMyVar() {
return myVar;
}
public void setMyVar(int mewVar) {
this.myVar = newVar;
}
}
并想访问和更新myvar
B类,
public class B{
private A a;
public void passA(A a){
this.a = a;
}
public void changeMyVar(int newVar){
a.setMyvar(newVar);
}
}
您将需要引用类A的实例,并像这样更新类B中的值:
int initialValue = 2;
int newValue = 3;
A a = new A(initialValue);
B b = new B();
b.passA(a);
b.changeMyVar(newValue);
assertEquals(a.getMyVar(),newValue); // true
因此,我对此的解决方案(即使我不确定这是否是一种很好的做法),也可以使用单例:
public class Globals {
private static Globals globalsInstance = new Globals();
public static Globals getInstance() {
return globalsInstance;
}
private int myVar = 2;
private Globals() {
}
public int getMyVar() {
return myVar;
}
public void setMyVar(int myVar) {
this.myVar = myVar;
}
}
现在,您可以通过以下任何位置获取全局唯一实例:
Globals globals = Globals.getInstance();
// and read and write to myVar with the getter and setter like
int myVar = globals.getMyVar();
global.setMyVar(3);
// Get the access of global while retaining priveleges.
// You can access variables in one class from another, with provisions.
// The primitive must be protected or no modifier (seen in example).
// the first class
public class farm{
int eggs; // an integer to be set by constructor
fox afox; // declaration of a fox object
// the constructor inits
farm(){
eggs = 4;
afox = new fox(); // an instance of a fox object
// show count of eggs before the fox arrives
System.out.println("Count of eggs before: " + eggs);
// call class fox, afox method, pass myFarm as a reference
afox.stealEgg(this);
// show the farm class, myFarm, primitive value
System.out.println("Count of eggs after : " + eggs);
} // end constructor
public static void main(String[] args){
// instance of a farm class object
farm myFarm = new farm();
}; // end main
} // end class
// the second class
public class fox{
// theFarm is the myFarm object instance
// any public, protected, or "no modifier" variable is accessible
void stealEgg(farm theFarm){ --theFarm.eggs; }
} // end class
要定义全局变量,您可以使用静态关键字
public final class Tools {
public static int a;
public static int b;
}
现在您可以通过调用从任何地方访问a和b
Tools.a;
Tools.b;
Yoy是正确的...特别是在J2ME中...您可以通过将MidLet构造函数(简单的初始化)放入以下代码行来避免NullPointerException:
new Tools();
这样可以确保在使用工具的任何指令之前分配工具。
而已!