java静态内部类加载

A. java中的静态内部类的特点是什么

需要了解2个概念：内部类和静态修饰符static1）首先，用内部类是因为内部类与所在外部类有一定的关系，往往只有谨核该外部类调用此内部类。所以没有必要专门用一个Java文晌镇件存放这个类。2）静态都是用来修饰类的内部成员的。比如静态方法，静态成员变量，静态常量。

它唯一的作用就是随着类的加载（而不是随着对象的产生）而产生，以致可以用类名+静态成员名直接获得。这样静态内部类就宴晌粗可以理解了，因为这个类没有必要单独存放一个文件，它一般来说只被所在外部类使用。

并且它可以直接被用 外部类名+内部类名 获得。以下举例说明怎么使用：Student类有个叫School的内部类（非静态）Student stu = new Student();stu.School sch = new stu.School();sch就是School的一个对象。假如School是内部静态类：Student.School sch = new Student.School()。

B. java 中静态内部类字段什么时候初始化是在外部类加载的时候就初始化吗

首先分析下名字：静态内部类
静态是static。静态的方法或者参数是随着类的加载而产生的（感觉应该是JVM启动时static属性就加载了。）。这就是为什么不用实例化类，就可以调用它的原因。
内部类：用内部类是因为内部类与所在外部类有一定的关系，往往只有该外部类调用此内部类。其他类不会调用。所以没必要另写一个类。外部类可以调用内部类。而内部类不能调用外部类的方法。
所以我觉得
静态内部类中的属性，方法，是在外部类加载的时候初始化的。
希望对您有帮助。如果有问题请自行
谷歌
度娘.

C. Java：静态内部类调用外部类的方法

static 用在类前面只是表示这个内部类与外面的类之间没有实例之间的引用关系，是可以在内部类中直接创建外面的类的实例的。编译器不会为我们自动创建关联引用，但我们可以创建非关联的实例。

这个时候相当于只是给了特定的可见性控制。

你创建两个内部类，一个 static，一个非 static 然后在 eclipse 的 navigator 视图中打开你的类观察，那个非 static 类，编译器自动创建了一个成员变量用来在外部类和内部类之间建立关联。

D. java 中静态内部类字段什么时候初始化

不是的，只有在加载内部类的时候才初始化 //有问题可以继续交神瞎租流x0dx0a楼主只要看懂一下的代码x0dx0a那么对于类的加载x0dx0a基本上就没问神埋题了x0dx0a最后类的加载过程的解释x0dx0apublic class Test6 {x0dx0a public static void main(String[] args){x0dx0a new B();x0dx0a new A.C();x0dx0a }x0dx0a}x0dx0ax0dx0aclass A{x0dx0a private P p1 = new P("A--p1");x0dx0a static P p3 = new P("A--p3");x0dx0a public A(){x0dx0a System.out.println("A()");x0dx0a }x0dx0a private P p2 =new P("A--p2");x0dx0a static{x0dx0a new P("A--static"); x0dx0a }x0dx0a {new P("A{...}");}x0dx0a x0dx0a public static class C {x0dx0a private P p1 = new P("C--p1");x0dx0a static P p3 = new P("C--p3");x0dx0a public C(){x0dx0a System.out.println("C()");x0dx0a }x0dx0a private P p2 =new P("C--p2");x0dx0a static{x0dx0a new P("C--static"); x0dx0a }x0dx0a {new P("C{...}");}x0dx0a }x0dx0a}x0dx0ax0dx0aclass B extends A {x0dx0a private P p1 = new P("B --p1");x0dx0a static P p3 = new P("B -- p3");x0dx0a public B() {x0dx0a System.out.println("B()"); x0dx0a }x0dx0a public P p2 = new P("B -- p2");x0dx0a static {x0dx0a new P("B -- static");x0dx0a }x0dx0a x0dx0a {new P("B{...}");}x0dx0a}x0dx0ax0dx0aclass P {x0dx0a public P(String s) {x0dx0a System.out.println(s);x0dx0a } x0dx0a}x0dx0a/*x0dx0a x0dx0a有父类的情况x0dx0a1. 加载父类x0dx0a 1.1 为静态属性分配存储空间并赋初始值 x0dx0a 1.2 执行静态初始化块和静态初始化语句（从上至下）x0dx0a2. 加载子类x0dx0a 2.1 为静态属性分配存储空间x0dx0a 2.2 执行静态游兆初始化块和静态初始化语句（从上至下）x0dx0a3. 加载父类构造器x0dx0a 3.1 为实例属性分配存数空间并赋初始值 x0dx0a 3.2 执行实例初始化块和实例初始化语句x0dx0a 3.3 执行构造器内容x0dx0a4. 加载子类构造器x0dx0a 4.1 为实例属性分配存数空间并赋初始值 x0dx0a 4.2 执行实例初始化块和实例初始化语句x0dx0a 4.3 执行构造器内容x0dx0a5 回到main()x0dx0a内部类的加载过程也一样x0dx0a*/

E. Java 静态内部类作用

1、变值权限修饰作用，在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。

2、在某些特殊的情况下，少了这个静态内部类还真是不行。如在进行代码程序测试的时候，如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序的入口，必须具有)，那么会出现很多额外的代码。

3、最主要的时这段主程序的代码对于Java文件来说，只是一个形式，其本身并不需要这种主方法。但是少了这个主方法又是万万不行的。在这种情况下，就可以将主方法写入到静态内部类中，从而不用为每个Java源文件都设置一个类似的主方法。

这对于代码测试是非常有用的。在一些中大型的应用程序开发中，则是一个常用的技术手段。

(5)java静态内部类加载扩展阅读

例如：

对于两个类，拥有相同的方法：

class People{

run();

}

interface Machine{

run();

}

此时有一个robot类：

class Robot extends People implement Machine.

此时run()不可直接实现。

interface Machine{

void run();

}

class Person{

void run(){

System.out.println("run");

}

}

class Robot extends Person{

private class MachineHeart implements Machine{

public void run(){

System.out.println("heart run");

}

}

public void run(){

System.out.println("Robot run");

}

Machine.getMachine(){returnnew MachineHeart();

}

class Test{

publicstaticvoid main(String[] args){

Robot robot=new Robot();

Machine m=robot.getMachine();

m.run();

robot.run();

}

}

F. Java中static的作用

1.static 成员变量

在 Java 中还支持用 static 修饰的内部类，称为静态内部类。静态成员内部类的特点主要是它本身是类相关的内部类，所以它可以不依赖于外部类实例而被实例化。静态内部类不能访问其外部类的实例成员（包括普通的成员变量和方法），只能访问外部类的类成员（包括静态成员变量和静态方法）。即使是静态内部类的实例方法（非静态成员方法）也不能访问其外部类的实例成员。

G. java 内部类为什么不能用静态方法

静态的对象，在内存中实默认实例派察化尘咐茄的，在加载的时候就会存放到内存中。也就是可以直接调用而不需要手动实例化。理解这个就不难理解楼主说的问题了。首先内部的静态类他是不能直接被实例化的。你必须实例化外部类才能实例简亩化它。而外部类不是默认加载的，他只有在手动实例化之后才有内存分配。这时问题出现了。既然静态对象是默认加载，那么静态内部类应该先于外部类被加载到内存中。那么这是又和我们之前的一个结论相反（首先内部的静态类他是不能直接被实例化的。你必须实例化外部类才能实例化它。）所以这种写法是错误的。

H. java中静态内部类什么时候加载

只有在加载内部类的时候才初始化
看懂以下的代码，那么对于类的加载，基本上就没问题了，最后类的加载过程的解释
public class Test6 {
public static void main(String[] args){
new B();
new A.C();
}
}

class A{
private P p1 = new P("A--p1");
static P p3 = new P("A--p3");
public A(){
System.out.println("A()");
}
private P p2 =new P("A--p2");
static{
new P("A--static");
}
{new P("A{...}");}

public static class C {
private P p1 = new P("C--p1");
static P p3 = new P("C--p3");
public C(){
System.out.println("C()");
}
private P p2 =new P("C--p2");
static{
new P("C--static");
}
{new P("C{...}");}
}
}

class B extends A {
private P p1 = new P("B --p1");
static P p3 = new P("B -- p3");
public B() {
System.out.println("B()");
}
public P p2 = new P("B -- p2");
static {
new P("B -- static");
}

{new P("B{...}");}
}

class P {
public P(String s) {
System.out.println(s);
}
}
/*

有父类的情况
1. 加载父类
1.1 为静态属性分配存储空间并赋初始值
1.2 执行静态初始化块和静态初始化语句（从上至下）
2. 加载子类
2.1 为静态属性分配存储空间
2.2 执行静态初始化块和静态初始化语句（从上至下掘森前）
3. 加载父类构造器
3.1 为实例属性分配存数空间并赋初始值
3.2 执判清行实例初始化块和实例初始化语句
3.3 执行构造春滑器内容
4. 加载子类构造器
4.1 为实例属性分配存数空间并赋初始值
4.2 执行实例初始化块和实例初始化语句
4.3 执行构造器内容
5 回到main()
内部类的加载过程也一样

I. java中的静态内部类有什么特点

特点：
1、静态内部类无需依赖于外部类，它可以独立于外部对象而存在。
2、静态内部类，多个外部类的对象可以共享同一个内部类的对象。
3、使用静态内部类的好处是加强了代码的封装性以及提高了代码的可读性。
4、普通内部类不能声明static的方法和变量，注意这里说的是变量，常量（也就是final static修饰的属性）还是可以的，而静态内部类形似外部类，没有任何限制。

有问题欢迎提问，满意请采纳，谢谢！

J. java的静态类型有什么特点

静态属性：随着类的加载而加载，该属性不属于某个对象，属于整个类
静态方法：直接使用类名春誉调哗谨用，静态方法里不能访问乱森基非静态成员变量
静态类：不能直接创建对象，不可被继承