04※、静态入参匹配 、动态入参匹配 、动态入参匹配plus 、※static静态的和非静态的区别以及 初始化、初始化块（静态与非静态）以及在继承链中的顺序

已于 2022-08-24 08:55:12 修改
阅读量147 收藏 1
点赞数
分类专栏： 03、面向对象的概念以及特征 文章标签： java jvm c# servlet 大数据
于 2022-07-31 23:56:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lantzrung/article/details/126092554
版权
本文详细探讨了Java中的静态与非静态方法的区别，动态入参匹配原理以及静态初始化块和非静态初始化块的执行顺序。通过实例展示了类加载时静态属性的初始化，以及对象创建时非静态属性的初始化过程，强调了静态方法与非静态方法在多态场景下的行为差异。
摘要由CSDN通过智能技术生成

​

静态、动态、动态入参匹配、static静态和非静态、初始化块

※静态入参匹配

–根据入参变量的编译时类型决定调用哪个方法

（谁入参到这个方法就根据谁的编译时类型来决定）


/**
 * @author Lantzrung
 * @date 2022年7月22日
 * @Description
 */
public class Test01 {
	
	//定义方法
	public void test(A a) {
		System.out.println("test-------------A");
	}
	public void test(B b) {
		System.out.println("test-------------B");
	}
	public void test(C c) {
		System.out.println("test-------------C");
	}

public static void main(String[] args) {
	//创建实例对象
	Test03 test03 = new Test03();
	//操作一:
	A a = new A();
	B b = new B();
	//
	test03.test(a);//test-------------A
	test03.test(b);//test-------------B
	
	//操作二:
	A a1 = new B();
	B b1 = new C();
	A a_b = b1;
	//(没有多态时):在确认同一个类时，根据方法签名【入参的变量的编译时类型】决定
	//根据方法签名
	test03.test(a1);//test-------------A
	test03.test(b1);//test-------------B
	test03.test(a_b);//test-------------A
}
}
// A --> B --> C
class A{
}
class B extends A{
}
class C extends B{
}

※动态入参匹配

–根据调用方法的引用变量的运行时类型决定调用哪个类

（谁调用了这个方法就根据谁的运行时类型来决定）

1、确定调用哪个类【调用方法的变量的运行时类型确定】

2、确定调用哪个方法【入参的变量的编译时类型确定】

/**
 * @author Lantzrung
 * @date 2022年7月22日
 * @Description
 */
package com.g0714work;

public class Test02 {
	public static void main(String[] args) {

//		//操作一:
//		A a = new A();
//		B b = new B();
//		C c = new C();
//		
//		//输出结果:
//		a.test(c);//A----c
//		b.test(a);//B----a

		// 操作二:
		// 1、确定调用哪个类【调用方法的变量的运行时类型确定】
		// 2、确定调用哪个方法【入参的变量的编译时类型确定】
		A a = new A();
		B b = new B();
		A a_c = new C();
		A a_b = b;

		// 输出结果:
		a_c.test(b);// C-------------b
		// 简单来说就是先确认运行时类型的就是new C();C类型，
		// 然后再确认编译时类型为B b,为b
		a_b.test(a);// B-------------a
		// 先确认运行时类型的就是new B();B类型，
		// 然后再确认编译时类型为A a,为a
		// 操作三:
		C cc = (C) a_c;
		cc.test(a_b);// C------------a
		// 先确认运行时类型的就是new C();C类型，
		// 然后再确认编译时类型为A a_b,为a

	}
}

// A --> B --> C
class A {
	// 定义方法
	public void test(A a) {
		System.out.println("A-------------a");
	}

	public void test(B b) {
		System.out.println("A-------------b");
	}

	public void test(C c) {
		System.out.println("A-------------c");
	}
}

class B extends A {
	// 定义方法
	public void test(A a) {
		System.out.println("B-------------a");
	}

	public void test(B b) {
		System.out.println("B-------------b");
	}

	public void test(C c) {
		System.out.println("B-------------c");
	}
}

class C extends B {
	// 定义方法
	public void test(A a) {
		System.out.println("C-------------a");
	}

	public void test(B b) {
		System.out.println("C-------------b");
	}

	public void test(C c) {
		System.out.println("C-------------c");
	}
}

※动态入参匹配plus

// 方法调用在编译的时候已经确定了，如果运行时类型有重写方法则显示子类特征

–// 1、先编译【test(A a)】，后运行【test(A a)】（看得见和看不见的问题）

–// 2、确定调用在哪个类中的方法【根据引用变量的运行时类型】

–// 3、确定调用在哪个方法【根据引用变量的编译时类型】

/**
 * @author Lantzrung
 * @date 2022年7月22日
 * @Description
 */

public class Test03 {
	public static void main(String[] args) {

		// 操作一:
		A a = new B();
		B b = new B();

		// 方法调用在编译的时候已经确认了，如果运行时类型有重写方法则显示子类特征
		// 编译的时候已经确定了类型了，运行的时候是确认有没有进行方法重写

		// 1、先编译【test(A a)】，后运行【test(A a)】
		// 2、确定调用哪个类【调用方法的变量的运行时类型确定】
		// 3、确定调用哪个方法【入参的变量的编译时类型确定】
//      注意:这里是还没有在classA中加入方法的 以下方法是操作二才加入的
//      public void test(B b) {
//		System.out.println("A-------------b");
//	    }
		a.test(b);// B------------a

//		//操作二:
//		A a = new B();
//		B b = new B();
//		a.test(b);// B------------b

	}
}

// A --> B --> C
class A {
	// 定义方法
	public void test(A a) {
		System.out.println("A-------------a");
	}

	public void test(B b) {
		System.out.println("A-------------b");
	}
}

class B extends A {
	// 定义方法
	public void test(A a) {
		System.out.println("B-------------a");
	}
	public void test(B b) {
		System.out.println("B-------------b");
	}
}


​

​

※static静态的和非静态的区别

表示的静态的意思，属于类的，当使用到这个类的时候会静态加载静态的属性以及方法。

–static用于修饰变量和方法、代码块

–有static修饰的则为静态的，没有的则为非静态

–静态的是属于类的 静态的东西是每个对象都共享的【同一个内存区域】

–而非静态是属于对象的，每个对象都有一个独立的内存空间【互不干涉】

–静态方法可以通过类名直接访问

–非静态的属性和方法要通过对象访问访问

–非静态代码块可以直接访问当前类中的非静态方法和属性

–静态的代码块中，不能直接访问非静态的方法和属性，除非通过对象调用

思考：什么时候使用静态，什么时候使用非静态

工具方法、常量使用静态修饰，同一个类中共享的可以静态
定义类时的成员方法以及属性一般就是非静态修饰

/**
 * @author Lantzrung
 * @date 2022年7月22日
 * @Description
 */
public class Person {
	private String name;
	private String sex;
	private int age;

	public static void main(String[] args) {
		// 创建两个新的对象
		Person p1 = new Person("zhang", "nan", 26);
		Person p2 = new Person("li", "nan", 18);
		// 输出p1和p2的值
		System.out.println(p1);// Person [name=zhang, sex=nan, age=26]
		System.out.println(p2);// Person [name=li, sex=nan, age=18]
		
        // 给静态变量赋值
        // 操作二:
	    // 静态的属性和方法在类加载的时候已经在方法区中分配了内存
		p1.item = 15;
		System.out.println(p1.item);// 15
		System.out.println(p2.item);// 15

		// 操作四:
		// static的方法、变量可以直接使用类名来调用
		System.out.println(Person.item);

		// 调用静态的方法
		p1.test();

	}

	// static使用的注意事项:

	// static用于修饰变量、方法、类
	// static静态的是属于类的，非静态是属于对象的【静态与非静态的区别】
	// static的方法、变量可以直接使用类名来调用
	// static修饰的变量--当前的类变量
	// 静态的代码块不能直接调用非静态的属性及方法，除非通过对象调用【内存的分配】
	// 静态的属性和方法在类加载的时候已经在方法区中分配了内存

	// 操作一:
	// 定义一个静态变量
	public static int item = 10;

	// 操作三:
	// 定义一个静态的测试方法
	public static void test() {
		// Cannot make a static reference to the non-static field name
		// 意思就是:静态的方法中不能调用非静态的引用
		// 静态的代码块不能直接调用非静态的属性及方法，除非通过对象调用【内存的分配】
//		System.out.println(name);
//		System.out.println(getName());
		// 解决办法:
		// 需要创建一个新的对象来进行调用
		Person p = new Person();
		System.out.println(p.name);
		System.out.println(p.getName());
	}

	// 非静态的方法
	// 可以直接调用
	public void test1() {
		System.out.println(name);
		System.out.println(getName());
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Person() {
		super();
	}

	public Person(String name, String sex, int age) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}

}

– 操作二:

https://img-blog.csdnimg.cn/29f902d9723b42cdab38e3c8b81505d9.png

https://img-blog.csdnimg.cn/b8cc8c7439464eb694669686ae3fb711.png

​​

初始化以及初始化块（静态与非静态）以及在继承链中的顺序

【了解即可】

  • -初始化块的作用是用于在类加载或者创建对象时，可以设置一些固定的初始化操作（初始化成员变量、执行其他类的加载）

  • -静态初始化块只执行一次（类加载时），非静态初始化块每创建一个对象就执行一次

  • -静态初始化块–>非静态初始化块–>构造器

// 总结:
// 构造器(全参、有参、无参)–>非静态代码块(代码块)–>静态代码块
// 静态初始化块，只会执行一次【类加载–加载其他库】
// 每创建一个对象，非静态初始化块都会执行一次

// 定义一个非静态初始化代码块，对象数据进行初始化值

/**
 * @author Lantzrung
 * @date 2022年7月22日
 * @Description
 */

public class Test {

	public static void main(String[] args) {

		// 操作一:
		// 添加了无参构造器、全参构造器和toString方法
		// Person p = new Person();
		// System.out.println(p);//Person [name=null, sex=null, age=0]

		// 操作二:
		// 加上了一个初始化块 添加了无参构造器、全参构造器和toString方法
//		 Person p = new Person();
//		 System.out.println(p);//Person [name=无名氏, sex=男, age=10]

//		// 操作三:
		// 加上了一个初始化块 并给对象赋值 添加了无参构造器、全参构造器和toString方法
		// 这里就算不要初始化块还是会给输出对象数据
//		Person p = new Person("zhang", "nan", 19);
//		System.out.println(p);
		// Person [name=zhang, sex=nan, age=19]

		// 操作四:
		// 加上了一个初始化块 并添加一个输出语句"初始化块执行" 并给对象赋值 添加了无参构造器、全参构造器和toString方法
//		Person p = new Person("zhang", "nan", 19);
//		System.out.println(p);
		// 初始化块执行
		// Person [name=zhang, sex=nan, age=19]

		// 操作五:
		// 加上了一个初始化块 并添加一个输出语句"初始化块执行" 并给对象赋值 添加了无参构造器、全参构造器和toString方法
		// 并且分别给构造器添加上"全参构造器初始化块执行"和"无参构造器初始化块执行"
		// 就算注释了全参构造器和初始化，无参构造器还是不会输出语句，因为没有对它进行调用
		// 要是要实现无参构造器的调用还是需要不对对象进行赋值
		// Person p = new Person("zhang", "nan", 19);
		// System.out.println(p);
		// 初始化块执行
		// 全参构造器初始化块执行
		// Person [name=null, sex=null, age=0]

		// 操作六:
		// 加上了一个初始化块 并添加一个输出语句"初始化块执行"
		// 添加了无参构造器、全参构造器和toString方法
		// 并且分别给构造器添加上"全参构造器初始化块执行"和"无参构造器初始化块执行"
		// 没有给对象进行赋值
		// Person p = new Person();
		// System.out.println(p);
		// 初始化块执行
		// 无参构造器初始化块执行
		// Person [name=无名氏, sex=男, age=10]

		// 操作七:
		// 加上了一个静态初始化块并加上输出语句"静态初始化块执行"
		// 加上了一个非静态初始化块并添加一个输出语句"非静态初始化块执行"
		// 添加了无参构造器、全参构造器和toString方法
		// 并且分别给构造器添加上"全参构造器初始化块执行"和"无参构造器初始化块执行"
//		 Person p = new Person("zhang", "nan", 19);
//		 System.out.println(p);
		// 静态初始化块执行
		// 非静态代码块初始化块执行
		// 全参构造器初始化块执行

		// 总结:
		// 构造器(全参、有参、无参)-->非静态代码块(代码块)-->静态代码块
		// 静态初始化块，只会执行一次【类加载--加载其他库】
		// 每创建一个对象，非静态初始化块都会执行一次
		// 定义一个非静态初始化代码块，对象数据进行初始化值
	}
}

/**
 * @author Lantzrung
 * @date 2022年7月21日
 * @Description
 */


public class Person {
	public String name ;
	public String sex;
	public int age;

	//定义一个静态变量
	public static int item;
	
	//静态初始化块，只会执行一次【类加载】
	static {
		//赋值给变量
		item = 15;
		System.out.println("静态初始化块执行");
	}
	
	// 每创建一个对象，非静态初始化块都会执行一次
	// 定义一个非静态初始化代码块，对象数据进行初始化值
	{
		name = "无名氏";
		sex = "男";
		age = 10;
		System.out.println("初始化块执行");
	}
	
	//操作二:定义初始化块，对对象数据进行初始化约定
	public Person(String name, String sex, int age) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
		System.out.println("全参构造器初始化块执行");
	}
	

	public Person() {
		super();
		System.out.println("无参构造器初始化块执行");
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}
}

增加一个细节:

/**
 * @author Lantzrung
 * @date 2022年7月21日
 * @Description
 */

public class Person {

	//定义一个静态变量
	//静态初始化块，只会执行一次【类加载】
	public static int item = 20;//静态变量 
	public final static int item2 = 10;//静态常量 注意:颜色比常量变得更深一点
	static {
		//赋值给变量
		item = 15;
		System.out.println("静态初始化块执行");
	}
}

/**
 * @author Lantzrung
 * @date 2022年7月22日
 * @Description
 */
public class Test01 {
	public static void main(String[] args) {

		// 操作一:
		// 静态变量在静态代码块前的时候，输出的是静态代码块中的变量数据
		// Person p = new Person();
		// System.out.println(p.item);//15
		
		// 操作二:
		// 静态变量在静态代码块后的时候，输出的是静态变量的数据
		Person p = new Person();
		System.out.println(p.item);// 20
    }
}

初始化块在继承链的顺序

思考：如果初始化块在继承链中，又是怎么样？
总结:父类静态初始化块(父类的静态变量)–>子类静态初始化块(子类的静态变量)–>父类非静态初始化块–>父类构造器–>子类非静态初始化块–>子类构造器

/**
 * @author Lantzrung
 * @date 2022年7月22日
 * @Description
 */
package com.g0714work.copy;

public class Test02 {

	public static void main(String[] args) {
        Student p = new Student("zhang", "nan", 18);
		System.out.println(p);
		// Person静态初始化块执行
		// Student静态初始化块执行
		// Person非静态初始化块执行
		// Person全参构造器初始化块执行
		// Student非静态初始化块执行
		// Student全参构造器初始化块执行
		// 总结:子类构造器-->子类非静态初始化块-->父类构造器-->父类非静态初始化块-->子类静态初始化-->父类静态初始化块
    }
}

/**
 * @author Lantzrung
 * @date 2022年7月21日
 * @Description
 */

public class Person {

	public String name;
	public String sex;
	public int age;
	
	static {
		System.out.println("Person静态初始化块执行");
	}
	
	{
		System.out.println("Person非静态初始化块执行");
	}

	public Person(String name, String sex, int age) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
		System.out.println("Person全参构造器初始化块执行 ");
	}

	public Person() {
		super();
		System.out.println("Person无参构造器初始化块执行 ");
	}
}

/**
 * @author Lantzrung
 * @date 2022年7月21日
 * @Description
 */
public class Student extends Person {

	static {
		System.out.println("Student静态初始化块执行");
	}
	
	{
		System.out.println("Student非静态初始化块执行");
	}

	public Student() {
		super();
		System.out.println("Student无参构造器初始化块执行 ");
	}

	public Student(String name, String sex, int age) {
		super(name, sex, age);
		System.out.println("Student全参构造器初始化块执行 ");
	}
	
}

​
Lantzruk
关注
专栏目录
TestNG-参数传递几种方式 03
xueningyang555的博客
03-28 2122
参数化测试 将参数直接传递给测试方法的两种方式： 使用 testng.xml 或 数据提供者。 1、通过 xml文件（ @Parameters）将参数传递给 @Test。 1) 创建一个测试类，有@Test 测试方法； 2）创建testng.xml 文件； 3）将testng.xml中参数用@Parameters引用到测试方法。 附上代码： ##...
java的static_Java static关键字详解
weixin_39921087的博客
02-21 106
static关键字在类中，用static声明的成员变量为静态成员变量，也成为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。这里要强调一下：static修饰的成员变量和方法，从属于类普通变量和方法从属于对象静态方法不能调用非静态成员，编译会报错static关键字的用途一句话描述就是：方便在没有创建对象的情况下进行调用(方法/变量)。显然，被static关键字修饰的方法或者变量不需要...
静态参数传递的几种方式
隐竹的专栏
11-22 4069
<br />src=http://www.0djx.com/article/20081217/2023.html<br /> <br />静态传值是区别于与服务端通信进行值传递的方式，例如LoadVars，XML，Remoting之类，后者暂且不在本文的讨论范围内，当你想让FLASH获取URL中的参数时，你为何不换个角度想了？其实我们可以让服务端动态生成SWF的的插入代码，主动将我们需要的参数“静态”传递给FLASH，FLASH直接用就可以了，根本不需要自己去拿，而以何种形式传递给FLASH，就是我所指的静
来来来 静态方法的参数
lusic01的专栏
10-27 2402
public class Test1 { private  int a = 2; public int getA() { return a; } public static void main(String[] args) { Test1 t = new Test1(); System.out.println(t.a); System.out.println(t.
※静态入参匹配、动态入参匹配和动态入参匹配plus
Lantzruk的博客
07-22 386
-根据调用方法的引用变量的运行时类型决定调用哪个类。1、确定调用哪个类【调用方法的变量的运行时类型确定】2、确定调用哪个方法【入参的变量的编译时类型确定】--根据入参变量的编译时类型决定调用哪个方法。（谁入参到这个方法就根据谁的编译时类型来决定）（谁调用了这个方法就根据谁的运行时类型来决定）...............
iOS 动态库和静态库
Zs0488的博客
01-16 584
iOS静态库和动态库
Java中static静态变量的初始化完全解析
09-02
Java中的静态变量（static变量）是在类加载时初始化的，而不是在对象创建时。静态变量属于类，而不属于任何特定的对象，因此它们是共享的，所有类实例都可以访问。了解静态变量的初始化顺序对于理解和避免潜在的编程...
Static-Comments-Plus:鹈鹕静态注释的增强版本
04-16
静态评论加 Pelican 插件的更完整版本。 :warning: 需要具有PHP功能的托管服务器！ 该插件可让您向文章添加静态评论。 默认情况下，该插件在名为Pelican_root_dir/comments/{slug}.md or .rst的本地文件中查找每...
Python3.0中普通方法、类方法和静态方法的比较
09-19
在Python3.0中，面向对象编程涉及到三种特殊的方法类型：普通方法、类方法和静态方法。这三种方法在不同的场景下有不同的用途和特点。 **一、语法区别** 1. **普通方法（实例方法）**：普通方法是通过`self`参数...
C/C++的动态库和静态库
o_bvious的博客
02-20 1146
C/C++的动态库和静态库 CC的动态库和静态库 静态库 静态库特点 生成静态库 静态库的两大缺点 动态库 动态库特点 生成动态库 使用动态库 在Linux下显式调用动态库 注意显式调用C动态库 静态库动态库的使用 注意事项 动态库和静态库的不同 静态库动态库链接搜索路径 头文件相关 其他 静态库 在链接阶段，将汇编生成的目标文件.o与引用到的库一起链接打包...
java静态类初始化_Java中static静态变量的初始化完全解析
weixin_32392583的博客
02-12 1126
静态变量初始化顺序1.简单规则首先先看一段最普遍的JAVA代码：public class Test{public static Test1 t = new Test1();public static int a = 0;public static int b;public static void main(String[] arg){System.out.println(Test.a);Syste...
入参参数尽量使用包装类型，静态变量使用@Value获取需要Set方法
james23Chosen1的博客
05-16 2345
碰到一个问题，百度校验一个参数 是用int类型。 /** * 交期天数 */ @NotNull private int deliveryDay; 用@NotNull注解来拦截未传的值，然后不穿这个交期天数，竟然通过了校验。打了断点进去看发现自己自动赋值为0。但是数据库的默认值是3，所以这算一个bug。因为这是一个pojo类，所以这个是属于全局变量，而全局变...
Java的static方法实战
实践求真知
06-02 1677
一点睛 用static可以声明一个静态属性变量，其实，也可以用来声明方法，用它声明方法时也称为“类方法”。使用static定义的方法可以由类名直接调用。 static的main方法可以接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。格式如下： java类名称参数1参数2参数3 二实战——静态方法的声明 1代码 class Per...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 902
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 333
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 508
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 694
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1007
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
log4cplus编译静态库
09-09
要编译log4cplus静态库，您可以按照以下步骤进行操作： 1. 首先，确保您已经安装了log4cplus的开发包。 2. 创建一个新的文件夹，用于构建静态库。 3. 在该文件夹中，创建一个名为`CMakeLists.txt`的文件，并将以下内容添加到文件中： ``` cmake_minimum_required(VERSION 3.0) project(log4cplus_static) # 设置log4cplus源文件目录 set(LOG4CPLUS_SOURCE_DIR /path/to/log4cplus/source) # 添加log4cplus源文件 file(GLOB_RECURSE LOG4CPLUS_SOURCES "${LOG4CPLUS_SOURCE_DIR}/*.cpp") # 设置编译选项 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") # 生成静态库 add_library(log4cplus_static STATIC ${LOG4CPLUS_SOURCES}) ``` 请将`/path/to/log4cplus/source`替换为您实际的log4cplus源代码路径。 4. 打开终端，进入到该文件夹，并执行以下命令来生成静态库： ``` mkdir build cd build cmake .. make ``` 执行完上述命令后，将在`build`文件夹中生成名为`liblog4cplus_static.a`的静态库文件。 现在，您可以使用该静态库在您的项目中进行编译和链接。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lantzruk

你的鼓励是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值