今天在某个代码里看到静态域的使用,出于学习的目的,专门对static相关的内容(静态类、方法、变量、域,以及非静态的)进行测试
废话不多说,上代码:
主类 StaticTest.java
public class StaticTest extends fatherClass{
//初始化时,可以直接调用静态成员,以及同类的非静态成员
//静态变量初始化时不能引用非静态成员
public static int staticVar=new AssistClass().getNum2();
//静态域与静态变量初始化具有相同的优先级
static{
staticVar++;
System.out.println("static block");
//域中可以定义变量以及类,不能定义方法,并且只是在域中使用
//不能带有public\protected\private标示符
int var2=3;
class NSC2{
int i=2;
}
// System.out.println(new NSC2().i);
//不允许定义静态变量和静态类
//! static int staticVar2;
//! static class SC2{}
}
public int var=new AssistClass().getNum();
public int var2=fun3();
public StaticTest(){
System.out.println("constructor");
}
//非静态域与非静态变量初始化具有相同的优先级
{
//静态域可以访问所属类的静态
var++;
staticVar++;
System.out.println("not static block");
}
public void fun(){//非静态方法可以直接调用静态和非静态成员
staticVar=1;
staticFun();
fun2();
}
public void fun2(){
}
public int fun3(){
return 3;
}
public static void staticFun(){
//静态方法不能直接调用非静态成员
//需要:1.实例化 2.改为静态
//! fun2();
System.out.println("sattic method");
}
public static int staticFun2(){
System.out.println("static field init");
return 2;
}
public static int staticFun3(){
System.out.println("not static field init");
return 3;
}
/**
* @param args
*/
//静态方法在第一次执行时会先执行静态初始化和静态域
//构造方法可以认为是静态方法
//每次实例化都会执行一次非静态初始化和非静态域
public static void main(String[] args) {
// TODO Auto-generated method stub
// staticFun();
// new StaticTest();
new StaticTest();
// System.out.println(st.var+"&"+st.var2+"&"+staticVar);
}
//结论:静态成员可以被直接调用,非静态成员则需经实例化(但可以被同类的非静态成员调用)
}
辅助类 AssistClass.java
public class AssistClass{
int i=1;
public int getNum(){
System.out.println("not static field init");
return 4;
}
public int getNum2(){
System.out.println("static field init");
return 5;
}
public int getNum3(){
System.out.println("father static field init");
return 5;
}
public int getNum4(){
System.out.println("father not static field init");
return 5;
}
public static void main(String[] args){
//静态方法在第一次执行时会先执行静态初始化和静态域
//构造方法可以认为是静态方法
//每次实例化都会执行一次非静态初始化和非静态域
new StaticTest();
new StaticTest();
}
}
父类 FatherClass.java
public class fatherClass{
//同静态时,父类的变量初始化/域先于子类执行
static int fatherVar=new AssistClass().getNum3();
static{
System.out.println("father static block");
}
//同非静态时,父类的变量初始化/域先于子类执行
{
System.out.println("father not static block");
}
int fatherVar2=new AssistClass().getNum4();
}
关于静态成员与非静态成员之间的调用关系,这里不赘述,因为这是语法问题,各位只要写一写代码就了解了
执行StaticTest类的main方法,输出结果:
引用
father static field init
father static block
static field init
static block
father not static block
father not static field init
not static field init
not static block
constructor
要是改变初始化与域的位置,输出结果也会有相应改变,同样静态(或非静态)的初始化和域,基本按照先后顺序执行。
结论是:
1)静态元素(变量、方法、域、内部类)不能直接调用非静态元素 ,需要对非静态元素所属类实例化,特别是调用非静态内部类时,需要对其外部类实例化,然后获取非静态内部类的实例对象。
2)不管位置如何,静态初始化 / 域先于非静态初始化 / 域,父类的初始化 / 域先于子类的初始化 / 域,变量的初始化以及域先于构造方法执行。即:
a) 先初始化 / 域,后构造方法;
b) 先“静态”后“非静态”;
c) 先父后子。
其他静态 / 非静态方法均需调用才能执行
这里请注意次序排列的先后顺序,比如静态非静态的区分先于父子类的区分,即子类的静态初始化比父类的非静态初始化优先的。
3)静态方法在第一次被执行时,会先执行静态的初始化和域,如所属类的main方法,构造方法虽没有static标示符,但也可以认为是静态方法。而在构造方法执行(即实例化)时,除了执行静态初始化和域,接着又会执行非静态的初始化和域。
当然非静态在每次实例化都会执行一次。
关于域,那是不归于方法封装的执行代码,即它是可以主动执行(静态在定义时,非静态在实例化时进行)的,而不必通过方法调用,应该有点类似C吧。
4)域中可以定义变量和类,但不能是静态变量和静态类(因为不需要共享),并且变量和类都只是域内部使用,因此不需要public/protected/private标识符。
补充: 谢谢各位的支持,另外应logic的要求,对静态类进行了测试
请看代码:
StaticTest2.java
public class StaticTest2 {
static int staticVar;
int var;
static class StaticClass{
//静态类中可以定义静态、非静态的成员、域
//静态类中可以调用外部类的静态成员
public static int S2Var=staticVar;
//静态类中需要对外部类实例化,才能调用外部类的非静态类成员
public int NS2Var=new StaticTest().var;
static{
System.out.println("static Class > static block");
}
{
System.out.println("static class > not static block");
}
class NS2Class{}
static class S2Class{public static int S2var;}
public static void staticFun(){
System.out.println("this is static class");
}
public void fun(){
System.out.println("this is static class");
}
}
class NotStaticClass{
//非静态内部类不能定义静态域
//提示错误:Cannot define static initializer in inner type StaticTest2.NotStaticClass
//! static { System.out.println("not static Class > static block"); }
{
System.out.println("not static class > not static block");
}
//非静态内部类中不能定义静态变量
//提示错误:The field var cannot be declared static; static fields can only be declared in static or top level types
//! static int var;
//非静态内部类中不能定义静态方法
//提示错误:The method staticFun cannot be declared static; static methods can only be declared in a static or top level type
//! public static void staticFun(){}
class NS2Class{}
//非静态内部类中不能定义静态类
//提示错误:The member type S2Class cannot be declared static; static types can only be declared in static or top level types
//! static class S2Class{}
public void fun(){
System.out.println("this is not static class");
}
}
static{
System.out.println("static block");
}
{
System.out.println("not static block");
}
public NotStaticClass getNSC(){
return new NotStaticClass();
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("............hua li de fen ge xian..............");
StaticTest2.StaticClass.staticFun();
new StaticClass().fun();
//等同于
// new StaticTest2.StaticClass().fun();
//外部类(即StaticTest2)需经实例化,
//设法获取静态内部类的实例(如getNSC()),才能调用非静态内部类的非静态成员
(new StaticTest2()).getNSC().fun();
//! new NotStaticClass().fun();
}
}
AnnotherTest.java
public class AnnotherTest{
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("外部类测试:");
//外部类初始化时,会执行其静态变量初始化和静态域,但不会涉及其静态类
new StaticTest2();
System.out.println("静态类测试:");
/*
* 静态类测试
*/
//静态类调用其成员,静态类的外部类不需要经实例化
//静态类调用其静态成员,此时不会执行其外部类(StaticTest2)的静态变量初始化和静态域
StaticTest2.StaticClass.staticFun();
// System.out.println( StaticTest2.StaticClass.S2Class.S2var );
//静态类调用其非静态成员
// new StaticTest2.StaticClass().fun();
System.out.println("非静态内部类测试:");
/*
* 非静态内部类测试
*/
//StaticTest2.NotStaticClass只能调用class元素
System.out.println(StaticTest2.NotStaticClass.class);
//非静态内部类中不能定义静态元素
//外部类(即StaticTest2)需经实例化,
//设法获取静态内部类的实例(如getNSC()),才能调用非静态内部类的非静态成员
(new StaticTest2()).getNSC().fun();
//以下代码会编译错误,需先实例化外部类
//! new StaticTest2.NotStaticClass().fun();
}
}
重点在AnnotherTest的测试结果:
引用
外部类测试:
static block
not static block
静态类测试:
static Class > static block
this is static class
非静态内部类测试:
class defaultPackage.StaticTest2$NotStaticClass
not static block
not static class > not static block
this is not static class
结论是:
5)静态类首先是内部类,静态类当中可以定义静态元素和非静态元素(包括内部类、变量、方法、域),而非静态内部类只能定义非静态元素。静态类可以直接调用外部类的静态元素,非静态内部类可以直接调用外部类的静态和非静态元素。
6)外部类在执行变量初始化和域(包括静态和非静态)时,不会涉及其内部类的变量初始化和域。相对的,内部类(包括静态类和非静态内部类)在执行自己的变量初始化和域时,也不会执行静态类所属外部类的变量初始化和域。
当然,非静态内部类必须通过其外部类的实例对象来调用,因此会先执行外部类的构造方法,于是该发生的还是会发生。
写的很乱,这是我的第二篇博文,欢迎各位拍砖。
分享到:
相关推荐
在这个特定的情景中,"static解析并显示html"指的是利用MFC中的CStatic控件来显示HTML内容。CStatic是MFC中用于创建静态文本、图像或自定义控件的类,通常用来展示不可编辑的信息。 当我们想要在MFC应用中显示HTML...
**二、mingw73_static解析** mingw73_static是指MinGW-w64的静态编译版本,MinGW-w64是一个为Windows平台提供GCC编译器的项目,它包含了针对不同体系结构(如x86和x64)的编译器和运行时库。"static"表示这个编译器...
解析:接口中的所有成员默认都是public,不能用private、protected或static修饰。 5. 下列正确的有? 正确答案:A.call by value不会改变实际参数的数值;D.call by reference能改变实际参数的内容 解析:Java...
解析:在Java中,静态(static)关键字用于声明类方法或类变量。类方法属于类本身,而不是类的任何实例,可以直接通过类名调用。 2. 术语“类变量”是哪个的同义词? (a) 只读变量 (b) 私有数据字段 (c) 静态数据...
Java中的`static`关键字在编程中扮演着至关重要的角色,它是Java面向对象特性的一个关键组成部分。`static`关键字用于修饰变量、方法以及嵌套类,它使得这些元素可以在不创建对象的情况下被访问。 首先,我们来看...
Java 中的 static 关键字 ...在 Java 中,类装载器把一个类装入 Java 虚拟机中,要经过三个步骤来完成:装载、链接和初始化,其中链接又可以分成校验、准备和解析三步,除了解析外,其它步骤是严格按照顺序完成的。
在C++编程中,开发一个能够解析HTML并将其内容显示在静态控件(Static Control)中的功能是一项常见的需求,尤其是在创建自定义用户界面时。在这个项目中,我们看到的是一组源代码文件,它们可能构成了一个小型库或...
本文将从不同角度对`static`在C语言中的应用进行深入解析,并结合具体的示例来帮助理解其背后的逻辑。 #### 一、`static`变量的基本概念与特性 1. **局部静态变量**: - 当在一个函数内部定义了一个`static`变量...
本文将全面解析`static`关键字的用途、常见误区以及在面试和笔试中可能出现的相关问题。 首先,`static`关键字主要用于声明类级别的成员,包括静态方法(`static` methods)、静态变量(`static` variables)以及...
本资料主要解析了`static`关键字的各种应用,帮助开发者深入理解其工作原理和用法。 首先,`static`关键字用于声明类级别的变量和方法,这意味着它们属于类本身,而不是类的任何实例。当类被加载时,静态变量和静态...
public static void main(String[] args) throws NamingException { String ipAddress = "8.8.8.8"; // Google DNS server's IP InitialContext context = new InitialContext(); javax.naming.directory....
Java static关键字解析静态内部类(默认指外部类的内部类)静态方法静态变量静态语句块 范围:只围绕外部类进行讨论,例如内部类的内部类这种多层套娃式的暂不进行讨论 jdk版本: jdk8 静态内部类(默认指外部类的...
本文将深入探讨Java中的静态块与静态方法,解析它们的区别、联系以及执行顺序,帮助读者更全面地理解`static`关键字在Java中的运用。 ### 静态方法 静态方法是通过`static`关键字声明的,它属于类而不属于类的任何...
在Java编程语言中,static关键字是一个非常重要的概念,它用于定义类的成员变量和成员方法,使其成为静态的,即属于类本身而非类的任何特定对象。这种成员变量和方法被所有对象共享,它们的生命周期与类的生命周期...
静态数据成员必须在类外进行初始化,且初始化语句不加作用域解析运算符`::`。例如: ```cpp class MyClass { public: static int count; }; int MyClass::count = 0; // 初始化静态成员 ``` 6. **C++11引入...
下面将详细解析这两个关键字的用法及其在Java中的重要性。 ### 一、`final`关键字 `final`关键字在Java中有多种用途,它可以用来修饰类、方法和变量,其主要目的是确保被修饰的对象具有不可变性或只读性。 #### 1...
### 继承与Static知识点详解 #### 一、继承与Static的基本概念 在Java中,继承是一种类之间的关系,允许一个类(子类)继承另一个类(父类)的属性和方法。通过继承,可以实现代码复用,提高程序的可维护性。 `...
public static void main(String[] args) { // 加载YAML文件 InputStream inputStream = YamlParser.class.getResourceAsStream("/config.yaml"); // 创建Yaml实例 Yaml yaml = new Yaml(); // 解析YAML...