因此，举个例子，我有一个JNI代码：
/** This literally does nothing. It's purpose is to call the static initializer early to detect if we have issues before loading. */
public static void nothing() {
}
static {
// should be loaded by CLib
if (CLib.hasGNUTLS() == 1) {
globalinit();
}
}
我发现自己
浏览 1提问于2015-08-12得票数 6
回答已采纳
2回答
我不太理解下面的static代码块。在使用方法和变量时，我理解static关键字，但我不知道static关键字在以下代码中的确切用途。
static
{
sURIMatcher.addURI("contacts", "people", PEOPLE);
sURIMatcher.addURI("contacts", "people/#", PEOPLE_ID);
sURIMatcher.addURI("contacts", "people/#/phone
浏览 0提问于2013-01-09得票数 0
回答已采纳
3回答
据说java中的静态块只在类被加载时运行一次。但这到底是什么意思呢？JVM (Java Virtual Machine，Java虚拟机)在哪个点装入类？
是调用该类中的main方法的时候吗？而且，当main方法开始执行时，同一个类的所有超类也会被加载吗？
考虑A扩展B，B扩展C，它们都有静态块。如果A有main方法，那么静态块的执行顺序是什么？
浏览 0提问于2011-12-18得票数 18
回答已采纳
想象一个Java类，它拥有一个类中可以找到的大多数特性。例如:它继承了另一个类，实现了几个接口，包括一些'static final‘常量，一些final常量，一些静态变量，实例变量，一个静态块，一个未命名的代码块(就是{}中的代码)，构造函数，方法等等。
当所讨论的类第一次加载到JVM中时，该类的各个部分是按什么顺序初始化或加载到JVM中的？对于加载，JVM中的调用堆栈是什么样子的？假设这里只有一个类加载器在工作。
这将回到Java的绝对基础/内部，但我还没有找到一篇好的文章来解释正确的顺序。
浏览 1提问于2009-11-19得票数 6
回答已采纳
1回答
在c++中虚拟继承中构造函数调用的顺序是什么？
对于以下两种情况下的多重继承；
(1)下列代码，没有虚拟继承；
class a
{
public:
a()
{
cout<<"\t a";
}
};
class b: public a
{
public:
b()
{
cout<<"\t b";
}
};
class c: public b
{
public:
浏览 3提问于2016-05-15得票数 4
2回答
类初始化死锁机制解释
、、、、
我找到了@apangin()中关于我母语的文章()，但我无法理解它。解释很简洁
让我们考虑一下这段代码：
static class A {
static final B b = new B();
}
static class B {
static final A a = new A();
}
public static void main(String[] args) {
new Thread(A::new).start();
new B();
}
你可以试着运行这段代码。在我的个人电脑上，它以75%的概率导致死锁。
所以我们有两个线程：
Thread_1正
浏览 1提问于2018-12-08得票数 1
回答已采纳
4回答
类初始化和同步类方法
、、、
在我的应用程序中，有一个类如下所示：
public class Client {
public synchronized static print() {
System.out.println("hello");
}
static {
doSomething(); // which will take some time to complete
}
}
该类将在多线程环境中使用，许多线程可能同时调用Client.print()方法。我想知道线程-1是否有可能触发类初始化，在类初始化完成之前，线程-2进入print
浏览 0提问于2011-01-07得票数 8
3回答
我在静态初始化块上发现了很多帖子，但我试图更好地了解执行顺序及其原因。下面的代码在两个静态块中打印文本，然后“然后”在主静态块中打印出文本。
我理解编译器调用的方式，这就是在加载类时按顺序执行所有静态块，然后访问main方法。但是，既然主方法本身是静态的，那么为什么不按照其他静态块的顺序执行它(甚至不确定它是否有用，只是试图理解一个概念，以及是否有迫切的理由这样做)。如果有静态块，我们想要运行主块呢？
class Cat {
static
{
System.out.println("This block welcomes you first")
浏览 6提问于2014-12-24得票数 6
回答已采纳
1回答
我刚刚注意到，在类的静态初始化过程中，创建和启动许多线程会导致死锁，并且不会启动任何线程。如果在初始化类之后动态运行相同的代码，则此问题将消失。这是预期的行为吗？
短示例程序：
package com.my.pkg;
import com.google.common.truth.Truth;
import org.junit.Test;
import java.util.Collection;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurre
浏览 1提问于2017-07-21得票数 4
回答已采纳
我在课堂初始化时碰到了Netty的问题。我认为静态字段总是在实例字段之前初始化，但显然不是这样的：
类AbstractByteBuff包含一个static final ResourceLeakDetector<ByteBuf> leakDetector
类AbstractReferenceCountedByteBuf extends AbstractByteBuff
类UnpooledUnsafeDirectByteBuf extends AbstractReferenceCountedByteBuf
第一次创建UnpooledUnsafeDirectByteB
浏览 7提问于2013-08-19得票数 2
回答已采纳
实现单例的一种常用方法(，)是使用具有静态成员的内部类：
public class Singleton {
private static class SingletonHolder {
public static final Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
private Singl
浏览 0提问于2017-10-03得票数 13
回答已采纳
1回答
我有一个父类，其中定义了存储关系函数，还有一个子类，它定义了存储上的表。在父类中，我定义了一个save()函数，它连接到实例的表，但是表是在子表上定义的。我想我可以设置父函数的构造函数来接受子tableName，但是我的linter抱怨在引用this之前必须调用super (尽管我想将this上的一个属性传递到超级)。
以下是家长：
export class StoredObject {
constructor(private tableName: string) {}
public save() {
store.collection(this.tableNa
浏览 0提问于2016-05-17得票数 2
回答已采纳
1回答
我想将以下代码添加到我的类中：
static private final ILogic_P logicInstanceI =
(ILogic_P)Factory.CreateAnon("some.path.ILogic_P" + (SomeClass.isIMDB() ? "1" : "2"));
public static ILogic_P getLogicInstanceI(){
return logicInstanceI;
}
我无法确定静态变量的初始化是否是线程安全的。有可能两个线程同时尝试初始化这个属性吗？
浏览 2提问于2015-12-09得票数 2
回答已采纳
我如何知道哪个初始化器是任何类的指定初始化器？我猜它是需要最多参数的一个，但有时这可能是不正确的。
浏览 2提问于2011-05-27得票数 10
回答已采纳
2回答
class A {
static {
System.out.println("A-SIB");
}
static void test(){
System.out.println("A-test");
}
}
class B extends A {
static {
System.out.println("B-SIB");
}
}
class C {
public static void main(String args []){
浏览 1提问于2014-03-04得票数 10
回答已采纳
1回答
在阅读了C++11和有关它的一般指导方针之后，我经常阅读有关如何使用类内初始化和聚合初始化的文章。
下面是一个似乎是“老”的做事方式的例子：
class Example
{
public:
// Set "m_x" to "x", "m_y" gets set to the default value of 5
Example(int x) : m_x(x), m_y(5)
{
}
private:
int m_x;
int m_y;
};
据我所知，这就是人们现在所建议的：
class Exa
浏览 0提问于2018-02-26得票数 0
回答已采纳
1回答
最后确定虚拟继承
、、
在我的代码中，我有一个基本的钻石图案：
CommonBase
/ \
/ \
DerivedA DerivedB
\ /
\ /
Joined
它是这样实现的，公共基类具有一个默认构造函数和一个接受参数的构造函数：
struct CommonBase {
CommonBase() : CommonBase(0) {}
CommonBase(int val) : value(val) {}
const int value;
};
struct DerivedA :
浏览 0提问于2018-12-17得票数 3
回答已采纳
3回答
下面的代码给出了正确的输出，如果我声明变量i和j，比如int i, j;
class A
{
int i, j;
public:
A(int val) : i(val), j(i + 1)
{
cout<<i<<endl<<j<<endl;
}
};
但是如果我声明变量i和j，比如int j, i;。然后j打印垃圾值。
class A
{
int j, i;
public:
A(int val) : i(val), j(i + 1)
{
cout<<
浏览 3提问于2017-08-23得票数 4
回答已采纳
5回答
我是Swift的新手，遇到了一些关于初始化器的问题。我已经用以下代码创建了一个Swift文件：
import Foundation
class SuperClass
{
var a : Int
init()
{
a = 10
print("In Superclass")
}
}
class SubClass : SuperClass
{
override init()
{
print("In Subclass")
}
}
在上面的代码中，init() of
浏览 5提问于2016-06-30得票数 3
回答已采纳
2回答
在多次简化代码之后，我发现了以下问题的原因。
class B {
public:
B(const int x)
:_x(x) {}
const int _x;
};
class C {
public:
C(const B& b)
: _b(b), _b2(_b._x) {}
B _b2; // line 1
const B& _b; // line 2
};
int main() {
B b(1);
C c(b);
}
警告(clang 8.0.0)
test1
浏览 1提问于2017-01-27得票数 2
回答已采纳
5回答
在java中创建实例变量
、、、
如果我有以下场景：
public class Foo extends Baz{
private String banana = "banana";
//blah blah blah
}
public class Baz{
protected static String apple = "apple";
}
苹果和香蕉，哪个最先被创造出来？我想说苹果是第一个被创造出来的，但我不确定。
浏览 2提问于2012-07-11得票数 2
回答已采纳
我有一个定制的UILabel类。
class CustomLabel: UILabel{
init(_ title: String = "Star"){
super.init(frame: CGRect.zero)
text = title
}
override init(frame: CGRect) {
fatalError("Not Implemented")
}
required init?(coder aDecoder: NSCoder) {
浏览 1提问于2019-09-11得票数 1
回答已采纳
3回答
让我们有一个类的对象o --某种类型，它包含成员、子对象、so和其他类类型的sso。请考虑以下示例：
#include <iostream>
using namespace std;
struct SO{ SO(){ cout << "SO()" << endl; } };
struct SSO{ SSO(){ cout << "SSO()" << endl; } };
struct O
{
O(){ cout <<
浏览 4提问于2014-08-13得票数 2
3回答
我在中看到用户指定了一个convenience required init()。这到底是什么意思？
我知道required关键字用于重写超类的指定初始化器，但是convenience required声明性做了什么？
浏览 5提问于2014-11-14得票数 16
回答已采纳
5回答
据我所知，当我在派生类初始化列表中初始化基类时，基类将立即被构造，然后基类元素应该是可用的。如果这是对的，为什么这个不起作用？
class Base
{
public:
int elem;
}
class Derived : public Base
{
Derived() : Base(), elem(1) {}
// error: class 'Derived' does not have any field named 'elem'
}
注意:在我的例子中，不能对Base进行任何更改(它是一个固定的接口类)。
浏览 0提问于2013-10-16得票数 2
2回答
根据
A类或接口类型T将在第一次出现以下任何一项之前被initialized：
T是一个类，并且创建了T的一个实例。
它还说，
类的初始化( Initialization )由执行静态初始化器和类中声明的静态字段(类变量)的初始化器组成
我由此推断出两点
如果类为instantiated.，则会发生静态initializersClass初始化，即执行类的初始化
现在,
我假设当我在自己的( Test自己的)静态初始化器中创建一个类Test的对象时，它应该抛给我一个堆栈溢出，因为它应该反复调用自己，因为根据以上两点，类的实例化应该初始化类，而初始化块具有类的实例化。当我在类自己的构造函数或
浏览 35提问于2015-07-20得票数 16
回答已采纳
5回答
我想问为什么java在初始化非静态对象之前先初始化静态对象？
在此示例中，将在b4和b5之后初始化b3：
class Cupboard {
Bowl b3 = new Bowl(3);
static Bowl b4 = new Bowl(4);
Cupboard() {}
static Bowl b5 = new Bowl(5);
}
浏览 0提问于2010-04-16得票数 5
回答已采纳
我在浏览一些类时发现了一个哈希集实现，如下所示
public static HashSet<String> set = new HashSet<String>();
static{
set.add("abc");
set.add("def");
set.add("eghi");
}
在static block中，我只想知道这个模式，static，initialization.Does，it最初是什么意思，当jvm启动时，我们设置了initialized值。
浏览 1提问于2013-07-23得票数 1
3回答
class Base
{
public:
Base(){}
Base(int k):a(k)
{
}
int a;
};
class X:virtual public Base
{
public:
X():Base(10){}
int x;
};
class Y:virtual public Base
{
public:
Y():Base(10){}
浏览 1提问于2010-03-10得票数 3
回答已采纳
2回答
我有一个关于对基本构造函数的隐式和显式调用的问题。如果我们有这样的类层次结构：
class Person{
protected:
std::string m_name;
public:
Person(std::string& _name) : m_name(_name){std::cout << "A person is being constructed." << std::endl;}
};
class Baby : public Person{
private:
in
浏览 0提问于2015-05-19得票数 4
回答已采纳
2回答
元类和构造函数
、、
据我所知，在Smalltalk和Objective-C中创建类的构造函数是困难的。这是因为构造函数不能是类实例的消息，因为类class尚未定义。
据我所知，解决方案是创建一个新类，它的唯一实例本身就是一个类。但是在这种情况下构造器是如何工作的呢？我不明白这个过程。
浏览 0提问于2011-06-11得票数 1
我有一个定义如下的类：
class MyClass {
private static final String name = "<some string>";
private static final String schema = "{<some json here>}";
public static final MySchemaObject schemaObj = MyUtils.staticSchema(name, schema); // Line1
public static MySchema
浏览 4提问于2021-03-19得票数 0
回答已采纳
3回答
代码：
class A {
static {
System.out.println("loading A static 1");
}
static {
System.out.println("loading A static 2 B.c= "+B.c);
}
static {
System.out.println("loading static 3");
}
static int a=10;
A(){
浏览 5提问于2014-04-01得票数 6
回答已采纳
TPath记录具有初始化类变量的类构造函数TPath.Create。但是，我找不到任何使用/调用TPath.Create的单元，尽管所有变量都有正确的值(TPath.PathSeparator，...)。
浏览 3提问于2012-01-31得票数 5
回答已采纳
4回答
我有以下节目：
#include<iostream>
using namespace std;
struct Base01{
int m;
Base01():m(2){}
void p(){cout<<m<<endl;}
};
struct Derived01:public Base01{
Derived01():m(3){}
};
struct Derived02:virtual public Base01{
Derived01():m(4){}
};
struct my: Derived0
浏览 4提问于2017-07-09得票数 2
回答已采纳
3回答
对于java和静态变量有一点疑问。我有类似的情况，问题是: MyObject()构造函数在创建MyClass的新实例时只运行一次或每次运行一次。
public class MyClass{
static MyObject obj = new MyObject();
...
谢谢!
浏览 0提问于2014-01-03得票数 3
回答已采纳
据我所知，每当一个类被加载时，JVM就会为它创建一个Class.class对象，它存储加载类的所有元信息。
当我们使用forName( "classname“)方法时，它首先加载”classname“，然后为它创建Class.class对象并返回对创建的Class.class对象的引用。
Example.java的定义为：
class Example
{
static
{
System.out.println("Example Loaded");
}
Example()
浏览 2提问于2016-04-26得票数 0
回答已采纳
理解如何加载类和调用静态初始化程序
所以，我只是想确认一下-
public class OOMErrorB extends OOMErrorA {
public static int c = 10;
static {
System.out.println("Loading static B " + c);
System.out.println(OOMErrorA.a);
}
public static void main(String[] args) {
new OOMErrorB();
浏览 2提问于2015-05-09得票数 3
回答已采纳
1回答
我有以下类，它们构成多级继承模型。
class CavPkoTest : virtual public CavTest
{
public:
CavPkoTest() : CavTest{CAV_TEST_ID_PKO}, NpBaseTest{CAV_TEST_ID_PKO, MODULE_CAV_TEST} {}
}
class CavTest : virtual public NpBaseTest
{
public:
CavTest(uint16_t p_testId) : NpBaseTest{p_testId, MODULE_CAV_TEST} {}
}
class
浏览 2提问于2017-02-06得票数 0
回答已采纳
1回答
使用目标-C，我会像这样初始化我的类：
SomeClass *anInstance = [SomeClass new]
anInstance.importantInt = 4;
anInstance.importantString = @"Vip";
anInstance.importantDelegate = self;
[anInstance initialize];
我这样做是为了避免重写我的初始化器，或者在一个类的开发过程中避免使用重复代码的多个初始化器。我正在调用-(void)initialize来完成实例的设置。
通过这种方式，我可以使用点表示法来分配属性，如果
浏览 3提问于2015-08-06得票数 0
回答已采纳
可以做到以下几点吗？
1)非指定初始化器调用超类的指定初始化器
2)类的指定初始化器调用超类的非指定初始化器？
或者，流程必须是：
a)指定的初始化器必须调用超类的指定初始化器
b)非指定初始化器必须调用自己类的指定初始化器
如果违反了上面的(1)或(2)，会发生什么？(或者，如果我们必须始终遵循(a)和(b)，其背后的原因是什么？)
浏览 0提问于2012-09-24得票数 3
2回答
我相信受保护成员可以通过继承类来访问。那么，我在思考过程中的错误是相信这是可以的吗？
我有一些类，食物和Veg，其中Veg继承自食物。食物有一个受保护的成员int age；在Veg的构造函数中，我尝试将age初始化为0。为什么这是无效的？
一些代码。
Veg::Veg():age(0)
{
cout << "Veg constructor." << endl;
}
class Veg : public Food
{
//snip
};
class Food
{
//snip
protected:
int age;
};
浏览 2提问于2011-03-10得票数 1
我有一个类，它使用静态初始化块来做一些事情。我的理解是，这个块是在加载类时执行的，这是通过调用类中的一些方法来触发的。
我的问题是，这种静态初始化是否可以从像spring这样的框架中触发，比如查看类来检查它们的注释等等？
浏览 1提问于2021-09-02得票数 0
回答已采纳
3回答
请用java解释这种行为。
、、、、
class abc extends TestStart{
static{
System.out.println("c");
}
{
System.out.println("f");
}
public abc(){
System.out.println("d");
}
}
public class TestStart {
static {
System.out.println("A");
浏览 0提问于2015-11-20得票数 0
1回答
看来，我缺少了锁定类的重要概念，而且根据我在java中的知识，它是相关的类加载event.As，只有当类加载器已经在内存中加载类(字节代码)时，我们才能使用任何类。基于这个假设，我认为“当语句同步( SharedQ ){.}在下面的代码中执行时，应该执行SharedQ类的静态块”。但这不一样。有人能解释一下这里到底发生了什么吗。
public class VerifyClassLoadingOnClassLock {
public static void main(String[] args) {
show();
}
private static vo
浏览 3提问于2015-01-06得票数 4
回答已采纳
我知道有很多关于单身模式的问题。但在这里，我想了解的是输出，这也可能涉及“静态”在Java中的工作方式。
public class Singleton {
private static Singleton currentSingleton = new Singleton();
public static Singleton getSingleton() {
return currentSingleton;
}
private Singleton() {
System.out.println("Singleton pr
浏览 2提问于2012-10-24得票数 3
回答已采纳
1回答
当我单独运行测试类时，一切都是好的和绿色的。但是当我在Intellij中一起运行测试时，有些测试失败了。
我用以下代码再现了这种行为：
public class TestSut {
public static String test = "test";
public static String test() {
return test;
}
}
这是第一个测试：
@RunWith(JMockit.class)
public class Test1 {
@Mocked(stubOutClassInitialization =
浏览 5提问于2016-08-03得票数 0
回答已采纳
2回答
以这个类为例：
public class Example {
static {
// Do something
}
}
静态块到底是什么时候调用的？
浏览 2提问于2015-05-17得票数 3
回答已采纳
2回答
我对类和超类共享字段有点困惑。我原以为这是可以的：
class SuperC {
public:
SuperC();
protected:
double value;
};
class C : public SuperC {
public :
C(double value);
};
SuperC::SuperC(){}
C::C(double value):SuperC(),value(value){}
但是编译器告诉我C没有"value“字段。C不继承SuperC中定义的C？
多个thx
浏览 0提问于2013-04-12得票数 5
回答已采纳
3回答
c++虚拟继承
、、、
问题：
class Base {
public:
Base(Base* pParent);
/* implements basic stuff */
};
class A : virtual public Base {
public:
A(A* pParent) : Base(pParent) {}
/* ... */
};
class B : virtual public Base {
public:
B(B* pParent) : Base(pParent) {}
/* ... */
};
class C : public A, public B {
publ
浏览 0提问于2010-01-24得票数 22
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
