Java: static，final，代码块 的详解

news2024/11/19 15:33:04

Java: static，final，代码块 的详解

在这里插入图片描述

每博一文案

山本文绪说过这样一句话：哪些决定放弃了的事，就请放弃得干干净净。哪些决定再也不见面的人，就真
的不要再见面了，不要再做背叛自己的事，如果想要爱别人，就先好好爱自己。	
人生是一场有去无回的旅行，旧日种种，结成过往，我们只能回过头看，却不能从头走，好的也罢，坏的也罢，
过去的都已成定局了。不管是遗憾还是庆幸，都要带着这份烙印，继续走向漫漫人生。
正如那句极有名的禅语：无论你遇见谁，他都是对的人，无论发生什么事，那都是唯一会发生的事。
不管事情开始于那个时刻都是对的，时刻已经结束的，就是结束了。如果没有失去，就不会懂得珍惜。
但是你知道吗？如果已经失去了，就该学会放弃，没有什么是注定会属于我们的，得到或者失去，都是自有它的安排。
面对哪些注定要说再见到人或物，与其拼命拉扯，泪影婆娑，倒不如落落大方道一句“珍重”。
从从容容德告个别，然后留下一个潇洒离开的背影，从今以后更加坚定自己的路，将自己的人生过得有声有色。
愿你可饮最烈的酒，也能放开该放的手，从前不回头，往后强求。
                                                    ——————   一禅心灵庙语

文章目录

  • Java: static，final，代码块 的详解
    • 每博一文案
    • 1. static 关键字
      • 1.1 static 修饰属性
      • 1.2 static 修饰方法
      • 1.3 static 修饰代码块
      • 1.4 static 修饰内部类
      • 1.5 开发中如何合理的使用 staitc 关键字
    • 2. main 方法的探究
    • 3. 代码块
      • 3.1 程序中成员变量赋值的执行顺序
    • 4. final 关键字
    • 5. 总结:
    • 6. 最后:

1. static 关键字

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上 的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象， 其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少 对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。这里我们就可以用到 static 关键字的使用了。

static : 表示的含义是 ：静态的 。

在Java类当中, static 可以修饰属性，方法，代码块，内部类 。

1.1 static 修饰属性

static 修饰属性(变量)： 按是否使用 static 修饰，可以分为为 静态属性(类属性) VS 非静态属性(实例属性) 。

非静态属性(实例属性)： 我们创建了类的多个对象，每个对象都独立的拥有一套 类中的 非静态属性，非静态变量对应不同的实例对象(new) 自身的修改，不会影响到其他的 对象当中的一套非静态属性。

静态属性(类属性)： 我们创建了类的多个对象，但是多个对象共享同一个静态属性，当通过某一个对象修改静态属性时，会导致其他对象调用此静态变量时，是最后一次修改过的结果。

被 static 修饰的属性的特点：

  • 静态属性随着类的加载而加载，早于 new 对象的加载创建，因为 new 对象，要先加载类，再调用类中的构造方法创建对应的对象。
  • 在访问权限允许的情况下，静态属性可以通过**“类名.静态属性名”** 的方式进行调用。
  • 由于类只会加载一次，则静态属性(静态变量) 在内存(方法区)当中也只会存在一份，存在方法区的静态域当中。
  • 静态属性有：System.out; Math.PI;
package blogs.blog2;

public class StaticTest {
    public static void main(String[] args) {
        Chinese c1 = new Chinese();
        c1.nation = "CHN";

        Chinese c2 = new Chinese();
        c2.nation = "CHINA";

        System.out.println("c2.nation: "+c1.nation);
        System.out.println("c2.nation: "+c2.nation);

        // 可以通过 类名.静态属性 ()
        Chinese.nation = "中国";
        System.out.println("Chinese.nation: "+Chinese.nation);
    }
}


class Chinese{
    String name;
    int age;
    static String nation;     // 被 static 修饰的静态属性



}

在这里插入图片描述

在这里插入图片描述

1.2 static 修饰方法

被 staitc 修饰的方法，被称为是 ”静态方法“ 或者是 类方法。

静态方法的特点:

  • 同样静态方法也是和随着类的加载而加载到内存(方法区)当中的。
  • 在访问权限允许的情况下，静态属性可以通过**“类名.静态方法名”** 的方式进行调用。
  • 静态方法只能调用 静态的方法/属性 ，无法调用非静态的方法/属性，除非 实例化对象(new)。因为一个(静态方法)是已经在内存当中存在了的，调用一个(非静态的)还没有加载到内存当中的，JVM 是不允许的。
  • 在静态的方法内：不能使用 'this’关键字 以及 super 关键字，他俩都是表示对象的引用.
  • 非静态方法可以调用非静态方法或属性，也可以调用静态方法或属性。
  • 被 static 修饰的方法无法重写

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package blogs.blog2;

public class StaticTest {
    public static void main(String[] args) {
        // 静态方法可以直接使用  “类名.静态方法”调用
        Chinese.show();
    }
}


class Chinese{
    String name;
    int age;
    static String nation;     // 被 static 修饰的静态属性


    public static void show(){
        System.out.println("我是静态方法");
        // name = "TOM";  // 静态方法无法直接调用非静态的属性
        // eat();   // 静态方法无法直接调用非静态的方法，可以通过 new 实例对象，调用

        /*this.name = "Tom";
        super.clone();*/  // 静态方法中无法使用 this./super.

        // 静态方法可以直接调用静态属性，静态方法
        nation = "Hello";   // 静态属性
        sleep();            // 静态方法
    }


    public void eat(){
        System.out.println("吃饭");

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

        // 非静态方法可以直接调用 静态方法/属性，因为加载内存的先后原因
        nation = "World";     // 静态属性
        sleep();              // 静态方法
    }


    public static void sleep() {
        System.out.println("睡觉");
    }
}

在这里插入图片描述

被 stiatic 修饰的方法，继承时，无法被重写，就算你按照重写的要求，编写好了没有报错，但是运行的时候，调用的是父类中没有被重写的方法 因为 stiatic 是类方法，和类一起加载到内存当中的，而多态中的重写是，运行时类型，只有运行了。才

package blogs.blog2;

public class StaticTest {
    public static void main(String[] args) {
        Earth earth = new Chinese();  // 多态
        earth.human();
    }
    
}


class Chinese extends Earth{
    public static void human() {
        System.out.println("中国人");
    }
}


class Earth{
    public static void human(){
        System.out.println("人类");
    }

}

在这里插入图片描述

1.3 static 修饰代码块

被 static 修饰的代码块，被称为 “静态代码块”。

具体详细，继续往下看，在 3.代码块 这一段有详细说明

1.4 static 修饰内部类

关于这一部分内容，大家可以移步至：🔜🔜🔜

1.5 开发中如何合理的使用 staitc 关键字

开发中：如何确定一个属性是否声明未 static ？？？

如果一个属性可以被多个对象共享的，不会随着对象不同而不同的，就可以声明为 staitc

一般 static 是和 final 一起修饰 变量的。

开发中：如何确定一个方法是否要声明为 static 的 ？？？

一般是 stiatic 的属性，通常对应的 set/get 方法也是 stiatic 的

工具类中的方法，习惯上声明为 static 的，比如：Math,Arras,Collections

2. main 方法的探究

在这里插入图片描述

  • public 权限修饰符为什么是 public ？？？

由于Java虚拟机需要调用类的 main() 方法，所以该方法的访问权限 必须 是 public 才行。

  • 为什么 main 方法的修饰符要是 static 静态的 ？？？

因为Java虚拟机在执行 main() 方法时，不必创建对象，所以该方法必须是 static ,可以直接调用。

又因为 main 方法是 static 静态的，静态方法无法直接调用非静态的方法/属性，

必须创建对应类的实例对象(new)后，才能通过这个对象去访问该对应类中的非静态方法/属性。

  • main 方法中的形参列表是 string[] args 字符串数组

该形参接收一个 String 类型的数组参数，该字符串数组中保存执行 java 命令时，所传递给所运行类的参数。

在这里插入图片描述

main 也是一个方法，特殊之处就是，它是一个程序入口的方法。不同的类中的是可以相互调用 main 的方法的，如下

因为有两个类，每个类中都有一个 main() 方法，所以执行的时候，你需要选择，想要运行的是哪一个告知编译器。

package blogs.blog2;

public class MainTest {
    public static void main(String[] args) {
        System.out.println("我是 MainTest 中的 main()方法");
    }
}


class Main2{
    public static void main(String[] args) {
        System.out.println("我要调用 MainTest中的main()方法");
        // 调用 MainTest 中的main()方法
        MainTest.main(args);
    }
}

在这里插入图片描述

3. 代码块

在这里插入图片描述

代码块(或初始化块)的作用: 对Java类或者对象进行初始化

代码块的分类：

  • 一个类中代码块中若有修饰符，则只能被 static 修饰，被 static 修饰的代码块被称为 静态代码块。
  • 没有任何修饰符，修饰的代码块，被称为非静态代码块

静态代码块的特点：

  • 可以有输出语句
  • 可以对类的属性，类的声明进行初始化操作
  • 不可以对非静态的属性初始化，无法直接调用非静态的的方法/属性，想要 实例化对象 new
  • 静态代码块随着类的加载而加载，并执行，且执行一次。所以静态代码块的执行要先于非静态代码块
  • 一个类中可以有多个静态代码块，若有多个静态的代码块，那么按照从上到下的顺序依次执行。
  • 静态的代码块的诸多限制和 “staitc" 是一样的。

非静态代码块的特点:

  • 和静态代码块一样可以有输出语句
  • 可以对类的数，类的声明进行初始化操作。
  • 不仅可以调用静态的方法/属性，也可以调用非静态的方法 / 属性
  • 一个类中可以有多个非静态代码块，若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
  • 注意的是非静态代码块是，创建对象 (new) 的时候，才会执行，而且每创建一次对象都会执行一次，并且先于构造器执行。

无论是静态代码块/还是非静态代码块，都是加载后并执行的，并不是加载到内存当中不执行的。

在这里插入图片描述

注意: 非静态代码块，不是创建对象 (new) 是不会加载调用执行非静态代码块的

package blogs.blog2;

public class BlockTest {
    public static void main(String[] args) {
        Person.show();
    }
}

class Person{
    String name;
    static String desc;

    public void eat() {
        System.out.println("非静态方法");
    }


    public static void show(){
        System.out.println("静态方法");
    }


    {
        System.out.println("非静态代码块");
    }

    static{
        System.out.println("静态代码块");
        // name = "Tom";  // 静态代码块无法直接调用非静态的
        // eat();
    }
}

在这里插入图片描述

静态代码块优先比非静态代码块优先被执行，并且静态代码块仅仅只是执行一次(加载类的那一次)

package blogs.blog2;

public class BlockTest {
    public static void main(String[] args) {
        Person person = new Person();
        Person person2 = new Person();
    }
}

class Person{
    String name;
    static String desc;

    public void eat() {
        System.out.println("非静态方法");
    }


    public static void show(){
        System.out.println("静态方法");
    }


    {
        System.out.println("非静态代码块");
    }

    static{
        System.out.println("静态代码块");
        // name = "Tom";  // 静态代码块无法直接调用非静态的
        // eat();
    }
}

在这里插入图片描述

练习: 观察如下代码的运行结果：

先执行父类，再执行静态代码块

package day15;

public class LeafTest {
    public static void main(String[] args) {
        new Leaf();
        System.out.println("*************************");
        new Leaf();
    }
}


class Root{
    static {
        System.out.println("Root的静态初始化块");
    }

    {
        System.out.println("Root的普通初始化块");
    }

    public Root(){
        super();
        System.out.println("Root的无参数的构造器");
    }

}


class Mid extends Root{
    static{
        System.out.println("Mid的静态初始化块");
    }

    {
        System.out.println("Mid的普通初始化块");
    }

    public Mid() {
        super();
        System.out.println("Mid的无参数的构造器");
    }

    public Mid(String msg) {
        // 通过this调用一类中的重载的构造器
        this();
        System.out.println("Mid的带参数构造器,其参数数值: "+msg);
    }
}


class Leaf extends Mid{
    static{
        System.out.println("Leaf的静态初始化块");
    }
    {
        System.out.println("Leaf的普通初始化块");
    }

    public Leaf() {
        // 通过super调用父类中有一个字符串参数的构造器
        super("尚硅谷");
        System.out.println("Leaf的构造器");
    }
}

在这里插入图片描述

package day15;


public class Son extends Father {
    static {
        System.out.println("44444444444444444");
    }
    {
        System.out.println("55555555555555");
    }

    public Son() {
        System.out.println("66666666666666");
    }

    public static void main(String[] args) {
        System.out.println("77777777777");
        System.out.println("**********************************");

        new Son();
        System.out.println("*********************************");

        /*new Son();
        System.out.println("*************************************");
        new Father();*/
    }
}


class Father{
    static{
        System.out.println("11111111111");
    }
    {
        System.out.println("222222222222");
    }

    public Father() {
        System.out.println("33333333333333");
    }
}

在这里插入图片描述

3.1 程序中成员变量赋值的执行顺序

如下是对属性赋值的先后所执行的顺序

  1. 默认初始化
  2. 显式初始化
  3. 在代码块中赋值
  4. 构造器中初始化
  5. 有了对象以后，可以通过 ”对象.属性，或对象.方法“ 的方式，进行赋值。
    在这里插入图片描述
public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();
        System.out.println(order.orderId);
    }
}

class Order{
    {
        orderId = 4;
    }
    int orderId = 3;

    public Order() {
        this.orderId = 5;
    }

}

在这里插入图片描述

把构造器初始化注释掉，结果是

在这里插入图片描述

4. final 关键字

final : 最终的含义。

final 可以用来修饰：类，方法，变量，局部变量(形参)。

final 修饰一个类，此类就不能被其他类所继承了

比如：System 类，String 类，StringBuffer类：因为里面的方法基本都实现了，没有必要再通过继承扩展了。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

final 修饰方法：表明此方法不可以被重写，比如：Object 类中的 getClass()

在这里插入图片描述

在这里插入图片描述

final 修饰属性：可以考虑赋值的位置有：显示初始化，代码块初始化，构造器，注意是：赋值不是修改,被 final 修饰的变量无法被修改了。

显示初始化

package blogs.blog2;

public class FinalTest {
    final int num = 10;

    public static void main(String[] args) {
        FinalTest f = new FinalTest();
        System.out.println(f.num);
    }
}

在这里插入图片描述

代码块初始化:

package blogs.blog2;

public class FinalTest {
    final int LEFT;
    {
        LEFT = 100;
    }

    public static void main(String[] args) {
        FinalTest f = new FinalTest();
        System.out.println(f.LEFT);
    }
}

在这里插入图片描述

构造器初始化:

package blogs.blog2;

public class FinalTest {
    final int num;

    public FinalTest(int n) {
        num = n;
    }


    public static void main(String[] args) {
        FinalTest f = new FinalTest(1000);
        System.out.println(f.num);
    }
}

在这里插入图片描述

final 修饰局部变量(形参) 表明此形参时一个常量，当我们调用此方法时，给常量形参赋值一实参，一旦赋值以后，就只能在方法体中使用此形参，并且不能再进行重新的赋值操作了。

在这里插入图片描述

package blogs.blog2;

public class FinalTest {
    final int num;

    public FinalTest(final int n) {
        num = n;
    }


    public static void main(String[] args) {
        FinalTest f = new FinalTest(1000);
        System.out.println(f.num);
    }
}

一般是 static, final 用来修饰属性，全局常量，需要注意的是一般 static 的成员属性，方法也是 static 的

练习:

观察如下代码是否会出现报错，如果不会报错，运行的结果又是什么？？？

package blogs.blog2;

public class FinalTest {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.test(aa);

    }




}

class AA {
    String name;
    int age ;

    public void test(final AA aa) {
        aa.age = 10;   // 这里是否或报错，能否编译成功
        System.out.println(aa.age);
    }
}

在这里插入图片描述

解析:

答：不会报错，结果是 10 。

因为 final 修饰的是 AA 这个引用类型的形参，并不会作用于 AA 类中的属性。

如果我修改 AA 这个引用类型的地址，可能就会报错了。

5. 总结:

  1. static 修饰属性，方法，代码块，内部类的不同的作用，
  2. static 静态的随着类一起加载到内存(方法区)当中(仅仅加载一次，所有对象共有)，早于 new 对象的加载创建，因为 new 对象，要先加载类，再调用类中的构造方法创建对应的对象。
  3. static 静态的属性，方法，代码块 都无法直接的访问非静态的方法/属性，需要通过 创建实例对象(new)的方式访问
  4. 被 static 修饰的方法，无法被重写，就算编写成了重写的方式了，但是调用的时候，执行的不是子类重写的方法，而是父类中没有被重写的方法。
  5. main 方法的 public , static ,String[] args 的作用。
  6. 代码块：静态代码块，非静态代码块。
  7. 静态代码块：随着类一起加载到内存(方法区)当中，加载的同时，并执行代码块，并且(无论加载多少次类)只执行一次(加载类的那一次)。优先于非静态代码块，优先于构造器。
  8. 非静态代码块：只有当创建实例对象(new)的时候才会被加载并执行，创建多少次对象就会执行多少次非静态代码块。
  9. final 最终的，可以修饰：属性(不可修改)，形参(不可修改)，方法(无法重写)，类(无法继承)。

6. 最后:

限于自身水平，其中存在的错误，希望大家给予指教，韩信点兵——多多益善，谢谢大家，后会有期，江湖再见！！！

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/110785.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CentOS7迷你版安装Redis并配置基础信息

CentOS7迷你版安装Redis并配置基础信息

1. 安装gcc、wget依赖 yum install gcc yum install wget 2. 使用命令：wget http://download.redis.io/releases/redis-6.2.5.tar.gz 下载安装包，注意要先cd到要下载到的目标位置） 3. tar -zxvf redis-6.2.5.tar.gz 解压压缩包 4. cd redis-…
阅读更多...
学习周报-20221223

学习周报-20221223

文章目录一 Linux的ACL访问控制列表一 基础概念1.1 起因1.2 系统支持1.3 相关定义二 查看ACL权限2.1 简单查看2.2 详细查看2.3 具体配置三 更改ACL权限3.1 添加或修改ACL3.2 输出和输入3.3 设置ACL掩码3.4 递归修改ACL3.5 删除ACL3.6 控制默认ACL权限二 Linux磁盘分区中物理卷&…
阅读更多...
zabbix6.0安装教程（七）：从web界面安装

zabbix6.0安装教程（七）：从web界面安装

zabbix6.0安装教程（七）：从web界面安装 目录一、欢迎主界面二、先决条件检查三、配置数据库连通性四、配置本章节提供有关Zabbx Web界面的部署步骤说明。Zabbix 前端是由PHP语言编写，所以其网页服务的运行需要支持PHP语言的网站服务…
阅读更多...
Allegro如何任意角度走线操作指导

Allegro如何任意角度走线操作指导

Allegro如何任意角度走线操作指导 Allegro支持在PCB上进行任意角度走线，尤其是在高速设计的时候，尤为常见，如下图 具体操作如下 选择add connect命令Find选择Cline segs
阅读更多...
谷歌要给移动VR定规矩

谷歌要给移动VR定规矩

代号牛轧糖的最新安卓7.0手机操作系统发布两天后，谷歌公司开发的虚拟现实（VR）平台Daydream（下称“白日梦”）也将在未来几周推出。与平台一同推出的，还有来自Hulu和YouTube等视频网站“网红”们的全新视频内…
阅读更多...
【软件工程】实验3：软件详细设计

【软件工程】实验3：软件详细设计

CAM系统的类图 CAM系统的顺序图 CAM系统模拟实现（CAM工具库封装） 1、代码运行界面 （1）根据提示输入要加工的图形类型 （2）J-Soft软件会根据输入的数字提示用户输入不同的图形参数，图形参数输入…
阅读更多...
函数栈帧（栈区）

函数栈帧（栈区）

函数栈帧（栈区）一.前言二.main函数空间的开辟（函数调用是如何做到的）三.main函数内部的变量初始化（局部变量是如何创建的以及为什么是随机值）四.main函数内部的函数创建1.函数是如何传参的2.传参的顺序以及…
阅读更多...
物联网通信技术原理第2章 无线通信技术（期末重点）

物联网通信技术原理第2章 无线通信技术（期末重点）

目录 2.1 无线通信基本知识 2.1.2 无线通信的特点 2.2 无线信道 2.2.1 恒参无线信道举例 2.2.2 恒参无线信道特性及其对信号传输的影响 1. 幅度—频率畸变 2. 相位—频率畸变​编辑 2.2.3 随参无线信道距离 1、短波电离层反射 2、对流层散射信道 2.2.4 随参信道特性及…
阅读更多...
漏洞深度分析|Apache Karaf 4.2.16 存在JNDI 注入漏洞

漏洞深度分析|Apache Karaf 4.2.16 存在JNDI 注入漏洞

项目地址 GitHub - apache/karaf: Mirror of Apache Karaf 项目介绍 Apache Karaf是一个模块化运行时，支持多种框架和编程模型（REST/API、web、spring boot 等）。它提供了统包功能，您可以毫不费力地直接利用这些功能&#xff0…
阅读更多...
戴维南定理

戴维南定理

定理内容：任意二端口直流网络都可以被一个等效电路替换，这个等效电路只包含一个电压源和一个串联电阻，如图1所示。 图1 戴维南定理的作用 1、分析含有非串联或非并联电源的网络 2、用最少数量的元件实现复杂网络的端口特性（端口前…
阅读更多...
【深入浅出Spring原理及实战】「开发实战系列」SpringSecurity原理以及实战认证分析开发指南

【深入浅出Spring原理及实战】「开发实战系列」SpringSecurity原理以及实战认证分析开发指南

前提介绍 承接上一篇文章，相信大家应该已经对SpringSecurity的原理有了一定的认识，而本篇文章给大家带来的则是在实际业务开发中的技术指南，希望对你有所帮助。所谓知彼知己方能百战百胜，用Spring Security来满足我们的需求最好了…
阅读更多...
我们国家都有哪些信息安全标准

我们国家都有哪些信息安全标准

写在前面 早年刚参加信息安全工作更多的学点皮毛技术，到处找安全工具，跟踪poc，拿到一个就全网扫一遍，从来没有想过，系统化的安全工作应该怎样搞?我做的工作在安全体系中处于哪个阶段? 后来有机会做企业安全建设&…
阅读更多...
503.下一个更大元素II，42. 接雨水

503.下一个更大元素II，42. 接雨水

503. 下一个更大元素 II 给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。 数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数…
阅读更多...
C++：vector操作笔记

C++：vector操作笔记

本文记录了对C中的vector容器的简单操作，包括给vector添加元素、按指定列排序、取值。 文章目录一、vector 和普通数组之间的转化二、根据vector数组的某一列数据排序三、删除二维 vector 数组最后一列数据一、vector 和普通数组之间的转化 1，数组转vec…
阅读更多...
Mysql日志体系

Mysql日志体系

3、Mysql日志体系 bing log ：在server记录mysql所有的DDL和DML语句，主要用来做主从复制和数据恢复。内容追加，没有固定大小限制。redo log ：undo log ： 3.1、bin log 3.1.1、binlog日志作用 binlog记录所有的DDL和…
阅读更多...
Unity CEO：玩家不在乎AR还是VR，他们只想要优质内容

Unity CEO：玩家不在乎AR还是VR，他们只想要优质内容

近期，Unity CEO John Riccitiello在接受英国金融时报采访时，透露了自己对于游戏的前生今世，以及AR/VR和未来的看法。他认为，打造一个新平台需要大量优质内容，创意对于新平台很重要，不管AR和VR技术有什么区别…
阅读更多...
java医院挂号系统挂号预约网站挂号网站预约网站源码

java医院挂号系统挂号预约网站挂号网站预约网站源码

主要实现门诊挂号和用户网站预约挂号的功能 演示视频： https://www.bilibili.com/video/BV1nN411d7HT/?share_sourcecopy_web&vd_sourceed0f04fbb713154db5cc611225d92156 环境：jdk7/8mysql5.5tomcat7/8 技术：ssm(springspringmvcmyi…
阅读更多...
读书笔记---Bioinformatics Data Skills

读书笔记---Bioinformatics Data Skills

最近阅读了《Bioinformatics Data Skills》，是不错的生物信息学入门书，本文作者简介如下： 全书以下面三个方向展开，为生物信息学的继续学习指明了道路： （1）生物信息学数据技巧（第一章…
阅读更多...
动态DNS与DPDK高性能DNS -DPDK环境搭建

动态DNS与DPDK高性能DNS -DPDK环境搭建

工具准备： vmware Ubuntu 16.04 Server 版本 1.vmware 添加两块网卡 桥接网卡作为 DPDK 运行的网卡 NAT 网卡作为 ssh 连接的网卡 2.修改网卡配置信息 将 ethernet0.virtualDev 由 e1000 修改 vmxnet3，因为 vmware 的 vmxnet3 支持多队 列网卡 3.修…
阅读更多...
Qt对象树

Qt对象树

对象模型（对象树） 类似于c中虚析构实现的功能一样，在释放父类对象的同时调用子类的析构函数释放子类对象 也c调用析构函数的区别是：会先调用父类的析构函数，然后一层层往下调用子类析构，直到调用到底层子…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023