深入理解JVM（12）——类加载（2）——类的主动使用和被动使用

最新推荐文章于 2026-06-24 15:57:47 发布
原创 最新推荐文章于 2026-06-24 15:57:47 发布 · 785 阅读 · 4 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文深入探讨了Java中类的主动使用和被动使用的概念，详细阐述了主动使用包括创建类实例、访问静态变量、调用静态方法等7种情况，并通过代码示例解释了每种情况的触发条件和效果。此外，还讨论了Java虚拟机的生命周期，数组创建的本质以及类加载的准备和初始化阶段的重要性。

目录

1.Java对类的主动使用和被动使用

1.1 主动使用（七种）

（1）上述主动使用规则的典型举例

（2）主动使用与final

（3）初始化时类与接口的区别

1.2 被动使用

2.Java虚拟机与程序的生命周期

3.数组创建本质分析

4.类加载的准备阶段和初始化阶段的重要意义

1.Java对类的主动使用和被动使用

所有Java虚拟机实现必须在每个类或接口被Java程序“首次主动使用”时才初始化

1.1 主动使用（七种）

  • 1.通过new关键字创建类的实例
  • 2.访问某个类或接口的静态变量（字节码助记符getstatic），或对该静态变量赋值（字节码助记符putstatic）
  • 3.调用类的静态方法（字节码助记符invokestatic）
    • 其实第3种和第二种本质上可以划分为同一种情况，因为它们反映到字节码助记符的层面上大体上是类似的含义
    • 注意：
      • 只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用
  • 4.反射（如Class.forName("com.test.Test")），通过反射的方式获得类的对象，也是对类的主动使用
  • 5.初始化一个类的子类
  • class Parent{}

class Child extend Parent{}


//当我去初始化Child类的时候，也会对Parent进行初始化
  • 6.Java虚拟机启动的时候被标记为启动类的类，即包含Main方法的类
  • 7.JDK1.7开始提供动态语言支持（如我们可以在JVM上使用脚本语言的引擎调用JavaScript（动态语言）代码）：
  •     java.lang.invoke.MethodHandle实例的解析结果REF_getStastic、REF_putStastic、REF_invokeStastic句柄对应的类没有初始化，则进行初始化

（1）上述主动使用规则的典型举例

代码演示1：通过new关键字创建类的实例

public class Demo01 {
    public static void main(String[] args) {
        MyParent04 myParent04 =new MyParent04();
        System.out.println("==============");
        MyParent04 myParent04_1 = new MyParent04();
    }
}

class MyParent04{

    static {
        System.out.println("MyParent03 static code");
    }
}

运行结果：

分析1：

  • 类被首次主动使用时（上述代码为new出对象实例），进行初始化，可以看到第二次主动使用该类时，并未再次进行初始化

代码演示2：访问父类的静态变量

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyChild.str1);
    }
}

class MyParent
{
    public static String str1="Hello,World!";

    static{
        System.out.println("MyParent static block");
    }
}

class MyChild extends MyParent
{
    static{
        System.out.println("MyChild static block");
    }
}

运行结果：

分析2：

  • 对于静态字段来说，只有直接定义了该字段的类才会被初始化
  • 上述静态字段str1，直接定义它的类为MyParent，所以在访问str1的时候，MyParent被主动使用，MyParent会被初始化，虽然使用了MyChild这个名字，但是没有主动使用MyChild中的静态方法或变量，所有Java虚拟机实现必须在每个类或接口被Java程序“首次主动使用”时才初始化，所以MyChild类不会被初始化，所以，最终只会调用MyParent中的静态代码块，而不会调用MyChild中的静态代码块

此处疑问：MyChild类没有被初始化，但有没有被加载呢？

我们可以使用JVM的参数-XX:+TraceClassLoading参数用于追踪类的加载信息并打印

   

我的查看结果：

  • 可以发现MyChild虽然没有被初始化，但被加载了

其他JVM参数：

//JVM的一些选项默认开启，一些默认关闭

-XX:+<option>     表示开启option选项

-XX:-<option>     表示关闭option选项

-XX:<option>=<value>  表示option选项的值设置为value

代码演示3：访问子类的静态变量

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyChild.str2);
    }
}

class MyParent
{
    public static String str1="Hello,World!";

    static{
        System.out.println("MyParent static block");
    }
}

class MyChild extends MyParent
{
    public static String str2="Welcome";

    static{
        System.out.println("MyChild static block");
    }
}

运行结果：

分析3：

  • 对子类的静态字段str2的调用是对MyChild类的主动使用，所以子类MyChild会被初始化，由于当初始化一个子类时，要求父类全部都被初始化，所以父类MyParent也会被初始化，所以最终结果先执行了父类静态代码块，后执行了子类静态代码块

代码演示4：访问包含Main的类

package JVMDemo01;

class MyParent
{
    public static String str1="Hello,World!";

    static{
        System.out.println("MyParent static block");
    }
}

class MyChild extends MyParent
{
    public static String str2="Welcome";

    static{
        System.out.println("MyChild static block");
    }
}

public class Demo01 {

    static {
        System.out.println("Demo01 static block");
    }

    public static void main(String[] args) {
        System.out.println(MyChild.str2);
    }
}

分析4：

  • 访问包含Main方法的类，即主动使用Demo01，导致了Demo01先进行了初始化
  • 然后对子类的静态字段str2的调用是对MyChild类的主动使用，所以子类MyChild会被初始化，由于当初始化一个子类时，要求父类全部都被初始化，所以父类MyParent也会被初始化，所以最终结果先执行了父类静态代码块，后执行了子类静态代码块

代码演示5：

package JVMDemo01;

class MyParent
{
    public static String str1="Hello,World!";

    static{
        System.out.println("MyParent static block");
    }
}

class MyChild extends MyParent
{
    public static String str2="Welcome";

    static{
        System.out.println("MyChild static block");
    }
}

public class Demo01 {

    static {
        System.out.println("Demo01 static block");
    }

    public static void main(String[] args) {
        MyParent parent;

        System.out.println("----------");

        parent = new MyParent();

        System.out.println("----------");

        System.out.println(MyParent.str1);

        System.out.println("----------");

        System.out.println(MyChild.str2);
    }
}

分析5：

  • 访问main方法，导致Demo01的初始化
  • 定义一个类MyParent的引用不是对类的主动使用，所以不会导致类的初始化
  • 使用new创建MyParent的实例导致MyParent类的初始化
  • 再次访问MyParent的静态变量，由于MyParent已经进行了初始化，即已经不是首次主动使用，便不用再进行初始化
  • 访问子类的静态变量，导致子类MyChild类的初始化，但子类先去检查父类是否被初始化，父类MyParent已经初始化，所以不用再次初始化

疑问：创建类的引用会不会导致类的加载呢？

package JVMDemo01;

class MyParent
{
    public static String str1="Hello,World!";

    static{
        System.out.println("MyParent static block");
    }
}

public class Demo01 {

    public static void main(String[] args) {

        MyParent parent;

    }
}

  • 可以看到未找到任何加载MyParent类的信息，即只定义一个引用，该类都不会被加载

代码演示6：访问父类的静态方法

package JVMDemo01;

class MyParent
{
    public static String str1="Hello,World!";

    static{
        System.out.println("MyParent static block");
    }

    static void doSomething(){
        System.out.println("doSomething");
    }
}

class MyChild extends MyParent {

    static{
        System.out.println("MyChild static block");
    }
}

public class Demo01 {

    public static void main(String[] args) {
        MyChild.doSomething();
        System.out.println("------------");
        System.out.println(MyChild.str1);
    }
}

分析：

  • 反编译可以看到使用了invokestatic调用了静态方法，即使用子类访问父类中定义的静态方法，是对父类的主动使用，所以导致父类被初始化
  • 当再次访问父类的静态变量，由于父类已经初始化，所以不会再次导致父类初始化

代码演示7：使用反射获取类的对象

package JVMDemo01;

class CL{
    static {
        System.out.println("Class CL");
    }
}

public class Demo01 {

    public static void main(String[] args) throws ClassNotFoundException {

        ClassLoader loader = ClassLoader.getSystemClassLoader();
        Class<?> clazz = loader.loadClass("JVMDemo01.CL");
        System.out.println(clazz);

        System.out.println("-----------------------");

        clazz = Class.forName("JVMDemo01.CL");
        System.out.println(clazz);
    }
}

分析7：

  • 调用ClassLoader类的loadClass方法并不是对类的主动使用，所以不会导致类CL的初始化
  • 使用反射获取类的对象是对类的主动使用，所以对类CL进行了初始化

（2）主动使用与final

代码演示1：

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyParent.str);
    }
}

class MyParent
{
    public static final String str="Hello,World!";

    static{
        System.out.println("MyParent static block");
    }
}

运行结果：

分析1：

  • 常量如果在编译期间是确定的话，在编译阶段会存入到调用这个常量的方法所在的类的方法的常量池中，本质上调用类并没有直接引用到定义常量的类，因此并不会触发定义常量的类的初始化，所以MyParent的静态代码块没有被执行
  • 这里即将常量存放到了调用常量str的方法所在的类Demo1的常量池中，之后Demo1与MyParent就没有任何关系了，甚至我们可以将MyParent的class文件删除

--------》--------》

反编译：

助记符：

ldc       表示将int,float或String类型的常量从常量池推送至栈顶
bipush   表示将单字节[-128,127]的常量从常量池推送至栈顶
sipush   表示将单字节[-32768,32767]的常量从常量池推送至栈顶
iconst_1 表示将int类型的1推送至栈顶（iconst_1~iconst_5、iconst_0、iconst_m1(-1)）
  • 从反编译的结果可以看到，并没有任何访问MyParent中静态变量str的语句，仅仅是从常量池中获得数据，所以不会导致类的初始化

按两下shift打开搜索对应的助记符，可以发现，它们的实现也是由相关的类去实现的，并且这些实现都在rt.jar包中

代码演示2：

import java.util.UUID;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyParent03.str);
    }
}

class MyParent03{
    public static final String str = UUID.randomUUID().toString();

    static {
        System.out.println("MyParent03 static code");
    }
}

运行结果：

反编译：

分析2：

  • 当一个常量的值并非编译期间可以确定的（如str）,那么其值就不会在编译期间放到调用类的常量池中，这时在程序运行时，会导致主动使用这个常量所在的类，导致类初始化，从上述反编译的结果我们也可以看到，底层是调用了putstatic对静态变量赋值，所以会导致类的初始化

代码演示3：

package JVMDemo01;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyChild5.a);
        System.out.println(MyChild5.b);
    }
}

interface MyParent05{
    //默认就是public static final
    int a = 5;
}

interface MyChild5 extends MyParent05{
    int b = 6;
}

删除MyChild5.class和MyParent05.class

分析3：

  • 对于接口，属性默认是，所以对于编译期常量会放到常量池中，所以即使删除class文件上述程序也运行正常

代码演示4：

package JVMDemo01;

import java.util.Random;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyChild5.b);
    }
}

interface MyParent05{
    //默认就是public static final
    int a = new Random().nextInt(5);
}

interface MyChild5 extends MyParent05{
    int b = 6;
}

  • 可以发现找不到任何加载接口MyParent05和MyChild5的信息，即这两个接口并没有被加载

删除MyParent05.class

删除MyChild5.class和MyParent05.class

package JVMDemo01;

import java.util.Random;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyChild5.b);
    }
}

class MyParent05{
    public static final int a = new Random().nextInt(5);
}

class MyChild5 extends MyParent05{
    public static final int b = 5;
}

  • 同理，找不到任何加载接口MyParent05和MyChild5的信息，即这两个类并没有被加载

分析4：

由于接口中的变量默认是，所以在编译期就会把常量b的值5放入到调用者Demo01类的常量池中，而在运行时访问的是常量池中的常量的话，本质上调用类（或接口）并没有直接引用到定义常量的类(或接口)，甚至不会加载该类（接口），因此并不会触发定义常量的类（接口）以及它的父类（接口）的初始化

（3）初始化时类与接口的区别

当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口

  • 在初始化一个类时，并不会先初始化它所实现的接口
  • 在初始化一个接口时，并不会先初始化它的父接口

因此，一个父接口并不会因为它的子接口或实现类的初始化而初始化，只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化

补充：代码块{}

package JVMDemo01;

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
    }
}

class A{

    public A(){
        System.out.println("A");
    }

    {
        System.out.println("Hello");
    }

}

  • 可以看到当我们在定义一个类的时候，如果定义一个代码块{}，会在每次创建对象的时候，先执行该代码块中的内容
  • 它与静态代码块的区别时，静态代码块只会在第一次创建对象的时候，执行静态代码块中的内容
package JVMDemo01;

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
    }
}

class A{

    public A(){
        System.out.println("A");
    }

    static {
        System.out.println("Hello");
    }

}

代码示例1：

package JVMDemo01;


public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyChild5.b);
    }
}

interface MyParent5{
    //默认就是public static final
    Thread thread = new Thread(){
        {
            System.out.println("MyParent5 invoked");
        }
    };
}

class MyChild5 implements MyParent5{
    public static int b = 5;
}

分析1：

  • 如果接口MyParent5中的thread被初始化的话，它就必然会创建Thread对象，执行代码块中的打印语句，但从结果可以发现它并没有打印"MyParent5 invoked"，所以证明父类接口MyParent5并没有被初始化，即证实在初始化一个类时，并不会先初始化它所实现的接口
  • 但同时可以看到MyParent5和创建的Thread匿名类MyParent5$1都被进行了加载（注意区分加载和初始化）

为了进一步证实类与接口在初始化时候的区别，我们修改上述接口为类：

package JVMDemo01;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyChild5.b);
    }
}

class MyParent5{

    public static Thread thread = new Thread(){
        {
            System.out.println("MyParent5 invoked");
        }
    };
}

class MyChild5 extends MyParent5{
    public static int b = 5;
}

可以发现代码块中的内容进行了打印，即初始化一个子类的时候，会先初始化它的父类

代码示例2：

package JVMDemo01;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyChild5.thread02);
    }
}

interface MyParent5{

    Thread thread01 = new Thread(){
        {
            System.out.println("MyParent5 invoked");
        }
    };
}

interface MyChild5 extends MyParent5{
    Thread thread02 = new Thread(){
        {
            System.out.println("MyChild5 invoked");
        }
    };
}

分析2：

  • 可以发现父接口MyParent5并没有被初始化，即证实在初始化一个接口时，并不会先初始化它的父接口
  • 但同样接口MyParent5会被加载

1.2 被动使用

除了以上七种情况，其他使用Java的类的方式都被看作是对类的被动使用，都不会导致类的初始化

  • 调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化

2.Java虚拟机与程序的生命周期

如下情况，Java虚拟机本身是一个进程，在如下情况下，Java虚拟机将结束生命周期：

  • 1.执行了System.exit()的方法
  • 2.程序正常执行结束
  • 3.程序在执行过程中遇到了异常或错误而异常终止
  • 4.由于操作系统出现了错误而导致Java虚拟机进程终止

3.数组创建本质分析

public class Demo01 {
    public static void main(String[] args) {
        MyParent05[] myParent05 = new MyParent05[1];
        System.out.println(myParent05.getClass());
        System.out.println(myParent05.getClass().getSuperclass());

        System.out.println("================");
        MyParent05[][] myParent05s1 = new MyParent05[1][1];
        System.out.println(myParent05s1);
        System.out.println(myParent05s1.getClass().getSuperclass());

        System.out.println("================");
        int[] ints = new int[1];
        System.out.println(ints.getClass());
        System.out.println(ints.getClass().getSuperclass());

        boolean[] booleans = new boolean[1];
        System.out.println(booleans.getClass());

        char[] chars = new char[1];
        System.out.println(chars.getClass());

        short[] shorts = new short[1];
        System.out.println(shorts.getClass());


    }
}

class MyParent05{
    static {
        System.out.println("MyParent05 static code");
    }
}

  • 首先可以看到，创建一个数组的实例的时候不会初始化类MyParent05，因为创建数组实例不属于上述主动使用类的7种方式中任何一种
  • 对于数组实例来说，其类型是由JVM在运行期动态生成的，表示为class [LJVMDemo01.MyParent05;
  • 这种形式，动态生成的类型，其父类型就是Object
  • 对于数组来说，JavaDoc经常将构成数组的元素为Component，实际上就是将数组降低一个维度后的类型

反编译：

助记符：

  • anewarray：表示创建一个引用类型的（如类、接口、数组）数组，并将其引用值压入栈顶
  • newarray：表示创建一个指定的原始类型（如int、float、char等）的数组，并将其引用值压入栈顶

4.类加载的准备阶段和初始化阶段的重要意义

代码演示1：

package JVMDemo01;

public class Demo01 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();

        System.out.println("counter1 = "+Singleton.counter1);
        System.out.println("counter2 = "+Singleton.counter2);
    }
}

class Singleton{
    public static int counter1;
    public static int counter2 = 0;

    private static Singleton singleton = new Singleton();

    private Singleton(){
        counter1++;
        counter2++;

        System.out.println("构造方法中counter1 = "+counter1);
        System.out.println("构造方法中counter2 = "+counter2);
    }

    public static Singleton getInstance(){
        return singleton;
    }
}

分析：

在执行时，

先进入准备阶段，按照定义顺序给类中的变量赋予默认值

  • counter1=0
  • counter2=0
  • singleton=null

然后由于主动使用类的静态方法进入初始化阶段，按照定义顺序为静态变量赋值：

  • counter2=0
  • 调用构造方法
    • counter1=1
    • counter2=1
  • 继续向下执行，没有静态变量需要被初始化

所以最终counter1=1，counter2=1

代码演示2：

package JVMDemo01;

public class Demo01 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();

        System.out.println("counter1 = "+Singleton.counter1);
        System.out.println("counter2 = "+Singleton.counter2);
    }
}

class Singleton{
    public static int counter1;

    //变化了下面两句的顺序
    private static Singleton singleton = new Singleton();

    public static int counter2 = 0;

    private Singleton(){
        counter1++;
        counter2++;

        System.out.println("构造方法中counter1 = "+counter1);
        System.out.println("构造方法中counter2 = "+counter2);
    }

    public static Singleton getInstance(){
        return singleton;
    }
}

分析：

在执行时，

先进入准备阶段，按照定义顺序给类中的变量赋予默认值

  • counter1=0
  • singleton=null
  • counter2=0

然后由于主动使用类的静态方法进入初始化阶段，按照定义顺序为静态变量赋值：

  • 调用构造方法
    • counter1=1
    • counter2=1
  • counter2=0
  • 继续向下执行，没有静态变量需要被初始化

所以最终counter1=1，counter2=0

可以看到如果没有准备阶段，先初始化调用构造方法时，counter1就会没有值，这也就是准备阶段先赋予默认值的意义——保证静态变量能被正常使用

硬件知识：内存单根16G和两根8G差别有多大？
IT技术分享社区
08-16 1万+
关于内存单根16G和两根8G的差别，小编觉得这些事实，你得知道！论单根16G和两根8G的区别！内存单通道和双通道，大家都有听过吧！理解起来很简单，一个单通道，只能进行单向传输数据，要么就输...
Windows10怎么分配虚拟内存
HydeRobin的博客
05-20 2531
1.什么是虚拟内存? 虚拟内存别称虚拟存储器（Virtual Memory）。电脑中所运行的程序均需经由内存执行，若执行的程序占用内存很大或很多，则会导致内存消耗殆尽; 为解决该问题，Windows中运用了虚拟内存技术，即匀出一部分硬盘空间来充当内存使用。当内存耗尽时，电脑就会自动调用硬盘来充当内存，以缓解内存的紧张 总结 就是拿出磁盘的一部分空间来从充当空间,当RAM内存不足时会自动调用磁盘里分配的空间来充当RAM内存; 2.分配虚拟内存步骤 右键我的电脑–>高级系统设置 高级–>设置
虚拟内存是什么？它有什么用？又该如何设置呢？
热门推荐
青春木鱼的博客
02-07 6万+
虚拟内存是计算机系统内存管理的一种技术。它使得应用程序认为它拥有连续的可用的内存（一个连续完整的地址空间），而实际上，它通常是被分隔成多个物理内存碎片，还有部分暂时存储在外部磁盘存储器上，在需要时进行数据交换。目前，大多数操作系统都使用了虚拟内存，如Windows家族的“虚拟内存”；Linux的“交换空间”等。
别再让C盘爆红了！Win10/Win11虚拟内存保姆级设置指南（含自动/手动/关闭详解）
weixin_26765287的博客
05-13 608
本文详细解析了Windows 10/11虚拟内存的设置方法，帮助用户有效解决C盘空间不足问题。通过自动管理、手动设置和关闭虚拟内存三种方案的对比，提供针对不同使用场景的优化建议，并介绍将页面文件迁移到其他驱动器的进阶技巧，彻底告别C盘爆红的困扰。
服务器16g内存设置多少虚拟,电脑需要设置虚拟内存么（16g虚拟内存设置多少合适）...
weixin_28487433的博客
08-10 1万+
虚拟内存大家都不会陌生，特别是在WinXP的年代，如果会合理地设置虚拟内存，可以明显提高电脑的运行速度。不过最近，有朋友在微信问到铅锤哥： Win10的虚拟内存怎么设置最好，设置多少最合适，能给电脑提速更快呢？借这个朋友的问题，今天铅锤哥就来给大家说说虚拟内存。一般来说，虚拟内存的多少，是要根据电脑实际物理内存的大小来进行设置的，因此不同的电脑，答案也有所不同。一、什么是虚拟内存？了解虚拟内存的前...
计算机内存不足16g内存,加装16G内存，电脑却运行卡顿、崩溃？原来是这项设置有问题！...
weixin_36378232的博客
07-27 4944
原标题：加装16G内存，电脑却运行卡顿、崩溃？原来是这项设置有问题！也不知道是从什么时候开始，就流传出只要物理内存充足，那么虚拟内存就无需设置，可以直接关闭的说法。而大白菜也有那么一位朋友，在加装了16G内存之后，关闭虚拟内存，想着终于不用担心电脑运行不够快了。事实证明，他太天真了！ 尤其是在玩游戏的时候，不止一次被提醒内存不足，还出现了游戏场景报错，甚至直接卡死蓝屏崩溃……这16G内存像是被吃了...
w7计算机虚拟内存设置,win7虚拟内存怎么设置最好
weixin_36003021的博客
07-29 4533
电脑内存是决定计算机运行速度快慢的重要因素，因为所有运行的程序都要内存的支撑来执行，如果电脑一下子开太多程序，而内存就会不够，内存不够的情况下，电脑就会死机，或者运行很慢很卡，所以这才诞生了虚拟内存，虚拟内存可以解决电脑内存不足的情况，原理就是把硬盘的一部分空间当内存使用，当大家在运行类似CAD，或者玩大型的网络游戏时，需要对虚拟内存进行设置优化，那么电脑虚拟内存怎么设置呢，今天系统圣地的小编以w...
win10设置虚拟内存_电脑配置强，虚拟内存没有用？教你这样设置，瞬间提升流畅度！...
weixin_39611308的博客
10-23 2785
电脑卡了，不外乎硬件、软件两方面的原因。有很多人会选择加个SSD来加速电脑。如果是追求更快的速度，还会进行一些系统设置，比如“虚拟内存”的设置，会设置一个固定值或者直接关闭虚拟内存。也难怪有很多人都说，现在虚拟内存根本没有存在的意义！但是这种说法，还是有失偏颇的。在我们的以往印象中，虚拟内存是使用硬盘空间来缓解内存不足的一个功能。因此很多人以为关闭了虚拟内存，只是让硬盘空间不被占用而已。准确来说，...
台式计算机内存多大算好些,台式电脑内存多大合适_台式电脑硬盘多大合适
weixin_33917217的博客
06-20 1万+
2016-12-11 16:44:06你好！很高兴为你解答，升级到4G比较合适，因为单条2G的内存条性价比较高，4G的有点小贵。另外玩游戏的时候，可以适当调整下游戏参数，对画质、光影效果的各种参数调低一些，这样运行会流...2017-01-03 14:15:11一般而言，4G的内存就够了，如果需要经常多开的话，可以使用8G内存。4G内存就可以安装64位操作系统，64位系统的运算速度高于32系统，4...
8g内存 eclipse怎么设置_电脑需要设置虚拟内存吗？该设置多大才合理？
weixin_39850150的博客
11-23 416
网友提问截图最近，在某答题平台上，有看到网友提出这个问题，为什么电脑上会弹出虚拟内存不足的气泡。我大致看了一下，这个气泡的特点很明显，这是WINDOWS XP系统，在2020年还用着XP系统，不难想象，这台电脑的历史是多么悠久。什么是虚拟内存呢？虚拟内存，在系统中也叫“页面文件”，它其实不是真正的物理内存，它是系统从硬盘上划分出来的一部分临时空间。虚拟内存的作用是什么？当我们的电脑物理内存(内存条...
8g内存一般占用多少_手记|如何设置虚拟内存
weixin_31861847的博客
12-12 2169
首先必须要说明一点，系统盘本身默认是开启虚拟内存的，日常4G/8G用户如果觉得电脑运行比较吃力或者对于电脑性能有一些专业要求的可以如下进行手动操作设置。如果觉得不够用再进行手工设置。 除此之外16G的内存用户，可以把虚拟内存再调小一些，以免占用过多的硬盘空间，尤其小容量SSD用户。 也许很多人都遇到过这种情况，电脑在正常使用操作时，隔三差五的总...
Windows电脑添加打印机
qq_50930131的博客
06-23 244
【代码】Windows电脑添加打印机。
响应式布局：使用BreakpointSystem适配手机、平板与PC（68）
Davina_yu的博客
06-23 171
在鸿蒙（HarmonyOS）“一次开发，多端部署”的理念下，响应式布局是应对手机、平板、折叠屏及 PC 等多设备形态的核心能力。它允许应用根据窗口尺寸、屏幕方向等特征自动调整布局，提供一致且优秀的用户体验。
HarmonyOS 6商城开发学习：平板竖屏下的底部“飞件“事故——用 layoutWeight 替掉 position 与 Stack 的响应式救火
nashane的博客
06-23 1192
文章摘要：本文针对购物比价类应用在平板竖屏下出现的"底部结算栏覆盖商品列表"问题展开分析。问题根源在于手机开发中惯用的Stack层叠布局与position绝对定位在屏幕比例变化时暴露缺陷——position的百分比定位在多尺寸下计算错位，Stack的强制覆盖导致交互冲突。解决方案是摒弃"浮层"思维，采用Column+layoutWeight(1)的自然流式布局，使Scroll占据剩余空间、底部栏自动沉底。这种主从关系明确的结构能适配手机、平板、折叠屏等多种设备形态，避
支持手机和平板的Mobile IDE NimoteCode
一个不知名码农的专栏
06-23 234
NimoteCode是一款专为移动设备优化的轻量级SSH+远程开发工具，现已在Google Play上线。它支持手机和平板，提供文件管理、终端操作、AI编程辅助（集成OpenAI/Claude等）、Git工作流及多任务并行处理等功能，特别针对平板设备优化了分屏多窗口操作。免费版已具备基础开发能力，Pro版则开放无限AI Agent、高级调试和代码分析等进阶功能。开发者表示暂不计划国内上线，但提供免费Promo Code供用户体验Pro功能。iOS版本正在审核中。该工具旨在让开发者无需电脑也能处理真实开发任务
电脑未知usb设备描述符请求失败怎么解决 详细修复教程
weixin_56386428的博客
06-22 323
电脑出现“未知USB设备（描述符请求失败）”怎么办？本文整理6种实用解决方法，包括更换接口、更新驱动、关闭USB节能设置等，帮助用户高效解决设备无法识别故障。
电脑省电技巧新手实操指南
2603_95460522的博客
06-20 311
很多笔记本用户都有过这样的经历：刚买回来时续航能轻松撑过半天，用了一两年后，明明没跑什么大程序，电量却像开了闸的水一样往下掉。有时候急着出门开会，插上电源才发现充不进电，或者会议开到一半电脑直接黑屏关机。这种焦虑不仅影响工作效率，更让人对设备的可靠性产生怀疑。其实，很多时候电池不耐用并非硬件老化不可逆，而是系统设置、后台进程或使用习惯在悄悄“偷电”。解决这些问题不需要高深的技术背景，也不需要拆解机器。
电脑端实用玩机工具
2603_95851887的博客
06-24 392
Uotan柚坛工具箱是一款开源跨平台玩机工具，支持Android/鸿蒙设备及Windows/Linux/macOS系统。提供三大核心功能：1）核心玩机（Recovery刷入、BL锁管理、Magisk刷入等）；2）系统维护（设备投屏、分区备份）；3）个性定制（DPI调节、状态栏隐藏）。特色功能包括一键安装驱动、QCN基带修复、Scrcpy低延迟投屏等，适用于线刷/卡刷多种场景。使用需先开启USB调试模式，部分高阶操作存在风险。该工具适配新系统且支持多平台，比传统工具更现代化。（149字）
一款运行在Android手机上的ADB管理工具！用手机去管理手机、平板、电视或盒子！支持 无线调试、应用管控、文件穿梭、屏幕镜像、Shell 命令等
2603_95851887的博客
06-20 492
SkyADB是一款安卓无线ADB管理工具，支持在同一WiFi下通过无线调试连接手机、平板、电视等设备。使用前需在目标设备开启开发者选项和ADB调试功能。提供三种连接方式：无线配对（推荐）、手动输入IP、局域网自动扫描。连接后支持应用管理（安装/卸载）、文件传输、屏幕镜像、远程控制、Shell命令等操作，尤其适合电视受限安装的场景。历史设备可保存以便快速重连，但目前仅限局域网使用，未来或有望实现远程控制功能。
如何将 iPad 同步至新电脑，且不丢失原有数据？
最新发布
Digitally的博客
06-24 219
以上五种同步方案操作简单、实测有效，大家可根据自身设备系统按需选用。综合来看，第三方工具是最优选择：一方面能保障设备原有数据不丢失，稳定完成电脑与 iPad 之间的文件互传；另一方面除基础同步功能外，还提供更直观便捷的 iPad 文件管理能力。如果你不喜欢 iTunes 繁琐的操作，使用 iReaShare iPhone Manager 处理数据传输、管理 iOS 设备会高效很多，轻松实现 iPad 与新电脑的数据同步。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值