Java常用关键字_java关键字-程序员宅基地

技术标签： JAVA spring java 开发语言

一、前言

本文介绍六个关键字：static、final、extends、implements、this、super，下面具体介绍各个关键字及需要注意的点。

二、Java 51个关键字

记住1：两个保留字：const和goto (保留字：现在没用，以后用得上)

记住2：所有的关键字都是小写，一旦有大写的，一定不是关键字

三、关键字static

static是java中的一个关键字（key words）,其表示的含义在于被static修饰的域、方法、代码块为类所有，而不是为代码所有，使用类名调用（亦可使用对象名调用），static域加载时仅加载一次。

第一点，非static方法、代码块内可以有非static域、方法、代码块，也可以有static域、方法、代码块；但是static方法、代码块内可以只能出现static域、方法、代码块，即static域、方法、代码块仅出现在static环境（static方法、代码块）下，static域只能出现在static方法或代码块中，static方法只能在static方法或代码块中被调用。如图1所示。

图1 外层环境与内部变量之间的关系

第二点，static方法可以用类名调用，也可以用对象名调用，但是非static方法只能由对象名调用调用，因为非static方法只有在对象存在时才有意义，如图2所示。

图2 static方法和非static方法调用方式

类变量
当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。类变量：使用 static 关键字修饰的成员变量。

・定义格式：

static 数据类型变量名；

静态方法

当 static 修饰成员方法时，该方法称为类方法。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。类方法：使用 static 关键字修饰的成员方法，习惯称为静态方法。

・定义格式：

修饰符 static 返回值类型方法名 (参数列表){// 执行语句}

・静态方法调用的注意事项：

1. 静态方法可以直接访问类变量和静态方法。(静态方法只能访问静态成员。)

2. 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。

3. 静态方法中，不能使用 this 关键字。

public class MyClass {

    int num; // 成员变量
    static int numStatic; // 静态变量

    // 成员方法
    public void method() {
        System.out.println("这是一个成员方法。");
        // 成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量
        System.out.println(numStatic);
    }

    // 静态方法
    public static void methodStatic() {
        System.out.println("这是一个静态方法。");
        // 静态方法可以访问静态变量
        System.out.println(numStatic);
        // 静态不能直接访问非静态
//        System.out.println(num); // 错误写法！

        // 静态方法中不能使用this关键字。
//        System.out.println(this); // 错误写法！
    }

}

・调用格式
被 static 修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

格式：// 访问类变量类名.类变量名；// 调用静态方法类名.静态方法名(参数)；

静态原理图解

static 修饰的内容是随着类的加载而加载的，且只加载一次。

存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。

它优先于对象存在，所以，可以被所有对象共享。

静态代码块
静态代码块：定义在成员位置，使用 static 修饰的代码块{ }。位置：类中方法外。执行：随着类的加载而执行且执行一次，优先于 main 方法和构造方法的执行。格式：

public class ClassName{static {// 执行语句}}

作用：给类变量进行初始化赋值。

四、关键字final

4.1 概要

Java语言中final是一个关键字（key words）,其表示的三个含义：final修饰的变量是常量，final修饰的类不可继承，final修饰的方法不可重写。

final关键字三个特性：final修饰的变量为常量、final修饰的类不可继承、final修饰的方法不可重写。

4.2 final修饰的变量为常量

4.2.1 基本类型与引用类型

对于final修饰的变量，应该对基本类型和引用类型分开讨论：

4.2.1.1 基本类型（byte short int long float double boolean char)

基本类型为栈内存（-128~127情况下），一旦被final关键字修饰，其变量属性变为只读，不再进行写操作，否则编译报错。

4.2.1.2 引用类型（类、接口、数组）

引用类型为堆内存，一旦被final关键字修饰，则引用不再改变，但是引用所指向的对象是可以被修改的，Java语言并未提供任何方式使用对象恒定不变。示意代码如下：

public class FinalData {
private final Value value=new Value(22);
public static void main(String[] args) {
	FinalData finalData=new FinalData();
	
	//finalData.value=new Value(33);   //编译报错    value为final类型   
	finalData.value.i++; // 编译通过  value所指向的对象可以修改 
}
}
class Value{
	int i;
	public Value(int i){
		this.i=i;
	}
}

4.2.2 初始化时机

4.2.2.1 final变量定义时初始化

final变量定义时初始化常见，定义时直接赋值即可，不再赘言。

4.2.2.2 final变量构造函数中初始化（空白final）

因为被final修饰的变量一定要在使用前被初始化，所以如果没在定义操作，一定在构造函数中初始化，这种情况称为空白final。示例代码如下：

public class FinalData {
	private final int i;//基本类型示意
private final Value value;//引用类型示意
public FinalData(){ //  无参构造函数    空白final
	i=1;
	value=new Value(1);
}
public FinalData(int x){//有参构造函数  空白final
	i=x;
	value=new Value(x);
}
 
public static void main(String[] args) {
	new FinalData();
	new FinalData(22);
 
}
}
class Value{
	int i;
	public Value(int i){
		this.i=i;
	}
}

4.3 final修饰的类不可继承

类使用final关键字修饰之后，该类不可被继承，可以起到保护该类的作用。实例代码如下：

final class FinalFatherClass{
	
}
class SonClass extends FinalFatherClass{  //编译报错   final类不允许继承
	
}

4.4 final修饰的方法不可重写

class FinalFatherClass{
	final void f(){
		System.out.println("FinalFatherClass f()");
	}
}
class SonClass extends FinalFatherClass{  
	final void f(){//编译报错    
// 子类中某一方法的方法签名（方法名+形参列表）与父类相同，即可认为子类中该方法重写父类方法
//因final方法不可被重写，顾此处编译报错
		System.out.println("SonClass f()");
	}
}

值得注意的是，子类虽不能重写父类final函数，但是可以继承父类final函数，示意代码如下：

public class TestFinal {
public static void main(String[] args){
	FinalFatherClass son=new SonClass();
	son.f();    //打印  FinalFatherClass f()
	//因为子类未重写父类final函数，也不能重新父类final函数    
	//但子类可以继承父类final函数，所以调用父类 f()  打印  FinalFatherClass f() 
 
}
}
class FinalFatherClass{
	final void f(){
		System.out.println("FinalFatherClass f()");
	}
}
class SonClass extends FinalFatherClass{ 
	
}

从上面可以看到，final修饰的方法在特定的访问权限下可以被继承。

这是因为，方法是否被final修饰与方法的访问权限是两回事，没有任何关系，被final修饰的方法和未被final修饰的方法都可以自由的指定访问权限。

我们有兴趣去谈论final关键字和访问权限关键字在修饰方法的过程的起到的作用，如下表（声明：final和访问权限是两个独立的概念，没有任何比较意义，所有本表仅方便读者理解，不可作为正统知识）：

小结 private<final<protect （仅适用于方法）

从表中可以看到，protect修饰的方法在子类中可见，所有可以被子类继承，亦可以被子类重写；

final修饰的方法可以被子类继承，但不可被子类重写（这里final方法的访问权限为默认的default、protected、public均可，只要保证子类可见即可）;

private修饰的方法由于仅本类可见，故不能被子类继承，亦不能被子类重写。

4.5 private与final对比

实际上，Java语言中，所有被private关键字修饰的方法都隐式的被final关键字修饰，（正如上表所示，private实现了final方法不可重写的功能，并附加不可继承功能。）（再次声明：final和访问权限是两个独立的概念，没有任何比较意义，所有上表仅方便读者理解，不可作为正统知识）可以对private方法添加final关键字，但是这种做法没有任何意义。代码示例如下：

public class TestFinal {
public static void main(String[] args){
	FinalFatherClass fatherClass=new FinalFatherClass();
 
SonClass sonClass=new SonClass();
//fatherClass.f();   //f() 为final方法  被private修饰后 仅本类可见  所有不能到TestFinal类中调用
//sonClass.f();
 
//fatherClass.g();   //g() 虽然不是final方法  但被private修饰后 也是仅本类可见  所有不能到TestFinal类中调用
//sonClass.g();
 
//小结：java中，private方法已经隐式的包含final关键字     所以final关键字有无并不重要
}
}
class FinalFatherClass{
	private final void f(){
		System.out.println("FinalFatherClass f()");
	}
	private void g(){
		System.out.println("FinalFatherClass g()");
	}
}
class SonClass extends FinalFatherClass{ 
	private final void f(){
		System.out.println("SonClass f()");
	}
	private void g(){
		System.out.println("SonClass g()");
	}
}

4.6 面试金手指（已经组织好语言，背下来）

本文介绍final关键字，分别介绍了：

final关键字修饰变量，将变量变成常量，一般用来设置全局变量；

final关键字修饰类，将类变为不可以被继承的类；

final关键字修饰方法，将方法变为不可被重写的方法（但是可以被继承，只要是在该方法的访问控制权限允许的情况下）；

最后讨论final关键字和访问控制权限的关系，对比了private和final，从某种意义上来说，final是介于protected和private之间的一种访问权限（虽然不准确，但是至少可以这样理解）。

五、关键字extends和implements

Java中单继承多实现，先继承后实现（即当一个类既要继承又要实现的时候，顺序是先继承后实现 eg: extends A implements B）。

5.1 类继承类（单继承）

class SuperA {
	
}
class SuperB{
	
}
class Sub extends SuperA{//类继承类   只能继承一个类   单继承
	
}

5.2 类实现接口（多实现）

interface InterfaceA {
	
}
interface InterfaceB{
	
}
class Sub implements InterfaceA,InterfaceB{//类实现接口  可以实现多个接口  Java多实现
	
}

5.3 接口继承接口（多继承）

接口继承接口容易被人遗忘，一般我们只记得类继承类和类实现接口，但接口直接也可以相互继承，而且还是多继承。

interface InterfaceA {
	
}
interface InterfaceB{
	
}
interface InterfaceC extends InterfaceA,InterfaceB{//接口继承接口  可以多继承
	
}

六、关键字this与super

6.1 this与super(面试金手指，背下来)

this表示当前类所指对象，super表示父类对象的引用

6.2 代码分析

6.2.1 父类构造函数和子类构造函数

代码示意：

public class Test_thisAndSuper {
 
	public static void main(String[] args) {
		System.out.println("=====无参构造函数=====");
		new BallGame();
		System.out.println("=====带参构造函数=====");
		new BallGame("basketBall");
	}
 
}
 
class Game {
	public Game() {
		System.out.println("Game non-parameter constructor");
	}
 
	public Game(String name) {
		System.out.println("Game parameter constructor: " + name);
	}
 
}
 
class BallGame extends Game {
	public BallGame() {
		super();// 此行代码 可有可无 Java中，子类构造函数可以隐式调用父类无参构造函数
		System.out.println("BallGame non-parameter constructor");
	}
 
	public BallGame(String name) {
		super(name);
		System.out.println("BallGame parameter constructor: " + name);
	}
}

输出结果：

=====无参构造函数=====
Game non-parameter constructor
BallGame non-parameter constructor
=====带参构造函数=====
Game parameter constructor: basketBall
BallGame parameter constructor: basketBall

6.2.1.1 附加：默认调用父类无参构造函数

public class Test1 {

    public static void main(String[] args) {
        System.out.println("=====无参构造函数=====");
        new BallGame();
        System.out.println("=====带参构造函数=====");
        new BallGame("basketBall");
    }

}

class Game {
    public Game() {
        System.out.println("Game non-parameter constructor");
    }

    public Game(String name) {
        System.out.println("Game parameter constructor: " + name);
    }

}

class BallGame extends Game {
    public BallGame() {
        super();// 此行代码 可有可无 Java中，子类构造函数可以隐式调用父类无参构造函数
        System.out.println("BallGame non-parameter constructor");
    }

    public BallGame(String name) {
      //  super(name);
        System.out.println("BallGame parameter constructor: " + name);
    }
}

运行结果：

=====无参构造函数=====
Game non-parameter constructor
BallGame non-parameter constructor
=====带参构造函数=====
Game non-parameter constructor
BallGame parameter constructor: basketBall

6.2.2 父类字段和子类字段

代码示意：

public class Test_thisAndSuper {
 
	public static void main(String[] args) {
		System.out.println("=====无参构造函数=====");
		BallGame _ballGame_noParameter=new BallGame();
		System.out.println("=====带参构造函数=====");
		new BallGame("basketBall");
		System.out.println("=====打印字段=====");
		_ballGame_noParameter.displayField();
	}
 
}
 
class Game {
	protected String _description="This is an interesting game";
	public Game() {
		System.out.println("Game non-parameter constructor");
	}
 
	public Game(String name) {
		System.out.println("Game parameter constructor: " + name);
	}
 
}
 
class BallGame extends Game {
	protected String _description="This is an interesting ballgame";
	public BallGame() {
		super();// 此行代码 可有可无 Java中，子类构造函数可以隐式调用父类无参构造函数
		System.out.println("BallGame non-parameter constructor");
	}
 
	public BallGame(String name) {
		super(name);
		System.out.println("BallGame parameter constructor: " + name);
	}
	
	public void displayField(){
		System.out.println("父类字段： "+super._description);
		System.out.println("子类字段： "+this._description);
	}
}

输出结果：

=====无参构造函数=====
Game non-parameter constructor
BallGame non-parameter constructor
=====带参构造函数=====
Game parameter constructor: basketBall
BallGame parameter constructor: basketBall
=====打印字段=====
父类字段： This is an interesting game
子类字段： This is an interesting ballgame

6.2.3 父类方法和子类方法

代码示意：

public class Test_thisAndSuper {
 
	public static void main(String[] args) {
		System.out.println("=====无参构造函数=====");
		BallGame _ballGame_noParameter=new BallGame();
		System.out.println("=====带参构造函数=====");
		new BallGame("basketBall");
		System.out.println("=====打印字段=====");
		_ballGame_noParameter.displayField();
		System.out.println("=====打印方法调用=====");
		_ballGame_noParameter.displayFunction();
	}
 
}
 
class Game {
	protected String _description="This is an interesting game";
	public Game() {
		System.out.println("Game non-parameter constructor");
	}
 
	public Game(String name) {
		System.out.println("Game parameter constructor: " + name);
	}
	
    protected void  playing() {
	    System.out.println("This game is so interesting");
    }
}
 
class BallGame extends Game {
	protected String _description="This is an interesting ballgame";
	public BallGame() {
		super();// 此行代码 可有可无 Java中，子类构造函数可以隐式调用父类无参构造函数
		System.out.println("BallGame non-parameter constructor");
	}
 
	public BallGame(String name) {
		super(name);
		System.out.println("BallGame parameter constructor: " + name);
	}
	
	public void displayField(){
		System.out.println("父类字段： "+super._description);
		System.out.println("子类字段： "+this._description);//此处this可以省略
	}
	
	protected void  playing() {
		System.out.println("This ballgame is so interesting");
	}
	
	public void displayFunction(){
		System.out.print("父类方法： ");
		super.playing();
		System.out.print("子类方法： ");
		this.playing();//此处this可以省略
	}
}

输出结果：

=====无参构造函数=====
Game non-parameter constructor
BallGame non-parameter constructor
=====带参构造函数=====
Game parameter constructor: basketBall
BallGame parameter constructor: basketBall
=====打印字段=====
父类字段： This is an interesting game
子类字段： This is an interesting ballgame
=====打印方法调用=====
父类方法： This game is so interesting
子类方法： This ballgame is so interesting

6.2.4 this和super同时出现

子类构造函数中可以同时出现super和this关键字，但是super和this不能同时调用构造函数，代码示意：

public class Test_thisAndSuper {
 
	public static void main(String[] args) {
		System.out.println("=====无参构造函数=====");
		BallGame _ballGame_noParameter=new BallGame();
		System.out.println("=====带参构造函数=====");
		new BallGame("basketBall");
		System.out.println("=====打印字段=====");
		_ballGame_noParameter.displayField();
		System.out.println("=====打印方法调用=====");
		_ballGame_noParameter.displayFunction();
		
	}
 
}
 
class Game {
	protected String _description="This is an interesting game";
	public Game() {
		System.out.println("Game non-parameter constructor");
	}
 
	public Game(String name) {
		System.out.println("Game parameter constructor: " + name);
	}
	
 
protected void  playing() {
	System.out.println("This game is so interesting");
}
}
 
class BallGame extends Game {
	protected String _description="This is an interesting ballgame";
	public BallGame() {
		super();// 此行代码 可有可无 Java中，子类构造函数可以隐式调用父类无参构造函数
		System.out.println("BallGame non-parameter constructor");
	}
 
	public BallGame(String name) {
		super(name);
		System.out.println("BallGame parameter constructor: " + name);
	}
	public BallGame(String test1,String test2){
		//super(test1);
		//this(test1);  super()和this()都要放在第一行  自相矛盾  编译时报错
		//小结:super和this可以同时出现，即使是在子类构造方法中也可以同时出现，但是不同同时调用构造方法，
		
		//理论解释：因为在一个构造方法中，只能访问一次其它的构造方法（不管是父类的还是子类的）所以此时不能同时用super和this关键字来调用构造方法，只能根据需求选其一。
		//简单理解：调用构造函数时，两个都要放第一，自相矛盾
	}
	public void displayField(){
		System.out.println("父类字段： "+super._description);
		System.out.println("子类字段： "+this._description);//此处this可以省略
	}
	
	protected void  playing() {
		System.out.println("This ballgame is so interesting");
	}
	
	public void displayFunction(){
		System.out.print("父类方法： ");
		super.playing();
		System.out.print("子类方法： ");
		this.playing();//此处this可以省略
	}
}

输出结果：

因不可同时调用父类构造函数和子类构造函数，无输出结果

小结（面试金手指，this与super同时出现）

1、super和this可以同时出现，即使是在子类构造方法中也可以同时出现，但是不同同时调用构造方法；

2、理论解释：因为在一个构造方法中，只能访问一次其它的构造方法（不管是父类的还是子类的）所以此时不能同时用super和this关键字来调用构造方法，只能根据需求选其一；

3、简单理解：调用构造函数时，两个都要放第一，自相矛盾。

七、面试金手指

7.1 static关键字（定义+第一点main方法+第二点）

定义：static修饰的域、方法、代码块为类所有，而不是为对象所有；

调用：可以使用类名调用（亦可使用对象名调用）；

变量加载顺序：static域加载时仅加载一次（基础面试题第一篇，变量加载顺序）。

第一点，static方法、代码块内可以只能出现static域、方法、代码块，最常见的就是main方法，static方法只能出现static变量。

第二点，非static方法只能由对象名调用调用，因为非static方法只有在对象存在时才有意义。

7.2 final关键字（final变量、final类、final方法、final与private protected）

final关键字三个特性：final修饰的变量为常量、final修饰的类不可继承、final修饰的方法不可重写。

第一，final修饰的变量为常量

对于final修饰的变量，应该对基本类型和引用类型分开讨论：

基本类型为栈内存（-128~127情况下），一旦被final关键字修饰，其变量属性变为只读，不再进行写操作，否则编译报错。

FinalData finalData=new FinalData();	
//finalData.value=new Value(33);   //编译报错    value为final类型   
finalData.value.i++; // 编译通过  value所指向的对象可以修改

final变量的两个初始化时机：final变量定义时初始化、final变量构造函数中初始化（空白final）

第二， final修饰的类不可继承

第三，final修饰的方法不可重写，但是可以被继承，子类可见

ps:方法是否被final修饰与方法的访问权限是两回事，没有任何关系，被final修饰的方法和未被final修饰的方法都可以自由的指定访问权限。

附加：对于final方法 private<final<protect （仅适用于方法）

protect修饰的方法在子类中可见，所有可以被子类继承，亦可以被子类重写；

final修饰的方法可以被子类继承，但不可被子类重写（这里final方法的访问权限为默认的default、protected、public均可，只要保证子类可见即可）;

private修饰的方法由于仅本类可见，故不能被子类继承，亦不能被子类重写；

ps:对于方法，所有被private关键字修饰的方法都隐式的被final关键字修饰，可以对private方法添加final关键字，但是这种做法没有任何意义。

7.3 extends和implements关键字（记住三点）

类继承类（单继承）

类实现接口（多实现）

接口继承接口（多继承）

7.4 this和super关键字（记住五点:概要+构造函数+子类字段+子类方法+this与super同时出现）

this表示当前类所指对象，super表示父类对象的引用

第一，对于构造函数，对于super() 和 super(xxx) 默认调用父类无参构造函数

第二，子类字段和父类字段

public void displayField(){
	System.out.println("父类字段： "+super._description);
	System.out.println("子类字段： "+this._description);
}

第三，子类方法和父类方法

public void displayFunction(){
	System.out.print("父类方法： ");
	super.playing();
	System.out.print("子类方法： ");
	this.playing();//此处this可以省略
}

第四，this与super同时出现

1、super和this可以同时出现，即使是在子类构造方法中也可以同时出现，但是不同同时调用构造方法；

3、简单理解：调用构造函数时，两个都要放第一，自相矛盾。

原文：一文解析Java常用关键字 - 知乎 (zhihu.com)

本文链接：https://blog.csdn.net/qq_27833723/article/details/131414647

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

没有U盘Win10电脑下如何使用本地硬盘安装Ubuntu20.04（单双硬盘都行）_没有u盘怎么装ubuntu-程序员宅基地

文章浏览阅读3.6k次，点赞2次，收藏2次。DELL7080台式机两块硬盘。_没有u盘怎么装ubuntu

【POJ 3401】Asteroids-程序员宅基地

文章浏览阅读32次。题面Bessie wants to navigate her spaceship through a dangerous asteroid field in the shape of an N x N grid (1 <= N <= 500). The grid contains K asteroids (1 <= K <= 10,000), which are conv...

工业机器视觉系统的构成与开发过程（理论篇—1）_工业机器视觉系统的构成与开发过程(理论篇—1-程序员宅基地

文章浏览阅读2.6w次，点赞21次，收藏112次。机器视觉则主要是指工业领域视觉的应用研究，例如自主机器人的视觉，用于检测和测量的视觉系统等。它通过在工业领域将图像感知、图像处理、控制理论与软件、硬件紧密结合，并研究解决图像处理和计算机视觉理论在实际应用过程中的问题，以实现高效的运动控制或各种实时操作。_工业机器视觉系统的构成与开发过程(理论篇—1

plt.legend的用法-程序员宅基地

文章浏览阅读5.9w次，点赞32次，收藏58次。legend 传奇、图例。plt.legend()的作用：在plt.plot() 定义后plt.legend() 会显示该 label 的内容，否则会报error: No handles with labels found to put in legend.plt.plot(result_price, color = 'red', label = 'Training Loss') legend作用位置：下图红圈处。..._plt.legend

深入理解 C# .NET Core 中 async await 异步编程思想_netcore async await-程序员宅基地

文章浏览阅读2.2k次，点赞3次，收藏11次。深入理解 C# .NET Core 中 async await 异步编程思想引言一、什么是异步？1.1 简单实例（WatchTV并行CookCoffee）二、深入理解（异步）2.1 当我需要异步返回值时，怎么处理？2.2 充分利用异步并行的高效性async await的秘密引言很久没来CSDN了，快小半年了一直在闲置，也写不出一些带有思想和深度的文章；之前就写过一篇关于async await 的异步理解，现在回顾，真的不要太浅和太陋，让人不忍直视！好了，废话不再啰嗦，直入主题：一、什么是异步？_netcore async await

IntelliJ IDEA设置类注释和方法注释带作者和日期_idea作者和日期等注释-程序员宅基地

文章浏览阅读6.5w次，点赞166次，收藏309次。当我看到别人的类上面的多行注释是是这样的：这样的：这样的：好装X啊！我也想要！怎么办呢？往下瞅：跟着我左手右手一个慢动作~~~File--->Settings---->Editor---->File and Code Templates --->Includes--->File Header:之后点applay--..._idea作者和日期等注释

随便推点

发行版Linux和麒麟操作系统下netperf 网络性能测试-程序员宅基地

文章浏览阅读175次。Netperf是一种网络性能的测量工具，主要针对基于TCP或UDP的传输。Netperf根据应用的不同，可以进行不同模式的网络性能测试，即批量数据传输（bulk data transfer）模式和请求/应答（request/reponse）模式。工作原理Netperf工具以client/server方式工作。server端是netserver,用来侦听来自client端的连接,c..._netperf 麒麟

万字长文详解 Go 程序是怎样跑起来的？| CSDN 博文精选-程序员宅基地

文章浏览阅读1.1k次，点赞2次，收藏3次。作者| qcrao责编 | 屠敏出品 | 程序员宅基地刚开始写这篇文章的时候，目标非常大，想要探索 Go 程序的一生：编码、编译、汇编、链接、运行、退出。它的每一步具体如何进行，力图弄清 Go 程序的这一生。在这个过程中，我又复习了一遍《程序员的自我修养》。这是一本讲编译、链接的书，非常详细，值得一看！数年前，我第一次看到这本书的书名，就非常喜欢。因为它模仿了周星驰喜剧..._go run 每次都要编译吗

C++之istringstream、ostringstream、stringstream 类详解_c++ istringstream a >> string-程序员宅基地

文章浏览阅读1.4k次，点赞4次，收藏2次。0、C++的输入输出分为三种：(1)基于控制台的I/O (2)基于文件的I/O (3)基于字符串的I/O 1、头文件[cpp] view plaincopyprint?#include 2、作用istringstream类用于执行C++风格的字符串流的输入操作。 ostringstream类用_c++ istringstream a >> string

MySQL 的 binglog、redolog、undolog-程序员宅基地

文章浏览阅读2k次，点赞3次，收藏14次。我们在每个修改的地方都记录一条对应的 redo 日志显然是不现实的，因此实现方式是用时间换空间，我们在数据库崩了之后用日志还原数据时，在执行这条日志之前，数据库应该是一个一致性状态，我们用对应的参数，执行固定的步骤，修改对应的数据。1，MySQL 就是通过 undolog 回滚日志来保证事务原子性的，在异常发生时，对已经执行的操作进行回滚，回滚日志会先于数据持久化到磁盘上（因为它记录的数据比较少，所以持久化的速度快），当用户再次启动数据库的时候，数据库能够通过查询回滚日志来回滚将之前未完成的事务。_binglog

我的第一个Chrome小插件-基于vue开发的flexbox布局CSS拷贝工具_chrome css布局插件-程序员宅基地

文章浏览阅读3k次。概述之前介绍过移动Web开发基础-flex弹性布局（兼容写法）里面有提到过想做一个Chrome插件，来生成flexbox布局的css代码直接拷贝出来用。最近把这个想法实现了，给大家分享下。play-flexbox插件介绍play-flexbox一秒搞定flexbox布局，可直接预览效果，拷贝CSS代码快速用于页面重构。你也可以通过点击以下链接（codepen示例）查_chrome css布局插件

win10下安装TensorFlow-gpu的流程(包括cuda、cuDnn下载以及安装问题)-程序员宅基地

文章浏览阅读308次。我自己的配置是GeForce GTX 1660 +CUDA10.0+CUDNN7.6.0 + TensorFlow-GPU 1.14.0Win10系统安装tensorflow-gpu（按照步骤一次成功）https://blog.csdn.net/zqxdsy/article/details/103152190环境配置——win10下TensorFlow-GPU安装（GTX1660 SUPER+CUDA10+CUDNN7.4）https://blog.csdn.net/jiDxiaohuo/arti