精华内容
下载资源
问答
  • Java中static修饰符的作用
    2018-11-26 12:19:33

    近日在做网络通信服务器和客户端的Java语言开发,碰到了获取客户端长连接Channel对象,利用唯一对象Client的获取方法getSingleClientInstance(),以为可以得到,但是显示始终为空指针。之后又换了好几种获取值的办法,一直是空指针。最后想着static修饰符的作用不是初始化就给了唯一一个内存空间吗?所以改用在Client属性中声明Channel对象为静态对象,又利用getChannel()获取这个静态对象,终于找到你,此时很激动Elate。所以全面的找了一下static修饰符的用法。


    既然是修饰符,当然可以修饰一切可以修饰的对象 。 比如,变量、方法、代码块、内部类!也可以这样理解,static域和非static域的存储空间是不同的,被static修饰符修饰的对象,都被存储在静态存储区,当然,每个类的方法也是在静态存储区的。这也就是所说的static修饰的变量和方法被称为类属性类方法,不隶属于哪一个对象。

    1. 变量
    一个变量有了static修饰符,内存会为它分配唯一的一块存储空间。程序跑起来的时候,变量就存在在内存里了。谁要用它,就去访问一下它所在的内存。

    2. 方法
    一个方法被static修饰,可直接访问;不被static修饰,就需要用对象来访问了。

    3. 代码块
    静态块–>非静态块–>构造函数的顺序执行。
    加载静态块时为它分配固定的内存,程序结束时内存才被释放。而非静态块和构造函数则是new一次执行一次。

    4. 内部类
    只能修饰内部类。
    静态内部类也可以拥有静态方法和非静态方法
    静态内部类只可以访问外部类的静态成员和静态方法,不可以访问非静态成员和非静态方法
    静态内部类访问自己内部的静态成员和静态方法时,也是通过点出来的,不过在前面需要加上外部类的名字。

    5.静态导包
    静态导包用法,将类的方法直接导入到当前类中,从而直接使用“方法名”即可调用类方法。在单元测试中用的多。比如Assert类的静态导入。

    6. 注意事项
    被static修饰的方法中不能出现非static对象。

    更多相关内容
  • 主要介绍了Java编程中protected关键字与static关键字的作用,是Java入门学习中的基础知识,需要的朋友可以参考下
  • 本文主要给大家介绍了关于c++中static修饰符的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧。 下面一段是引用自effective c++ 中的一句话: 所谓的static对象,其寿命是从构造出来到...
  • static修饰符用法

    2021-02-15 11:13:17
    在Java中,static修饰符是比较重要的知识点,也是Java工程师面试时,问的比较多的问题。因此,对static修饰符知识点的学习及整理,还是很有必要的。 static修饰符总的来说有四种作用:修饰字段或方法、修饰代码块、...


    Java中, static修饰符是比较重要的知识点,也是 Java工程师面试时,问的比较多的问题。因此,对 static修饰符知识点的学习及整理,还是很有必要的。

    static修饰符总的来说有四种作用:修饰字段或方法、修饰代码块、静态导入包、构造静态内部类

    一、修饰字段或方法

    1.修饰字段

    当使用static修饰字段时,那么该字段就为静态字段,在每个类中只有一个这样的字段。而其他非静态的字段,在每个对象中都有自己的一个副本。

    例如:
    在学生Student类中有两个字段,分别是:学校id——schoolId(静态字段)、学生id——studentId(非静态字段)。每个Student对象都有自己的学生id,但是这些学生都有同一个学校id
    也就是说,如果有1000个学生对象,则有1000个学生id,分别对应每一个学生对象。但是,只有一个静态字段学校id,即使没有学生对象,静态字段学校id也是存在的。

    静态变量使用的较少,但是静态常量使用的较多。例如,JavaMath类中定义的Π静态常量。

    public static final double PI = 3.14159265358979323846;
    

    2.修饰方法

    static修饰的方法,称为静态方法。静态方法是不用实例化对象就可以执行的方法。调用普通的方法时,首先需要实例化对象,然后再调用方法;调用静态方法时,不需要实例化对象,可以直接调用方法。

    例如:
    Math类中的max方法,传入两个整型数值,返回最大值,表达式为:

    Math.max(int a, int b)
    

    那么什么时候会使用静态方法呢?

    • 方法只需要访问类的静态字段时
    • 调用方法不需要实例化对象时

    二、修饰代码块

    如果类的静态字段需要比较复杂的初始化代码时,可以使用静态代码块。
    将代码放在一个块中,并将该块标记为static,那么就构造了静态代码块。

    例如:

    //随机生成一个小于1000的随机整数
    private static int id = 1;
    static{
      Random random = new Random();
      id = random.nextInt(1000);
    }
    

    三、静态导入包

    在使用静态字段或方法时,需要在字段或方法前加类名,例如使用数学类中比较最大值的方法时,需要在max方法前加Math类名,当使用静态字段或方法较少时,这样没有问题,但是如果使用的静态字段或方法较多时,就可以在类文件头部静态导入包。

    例如:
    在没有静态导入包前,使用最大值比较函数,是这样写:

    //头部没有静态引入Math类
    Math.max(1,2);
    
    import static java.lang.Math.*;
    ……
    //头部静态引入了Math类
    max(1,2);
    

    通过静态引入类,可以使得代码更清晰,代码量也减少了。


    四、构造静态内部类

    当一个内部类只是为了隐藏在一个类内部,并不需要内部类有外部类的引用时,可以将内部类声明为static

    要点:

    • 只要内部类不需要访问外部类对象,那么就应该使用静态内部类
    • 与常规内部类不同,静态内部类可以有静态字段和方法
    • 在接口中声明的内部类自动是staticpublic

    展开全文
  • C++ static 修饰符

    千次阅读 热门讨论 2021-05-05 22:40:55
    C++ static 修饰符是什么 & static 修饰符的使用场景以及用法.

    概述

    static (静态) 修饰符是用来控制变量的存储方式和可见性的. 静态局部变量存储在静态区域:
    在这里插入图片描述
    static 的性质:

    • 局部特性: 作用范围仅限于本函数
    • 静态特性:存储在静态区, 函数调用结束后不孝顺而保留原值. 在下一次调用时, 保留上一次调用结束时的值.

    静态数据成员

    在我们定义全局变量的时候, 我们会发现一个问题:
    我们可以在程序各处自由的修改全局变量的值 (不安全).

    静态数据成员的特点:

    1. 静态数据成员被所有对象共享, 在所有对象之外单独开辟空间存储
    2. 静态数据成员所占空间并不随某个对象的撤销而释放
    3. 静态数据成员可以在同类的多个对象之间实现数据共享
      在这里插入图片描述

    引用静态数据成员

    Student 类:

    #ifndef PROJECT1_STUDENT_H
    #define PROJECT1_STUDENT_H
    
    #include <string>
    using namespace std;
    
    class Student {
    private:
        static int count;  // 定义静态数据成员
        int num;
        string name;
        char gender;
    public:
        Student();
        Student(int num, string name, char gender);
        ~Student();
        int getCount() {return count;}
        void display();
    };
    
    #endif //PROJECT1_STUDENT_H
    

    Student.cpp:

    #include "Student.h"
    #include <iostream>
    using namespace std;
    
    // 类外初始化静态数据成员
    int Student::count = 0;
    
    // 无参构造
    Student::Student() : num(-1), name("None"), gender('N') {}
    
    Student::Student(int n, string p, char g) : num(n), name(p), gender(g) {
        count ++;
    }
    
    void Student::display() {
        cout << "num: " << num << endl;
        cout << "name: " << name << endl;
        cout << "gender: " << gender << endl;
        cout << "===============" << endl;
    }
    
    Student::~Student() {
        count --;
    }
    

    main:

    #include "Student.h"
    #include <iostream>
    using namespace std;
    
    int main() {
    
        Student student1(1, "Little white", 'f');
        cout << student1.getCount() << endl;
    
        Student *pt = new Student(1, "Little white", 'f');
        cout << pt -> getCount() << endl;
        cout << student1.getCount() << endl;
    
        // 释放
        delete pt;
        cout << student1.getCount() << endl;
    
        return 0;
    }
    

    输出结果:

    1
    2
    2
    1
    

    静态数据成员是 “大家” 的:

    • 静态数据成员不属于某对象, 而是属于类的所有对象. 不过, 用类的对象可以引用它
    • 如果静态数据成员被定义为私有的, 则不能在类外直接引用, 而必须通过公用的成员函数引用
    • 静态数据成员实现了各对象之间的数据共享, 同时避免了使用全局变量破坏了封装的原则

    用类名访问数据成员

    Student 类:

    #ifndef PROJECT1_STUDENT_H
    #define PROJECT1_STUDENT_H
    
    #include <string>
    using namespace std;
    
    class Student {
    private:
        int num;
        string name;
        char gender;
    public:
        static int count;  // 定义静态数据成员
        Student();
        Student(int num, string name, char gender);
        ~Student();
        int getCount() {return count;}
        void display();
    };
    
    #endif //PROJECT1_STUDENT_H
    

    Student.cpp:

    #include "Student.h"
    #include <iostream>
    using namespace std;
    
    // 类外初始化静态数据成员
    int Student::count = 0;
    
    // 无参构造
    Student::Student() : num(-1), name("None"), gender('N') {}
    
    Student::Student(int n, string p, char g) : num(n), name(p), gender(g) {
        count ++;
    }
    
    void Student::display() {
        cout << "num: " << num << endl;
        cout << "name: " << name << endl;
        cout << "gender: " << gender << endl;
        cout << "===============" << endl;
    }
    
    Student::~Student() {
        count --;
    }
    

    main:

    int main() {
        
        cout << Student::count << endl;
        Student *pt = new Student(1, "Little white", 'f');
        cout << pt -> getCount() << endl;
    
        // 释放
        delete pt;
        cout << Student::count << endl;
    
        return 0;
    }
    

    输出结果:

    0
    1
    0
    

    静态数据成员既可以通过对象名引用, 也可以通过类名来引用. 在作用域内, 通过类名和运算符 “::” 引用静态数据成员时, 不用考虑该类知否有对象存在.

    静态成员函数

    成员函数也可以定义为静态的, 我们只需要在类声明函数的前面加上 static 关键字. 如:

    #ifndef PROJECT1_STUDENT_H
    #define PROJECT1_STUDENT_H
    
    #include <string>
    using namespace std;
    
    class Student {
    private:
        int num;
        string name;
        char gender;
    public:
        static int count;  // 定义静态数据成员
        Student();
        Student(int num, string name, char gender);
        ~Student();
        static int getCount() {return count;}  // 定义静态成员函数
        void display();
    };
    
    #endif //PROJECT1_STUDENT_H
    

    静态成员函数的作用就是为了能处理静态数据成员, 即不需要 this 指针访问的成员.

    重点:

    • 静态成员的本质特征是类中所有对象的 “公共元素”
    • 静态成员的语法特征是通过类名和域运算符 “::” 引用, 而不只是通过对象引用

    综合案例

    Student 类:

    #ifndef PROJECT1_STUDENT_H
    #define PROJECT1_STUDENT_H
    
    #include <string>
    using namespace std;
    
    class Student {
    private:
        int num;
        string name;
        char gender;
        int score;
    public:
        static int count;  // 定义静态数据成员
        static int sum;  // 定义静态数据成员
        Student();
        Student(int num, string name, char gender, int score);
        ~Student();
        static double average() {return (sum / count);}
        static int getCount() {return count;}
        void display();
    };
    
    #endif //PROJECT1_STUDENT_H
    

    Student.cpp:

    #include "Student.h"
    #include <iostream>
    using namespace std;
    
    // 类外初始化静态数据成员
    int Student::count = 0;
    int Student::sum = 0;
    
    // 无参构造
    Student::Student() : num(-1), name("None"), gender('N'), score(-1) {}
    
    Student::Student(int n, string p, char g, int s) : num(n), name(p), gender(g), score(s) {
        count ++;
        sum += s;
    }
    
    void Student::display() {
        cout << "num: " << num << endl;
        cout << "name: " << name << endl;
        cout << "gender: " << gender << endl;
        cout << "===============" << endl;
    }
    
    Student::~Student() {
        count --;
    }
    

    main:

    #include "Student.h"
    #include <iostream>
    using namespace std;
    
    int main() {
    
        // 创建student数组
        Student student_array[3] = {
                Student(1, "Little white", 'f', 68),
                Student(2, "Small white", 'f', 78),
                Student(3, "Big white", 'f', 88)
        };
    
        // 调试输出平均分
        cout << "三个学生的平均分是: " << Student::average() << endl;
    
        return 0;
    }
    

    输出结果:

    三个学生的平均分是: 78
    
    展开全文
  • 修饰符, 表示静态的, 可以用来修饰类和成员变量已经方法; 可修饰的范围 可以修饰的范围有成员变量, 普通方法, 内部类; class People{ static String name; // 修饰成员变量 int age; public People(String n,...

    static的概念
    是修饰符, 表示静态的, 可以用来修饰类和成员变量已经方法;

    可修饰的范围
    可以修饰的范围有成员变量, 普通方法, 内部类;

    class People{
    	static String name; // 修饰成员变量
    	public People(String n){
    	// 构造方法不能被static修饰
    		name = n;
    		}
    	public static void action(){
    		// 修饰普通方法
    		System.out.print("可以修饰普通方法");
    	}
    	static class Inner{
    		// 内部类
    	}
    }
    

    不可以修饰的范围:
    修饰构造方法, 外部类时会报错:
    Illegal modifier for the class Student; only public, abstract & final are permitted, 表示错误地使用修饰符来修饰, 只能通过 public, abstract , final are permitted修饰

    特点
    static修饰的成员(成员变量, 普通方法, 内部类)在类被加载的时候, 会加载到静态区。会被所有该类实例的对象共享, 所以在这里一般定义变量不建议使用static修饰成员变量(除非专门的使用场景, 下面有介绍)。
    不建议使用static修饰成员变量的原因:
    因为程序的执行流程的关系, 当需要用到一个类的时候(或者是创建对象的时候), 程序会去加载该类的字节码文件。这个时候,程序会先判断当前字节码文件是否有static修饰的成员, 如果有的话就会先将该static修饰的成员加载到静态区, 分配一个地址, 然后再加载字节码文件, 加载的字节码文件的时候会持有该静态成员的地址。

    public class PeopleTest {
     /**
     * @author huaixiao
     *	测试类   static 
     */
    	public static void main(String[] args) {
    		People p1 = new People("张三");
    		System.out.println(p1.name); //张三
    		People p2 = new People("李四");
    		System.out.println(p1.name); // 李四
    		System.out.println(p2.name); // 李四
    	}
    }
    
    

    得到的结果如下 , 说明static修饰的成员变量, 共享数据, 永远以最后修改的那一次为准

    张三
    李四
    李四
    

    在这里插入图片描述

    使用场景
    1. 需要被所有对象共享的一些数据的时候才使用, 例如 火车票数, 全国各地都可以抢, 但是数据是共享的
    2. 不想被多次创建对象的时候, 因为创建对象会消耗资源
    3. 单例模式
    4. 还有就是与public static final 连用, 作为全局变量等

    展开全文
  • 先看下面的例子,它将告诉我们在JS世界中也有C#里的public , private ,及static
  • java中static修饰符的作用

    千次阅读 2018-03-08 09:25:46
    static修饰的成员变量和成员方法独立于该类的任何对象。也就是说,它不依赖类特定的实例,被类的所有实例共享。只要这个类被加载,Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此,static对象...
  • Java static 修饰符的理解

    千次阅读 2020-04-04 10:38:21
    static 修饰的变量,方法,代码块 只有变量和代码块会在类加载时就初始化 而static方法只要在被调用时才执行(里面的变量也只有这时候才初始化)。 但是,一般不常用的方法还是不建议用static 因为,系统启动后,...
  • 题目代码化: package com.test; public class Test { public void main(String[] args) { System.out.println("test"); } } 结果: 通过powershell再来验证一下: 正常编译,运行报错 ......
  • final 最终的 fianl 修饰类,不存在子类,比如String类 final修饰方法,子类不能重写...static 静态 修饰属性,属于类不属于某一个对象,一旦改变值,则具有全局特性,某一个对象的属性值就会发生改变。犹如修改...
  • 记录一下,待梳理补充。 静态方法的好处就是不用生成类的实例就可以直接调用。 static方法修饰的成员不再属于某个...如果不是static修饰的成员函数,在使用完之后就会立即被JVM回收。 什么时候使用static? 如...
  • 一、static修饰符 static修饰符可以修饰变量、方法或代码块 类的静态成员可以与类的名称一起使用,而无须创建类的对象。(可以直接通过类名来访问静态变量,建议使用类名来调用静态变量) 不管创建了类的多少实例...
  • 编程入门基础 static修饰符 主讲教师耿宇航 Copyright2013, All Rights Reserved 谢 谢 ! Copyright2013,, All Rights Reserved
  • JAVA中理解static修饰符的作用

    千次阅读 2014-05-30 21:02:11
    是静态修饰符,什么叫静态修饰符呢?大家都知道,在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的,而所谓静态就是指在编译后所分配的内存会一直存在,直到程序退出内存才会释放这个空间,也就是...
  • 以下是对Java修饰符abstract,static,final的区别进行了详细的介绍,需要的朋友可以过来参考下
  • static关键字(静态修饰符

    千次阅读 2019-03-19 22:52:19
    1、static是一个修饰符,用于修饰成员 2、static修饰的成员被所有的对象所共享 3、static优先于对象存在,因为static的成员随着类的加载就已经存在了 4、static修饰的成员多了一种调用方式,即可以直接被类名调用...
  • 关于java的static修饰符使用注意点

    千次阅读 2019-08-09 11:31:14
    情景:在A类里面定义了两个static 变量,x和y,然后,y=x, 在B类方法中,更新了x的值,同时,在更新x值后,引用y值,但是y值为null 代码: java类A package com.rh.test; public class A { public static ...
  • static修饰符详解

    千次阅读 多人点赞 2015-05-26 08:41:03
    static修饰的成员变量和成员方法独立于该类的任何对象。也就是说,它不依赖类特定的实例,被类的所有实例共享。 只要这个类被加载,Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此,static对象...
  • static修饰符和特点

    2018-02-03 09:53:07
    static修饰符表示静态的,可修饰字段、方法、内部类,其修饰的成员属于类,也就是说static修饰的资源属于类级别,而不是对象级别 static真正的作用:用来区别字段,方法,内部类,初始化代码块是属于对象还是类...
  • 为什么要在全局变量上加上static修饰符为什么要在全局变量上加上static修饰符为什么要在全局变量上加上static修饰符 全局变量,会带来命名污染,全局可用,避免传参。 一个全局变量,天然的拥有外延性,可以被其它的...
  • abstract修饰类 (1) 被abstract修饰的类是抽象类,编译后生成独立class文件 (2) 抽象类不能单独new对象,但可以声明引用 (3) 抽象类可以定义成员变量和成员方法 (4) 抽象类可以有构造,但不用于new对象,而是用于子类...
  • java中static修饰符

    万次阅读 2017-04-27 00:03:16
    static修饰符:共享的static的成员变量只会在数据共享区中维护一份,而非静态成员变量的数据会在每个对象中都维护一份的。
  • Java中static修饰符

    千次阅读 2015-01-04 23:52:07
    解析static修饰符与内存关系
  • 单例设计模型: Singleton模式开发:Static通常用于,单例设计,静态只有一份,并且常驻内存。 Singleton是一种设计模式,高于语法,可以保证一个类在整个系统中仅有一个对象。 待续!
  • 修饰符static的五种用法

    千次阅读 2018-09-08 22:47:39
    static修饰的类、方法等都是静态的,也就是不依赖实例进行创建,在类被第一次访问的时候就加载了。static出现的地方以及所起的作用大概有五种: 1. 修饰静态属性; 2. 修饰静态方法; 3. 修饰静态内部类; 4. ...
  • static修饰符的作用及应用

    千次阅读 2016-03-27 14:12:39
    static 修饰符 1.数据共享成员变量(实例变量)和静态变量(类变量)的区别 1.两个变量的生命周期不同 成员变量随对象的创建而存在,随对象被回收而释放 静态变量随类的加载而存在,随类的消失而消失 2.调用...
  • 面向对象中static修饰的内容隶属于类而不是属于对象 1. static用来修饰成员变量: 被static修饰的成员变量叫静态成员变量,如果没有被修饰叫非静态成员变量 定义变量后只运行一次代码的初始化操作,之后会跳过...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 295,468
精华内容 118,187
关键字:

static修饰符

友情链接: 图书管理系统.rar