精华内容
下载资源
问答
  • Java 静态类、静态方法和静态变量

    万次阅读 多人点赞 2017-11-06 15:44:52
    转载自Java 静态类、静态方法和静态变量Java 静态类、静态方法和静态变量static 是Java中的一个关键字,我们不能声明普通外层类或者包为静态的。static用于下面四种情况。1.静态变量:我们可以将类级别的变量声明为...

    转载自Java 静态类、静态方法和静态变量

    Java 静态类、静态方法和静态变量

    static 是Java中的一个关键字,我们不能声明普通外层类或者包为静态的。static用于下面四种情况。

    1.静态变量:我们可以将类级别的变量声明为static。静态变量是属于类的,而不是属于类创建的对象或实例。因为静态变量被类的所有实例共用,所以非线程安全的。通常静态变量还和关键字final一起用,作为所有对象共用的资源或常量。如果静态变量不是私有的,那么可以通过ClassName.variableName来访问它.

        //静态变量的例子
        private static int count;
        public static String str;
        public static final String DB_USER = "myuser"
    

    2.静态方法,类似于静态变量,静态方法也属于类,不属于实例的。静态方法只能访问类的静态变量,或调用类的静态方法。通常静态方法作为工具方法,被其它类使用,而不需要创建类的实例。譬如集合类、Wrapper类(String, Integer等)和工具类(java.util中的类)都有很多静态方法。通常java程序的开始就是一个main()方法,它就是个静态方法。

    //静态方法的例子
    public static void setCount(int count) {
        if(count > 0)
        StaticExample.count = count;
    }
    
    //静态工具方法
    public static int addInts(int i, int...js){
        int sum=i;
        for(int x : js) sum+=x;
        return sum;
    }

    3.静态块就是类加载器加载对象时,要执行的一组语句。它用于初始化静态变量。通常用于类加载的时候创建静态资源。我们在静态块中不能访问非静态变量。我们可以在一个类中有多个静态块,尽管这么做没什么意义。静态块只会在类加载到内存中的时候执行一次。

    static{
        //在类被加载的时候用于初始化资源
        System.out.println("StaticExample static block");
        //仅能访问静态变量和静态方法
        str="Test";
        setCount(2);
    }

    4.静态类:我们对嵌套类使用static关键字。static不能用于最外层的类。静态的嵌套类和其它外层的类别无二致,嵌套只是为了方便打包。


    静态类与内部类的区别

    内部类

    1、内部类拥有普通类的所有特性,也拥有类成员变量的特性
    2、内部类可以访问其外部类的成员变量,属性,方法,其它内部类

    静态内部类

    1、只有内部类才能声明为static,也可以说是静态内部类
    2、只有静态内部类才能拥有静态成员,普通内部类只能定义普通成员
    3、静态类跟静态方法一样,只能访问其外部类的静态成员
    4、如果在外部类的静态方法中访问内部类,这时候只能访问静态内部类

    /**
     * 外部类,不能声明为 static
     * 
     * @author zhanqi
     * 
     */
    public class OuterClass {
    
        private int ab = 1;
        private static int sab = 2;
    
        /**
         * 普通内部类
         */
        public class NormalInnerClass {
    
            // private static int age = 22;
            private int age = 22; // 不能声明为static
    
            public NormalInnerClass() {
                // 可以访问外部类静态与非静态成员
                System.out.println(ab);
                System.out.println(sab);
            }
        }
    
        /**
         * 静态内部类
         */
        public static class StaticInnerClass {
            // 定义静态与非静态成员都是可以的
            private static int age = 22;
            private int age2 = 22;
    
            private void echo() {
                // System.out.println(ab);
                System.out.println(sab);// 只能访问外部类的静态成员
            }
        }
    }

    内部类实例化

    1.访问内部类,必须使用:外部类.内部类,OutClass.InnerClass
    2.普通内部类必须绑定在其外部类的实例上
    3.静态内部类可以直接 new

    /**
     * 外部类访问内部类
     */
    public class OuterClass {
    
        /**
         * 普通方法
         */
        public void method() {
            StaticInnerClass sic = new StaticInnerClass();
            NormalInnerClass nic = new NormalInnerClass();
        }
    
        /**
         * Main
         */
        public static void main(String[] args) {
            // 在静态方法中,只能访问静态成员,静态内部类
            // NormalInnerClass nic = new NormalInnerClass();
            StaticInnerClass sic = new StaticInnerClass();
        }
    }
    
    /**
     * 其它类访问内部类
     */
    class Test {
        public static void main(String[] args) {
            /**
             * 1:其它类访问内部类,必须使用:外部类.内部类,OutClass.InnerClass
             * 2:普通内部类必须绑定在其外部类的实例上
             * 3:静态内部类可以直接 new
             */
            OuterClass.StaticInnerClass sic = new OuterClass.StaticInnerClass();
            // OuterClass.NormalInnerClass n = new OuterClass.NormalInnerClass();
    
            OuterClass oc = new OuterClass();
            OuterClass.NormalInnerClass nic = oc.new NormalInnerClass();
        }
    }

    静态对象

    静态对象我们经常使用,但是对静态对象和非静态对象的区别却并不一定那么了解。下表格就是静态对象和非静态对象主要区别。

    1.拥有的对象,静态对象是类共同拥有的 ,而非静态对象是由类单独拥有;
    2.内存空间,静态对象内存空间是固定,非静态类对象是附着相关类的分配;
    3.分配顺序,先分配静态对象的空间,然后才会分配非静态对象也就是初始化。

    展开全文
  • Java 静态变量,静态方法,静态常量 就是变量 ,方法,常量前面添加了static 关键字 为什么要使用静态的呢 有时候在处理问题时会需要两个类在同一个内存区域共享一个数据, 不如现在 Main 类中用到一个 NAME常量 而 有...

     

    Java 静态变量,静态方法,静态常量  就是变量 ,方法,常量前面添加了static 关键字

    为什么要使用静态的呢

    有时候在处理问题时会需要两个类在同一个内存区域共享一个数据, 不如现在 Main 类中用到一个 NAME常量 

    而 有一个Book类中也用到了NAME常量,这时就没有必要在2个类中都创建NAME常量了 为了解决这个问题 我们

    可以把这个NAME常量设置为static 相信这里就明白了为什么要使用了static了吧

    其语法:

             类名.静态类成员

    一个小案例 来更好的理解static 关键字

    package me;
    
    public  class Me {
        static String name; //静态变量
        static double PI = 3.14;//静态常量
    
        public static void Fine(){
         System.out.println("静态方法调用了额");
        }
    
        public void Method(){
            System.out.println(Me.name);
            System.out.println(Me.PI);
        }
    
        public static void main(String[] args) {
            Me.Fine(); //静态方法调用
            Me me = new Me();
            me.Method();// 等同于 new Me().Method();
    
        }
    }
    

           

     静态变量, 静态方法,静态常量 以上demo 都提到了.

    注意事项:

    1 静态方法不可以使用this关键字

    2 在静态方法中不可以直接调用非静态方法 

     

     

    展开全文
  • Java 静态工厂方法详解

    千次阅读 多人点赞 2019-04-08 19:09:54
    Java 静态工厂方法详解 本文章主要是对《Effective Java》对静态工厂方法的理解 第一次使用静态工厂方法是在HIT《Software Construction》课程的Lab2-P1的Graph.java中,对静态工厂方法的理解也相当有限,因此撰写...

    Java 静态工厂方法详解

    本文章主要是对《Effective Java》对静态工厂方法的理解

    第一次使用静态工厂方法是在HIT《Software Construction》课程的Lab2-P1的Graph.java中,对静态工厂方法的理解也相当有限,因此撰写此博客加深对静态工厂方法的理解。

    Java 静态工厂方法在实际开发中经常使用,在《Effective Java》中第二章第一条即为:考虑使用静态工厂方法代替构造器。

    静态工厂方法的含义

    静态工厂方法指的是在类中提供一个公有的静态方法,返回类的一个实例。

    静态工厂方法的第一大优势:它们有名称

    类的构造器名称被限制为类名,然而当构造器因不同的参数类型而无法确切的描述被返回的对象时,静态工厂方法却可以提供不同的函数名称作为不同构造方法。
    例如如下代码:

    public class Person {
        private final SEX sex;
        private final String name;
        private final int age;
    
        private Person(String name, int age, SEX sex){
            this.sex = sex;
            this.name = name;
            this.age = age;
        }
    
        public static Person getManInstance(String name, int age){
            return new Person(name, age, SEX.man);
        }
        
        public static Person getWomanInstance(String name, int age){
            return new Person(name, age, SEX.woman);
        }
    }
    
    enum SEX{
        man,
        woman;
    }
    

    在实际开发中,也如果是需要定义相同参数的构造器,可以通过交换参数位置的方法完成,但是这并不是一个好的方法,降低客户端代码的阅读性。

    静态工厂方法的第二大优势:不必在每次调用时都创建新的对象

    这种方法使得immutable的类可以使用预先构造好的实例或者是已经构造好的静态实例对象、进行重复利用。

    这里提供以下immutable类的五条规则:

    1. 不提供任何mutator
    2. 保证类不会被扩展
    3. 所有的域都是final的
    4. 所有的域都是私有的
    5. 确保对于任何可变组件的互斥性访问
      示例代码如下:
    public class Position{
        private final int x;
        private final int y;
        private static Position ORIGIN = new Position(0,0);
        private Position(int x, int y){
            this.x = x;
            this.y = y;
        }
    
        public static Position getORIGIN(){
            return ORIGIN;
        }
        
        public int getX(){
            return x;
        }
        
        public int getY(){
            return y;
        }
    }
    

    静态工厂方法第三大优势:他们可以返回原返回类型的任何子类型的对象

    这样我们在选择返回对象的类时就有了更大的灵活性。
    这种灵活性的一种应用是,API可以返回对象,同时又不会使对象的类变成公有的。以这种方式隐藏实现类会使API变得非常简洁。这项技术适用于基于接口的框架(interface-basedframework),因为在这种框架中,接口为静态工厂方法提供了自然返回类型。接口不能有静态方法,因此按照惯例,接口Type的静态工厂方法被放在一个名为Types的不可实例化的类(见第4条)中。
    示例代码如下:

    public class Person {
        public static Person getStudent(){
            return new Student();
        }
    }
    class Student extends Person {
    
    }//仅为一无内涵的示例
    

    静态工厂方法的第四大优势在于,在创建参数化类型的实例的时候,他们使代码变得更加简介

    此优势主要体现在泛型初始化时,示例代码如下:

        // 不使用静态工厂方法的情况:
        Map<String, Integer> map = new HashMap<String, Integer>();
        
        
        // HashMap中如果存在此方法:
        public Map<K,V> getInstance(){
            return new HashMap<K,V>();
        }
        
    //    即可简化成以下代码
        Map<String, Integer> map = HashMap.getInstance();
    

    静态方法的主要缺点是,类如果不含有共有的或受保护的构造器,就不能被子类化。

    这一部分较有体会,例如以下代码(错误示例)

    public class Person {
        private final SEX sex;
        private final String name;
        private final int age;
    
        private Person(String name, int age, SEX sex){
            this.sex = sex;
            this.name = name;
            this.age = age;
        }
    
        public static Person getManInstance(String name, int age){
            return new Person(name, age, SEX.man);
        }
    
        public static Person getWomanInstance(String name, int age){
            return new Person(name, age, SEX.woman);
        }
    }
    
    class Student extends Person {
        
    }
    

    实际在编译器的静态检查中会报错,原因是父类缺少公有的构造方法,而子类无法调用父类的私有构造器,导致子类无法生成构造器。

    静态工厂方法的第二个缺点在于,他们与其他的静态方法实际没有任何区别

    下面是一些静态工厂方法的惯用名称:

    1. valueOf——不太严格地讲,该方法返回的实例与它的参数具有相同的值。这样的静态工厂方法实际上是类型转换方法。
    2. of—— valueOf的一 种更为简洁的替代,在EnumSet (见第32条)中使用并流行起来。
    3. getInstance-返回的实例是通过方法的参数来描述的,但是不能够说与参数具有同样的值。 对于Singleton来说, 该方法没有参数,并返回唯一的实例。
    4. newInstance——像 getInstance-样, 但newInstance 能够确保返回的每个实例都与所有其他实例不同。
    5. getType——像getInstance- 样, 但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。
    6. newType——像newinstance一样,但是在工厂方法处于不同的类中的时候使用。Type表示工厂方法所返回的对象类型。

    要不,点个赞?~

    展开全文
  • Java静态变量、静态常量、静态方法

    万次阅读 2016-11-17 17:24:17
    Java静态变量、静态常量、静态方法  静态变量和静态方法都属于静态对象。在外部调用静态方法时,可以使用"类名.方法名"的方式,也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说,调用静态...

    Java静态变量、静态常量、静态方法

           静态变量和静态方法都属于静态对象。在外部调用静态方法时,可以使用"类名.方法名"的方式,也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说,调用静态方法可以无需创建对象。

    1、Java静态对象和非静态对象的区别

                                            静态对象                                                       非静态对象     
    拥有属性:               是类共同拥有的                                            是类各对象独立拥有的
    内存分配:              内存空间上是固定的                                      空间在各个附属类里面分配 
    分配顺序:              先分配静态对象的空间                    继而再对非静态对象分配空间,也就是        初始化顺序是先静态再非静态。

    2、Java静态对象的特点

    A,静态对象的数据在全局是唯一的,一改都改。如果你想要处理的东西是整个程序中唯一的,弄成静态是个好方法。非静态的东西你修改以后只是修改了他自己的数据,但是不会影响其他同类对象的数据。 
    B,引用方便。直接用类名.静态方法名  或者  类名.静态变量名就可引用并且直接可以修改其属性值,不用get和set方法。
    C,保持数据的唯一性。此数据全局都是唯一的,修改他的任何一处地方,在程序所有使用到的地方都将会体现到这些数据的修改。有效减少多余的浪费。

    D,static final用来修饰成员变量和成员方法,可简单理解为“全局常量”。对于变量,表示一旦给值就不可修改;对于方法,表示不可覆盖。

    3、静态变量、静态方法和静态块

           通常情况下,类成员必须通过它的类的对象访问,但是可以创建这样一个成员,它能够被它自己使用,而不必引用特定的实例。在成员的声明前面加上关键字static就能创建这样的成员。如果一个成员被声明为static,它就能够在它的类的任何对象创建之前被访问,而不必引用任何对象(跟类是否有static修饰无关)。

           你可以将方法和变量都声明为static。static 成员的最常见的 例子是main( ) 。声明为static的方法有以下几条限制: ·

    A,它们仅能调用其他的static 方法

    B,它们只能访问static数据

    C,它们不能以任何方式引用this 或super(this涉及到对象,super 与继承有关)

           示例:Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法,一些static变量,以及一个static 初始化块。

    1. public class TestNew {  
    2.     static int a = 3;  
    3.     static int b;  
    4.     static void meth(int x){  
    5.         System.out.println("x = "+x);  
    6.         System.out.println("a = "+a);  
    7.         System.out.println("b = "+b);  
    8.     }  
    9.     static {  
    10.         System.out.println("static block initialized");  
    11.         b = a*4;  
    12.     }  
    13.     public static void main(String[] args) {  
    14.         // TODO Auto-generated method stub  
    15.         meth(42);  
    16.     }  
    17. }  

           执行结果是:

    static blockinitialized
    x = 42
    a = 3
    b = 12

    上述classTestNew的执行顺序是:首先static 块执行(打印一条消息),a被设置为3,最后b被初始化为a*4 成12。然后调用main(),main () 调用meth() ,把值42传递给x。3个println ( ) 语句引用两个static变量a和b,以及局部变量x 。

    4、外部使用静态变量或者静态方法

           在定义它们的类的外面,static方法和变量能独立于任何对象而被使用,你只要在类的名字后面加点号运算符即可。可以看到,这种格式与通过对象引用变量调用非static方法或者变量的格式类似。示例:

    1. class StaticDemo{  
    2.     static int a = 42;  
    3.     static int b = 99;  
    4.     static void callme(){  
    5.         System.out.println("a = "+a);  
    6.     }  
    7. }  
    8. public class TestNew {  
    9.     public static void main(String[] args) {  
    10.         // TODO Auto-generated method stub  
    11.         StaticDemo.callme();  
    12.         System.out.println("b = "+StaticDemo.b);  
    13.     }  
    14. }  

         执行结果:

    a = 42
    b = 99

    5、静态内部类

    静态内部类是指在一个类的内部,又定义了一个用static修饰的类。

    A,首先,用内部类是因为内部类与所在外部类有一定的关系,往往只有该外部类调用此内部类。所以没有必要专门用一个Java文件存放这个类。

    B,静态方法、静态成员变量。它唯一的作用就是随着类的加载(而不是随着对象的产生)而产生,以致可以用类名+静态成员名直接获得。这样静态内部类就可以理解了,它可以直接被用外部类名+内部类名获得。

    publicclass Build {

          ..............

        public static class VERSION {

               ................

               public static final String RELEASE =getString("ro.build.version.release");

               ................

         }

         ................

    }

    在外部可以直接通过Build.VERSION.RELEASE来访问。

    6、静态常量

    静态常量不可变,可以直接被访问,如类名.静态常量名。例如:

    public class MathTest{

       public static final double PI= 3.1415926;

    }

    可以直接采用MathTest.PI的形式访问该PI常量。

     

     

    展开全文
  • Java静态域与静态方法

    千次阅读 2017-08-04 16:01:14
    Java静态域与静态方法@(JAVA)[java]在Java中,静态修饰符static只能用于类的成员变量与成员方法。(一)静态域1、静态变量如果将某个变量定义为static,那么这个类及其所有对象共享同一个值,它在内存中只存在一份,...
  • Java静态导入

    千次阅读 2016-06-02 15:21:51
    Java静态导入 静态导入是JDK5.0引入的新特性 要使用静态成员(方法和变量)我们必须给出提供这个静态成员的类,使用静态导入可以使被导入类的静态变量和静态方法在当前类直接可见,使用这些静态成员无需再给出他们的...
  • Java 静态代理

    万次阅读 2019-12-09 13:53:40
    1)、静态代理。 在程序运行前,代理类的.class文件已存在。事先知道要代理的实现类是什么。 优点:不需要知道委托类(实现类),只需知道代理类即可。 缺点:(1)代码重复。代理类和委托类(实现类)实现了相同...
  • Java静态引入

    千次阅读 2019-03-14 08:54:16
    为什么Java需要静态引入? 静态引入是什么?
  • java静态代码检查工具

    2016-02-01 05:35:40
    推荐一款java静态代码检查的工具,可以java nullpointer exception静态检查,可以实现检查是否有抛空指针异常的可能性,便于解决代码中更多空指针异常的问题
  • java 静态内部类的使用

    万次阅读 2018-11-05 19:06:39
    java 静态内部类的使用
  • Java静态对象和非静态对象有什么区别?? 对于静态方法,相信它的作用在各位朋友眼里也是不容置疑的,那么他跟非静态到底有什么区别呢??? 到底有什么好处呢??对于静态方法来说~
  • 首先我们看下RecyclerView的ViewHolder...java静态内部类: static class EndViewHolder extends BlocksView.ViewHolder { public EndViewHolder(View itemView) { super(itemView); itemView.setMinimumHeight
  • 编译java静态库,java共享库

    千次阅读 2017-02-17 18:27:09
    把这段复制到app下的Android.mk的最后,可以编译出java共享库,这个.jar除了生成在\out\target\common\obj\JAVA_LIBRARIES这里,还会copy到\out\target\product\***\system\framework下,如果只是使用java静态库,...
  • java静态类读取配置文件内容

    千次阅读 2016-12-15 16:55:30
    java静态类读取配置文件内容
  • Java静态代码块和静态方法的区别

    千次阅读 2017-07-06 10:41:16
    (一)Java 静态代码块 静态方法区别 一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的...
  • java静态变量和静态方法优缺点

    千次阅读 2018-01-22 16:24:10
    java静态变量和静态方法会在程序初始化运行时候就加载到内存。优点:不需要在进行实例化。静态变量的值,直接赋新值即可,不需要参数传递,之后可以直接进行参数引用即可;静态方法可以直接通过"类名.方法"...
  • JAVA静态变量

    千次阅读 2020-02-11 12:17:59
    1.Java 中的 static 使用之静态变量 Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问...
  • Java静态变量使用实例

    万次阅读 2018-10-19 10:18:34
    一、Java 中被 static 修饰的成员称为静态成员或类成员 二、它属于整个类所有,而不是某个对象所有,即被类的所有对象共享。 三、静态成员可以使用类名直接访问,也可以使用对象名进行访问 1.贴一个统计字符串的小...
  • Java静态代码块和静态属性加载顺序

    千次阅读 2019-04-11 17:37:26
    Java静态代码块、静态属性、构造函数加载顺序 代码实例 //父类 public class B { public static B t1 = new B(); public static B t2 = new B(); public B(){ super(); System.out.println("B类构造块"); } ...
  • jsp中调用java静态常量

    千次阅读 2018-11-06 11:12:04
    1. 在普通的jsp代码中嵌入java静态常量 1.1 在页面开头引入该静态常量所在的类: &lt;%@page import="com.XXX.XXXX"%&gt; 1.2 在HTML片段中使用该静态常量: &lt;option value="&...
  • Java静态

    千次阅读 2018-09-06 16:48:07
    Java世界里,经常被提到静态这个概念,static作为静态成员变量和成员函数的修饰符,意味着它为该类的所有实例所共享, 也就是说当某个类的实例修改了该静态成员变量,其修改值为该类的其它所有实例所见。...
  • Java静态方法的同步锁

    2015-10-20 14:19:39
    Java静态方法的同步锁必须是字节码class吗?可以是static对象吗?
  • Java静态方法(类方法)的继承

    千次阅读 2018-01-29 19:55:52
    Java静态方法、静态变量是可以被继承的 背景:最近因为个人工作的原因,转战到Java领域。在学习过程中发现,网上有关Java静态继承,都说不能继承,且子类静态方法重写说成是隐藏了父类方法云云的。 下面我来...
  • Java静态属性和方法的继承问题

    千次阅读 2016-06-01 13:46:03
    Java静态属性和静态方法继承的一个总结。
  • java 静态资源访问详解

    千次阅读 2018-06-10 05:01:30
    java 静态资源访问详解一、java project项目如果工程项目是java project的话获取资源文件1、如果是在本工程根目录下直接访问1FileReader fr = new FileReader("config.properties"); 2、也可以直接根据...
  • Java静态代理

    千次阅读 2019-05-01 21:02:20
    在使用Runnable接口实现多线程的时候,启动必须借助Thread对象,我们将这个Thread对象称之为代理对象(静态代理)。在开发中一般用于记录日志、增强服务等,其对应的是动态代理,后面再行学习。
  • Java静态代码分析工具Infer

    千次阅读 2015-06-13 21:39:45
    Java静态代码分析工具Infer作者:chszs,转载需注明。博客主页:http://blog.csdn.net/chszs一、Infer介绍Infer是Facebook最新开源的静态程序分析工具,用于在发布移动应用之前对代码进行分析,找出潜在的问题。目前...
  • JAVA静态方法中只能调用静态成员。 main方法是静态方法,如果想调用其它的方法,只能是其它的静态方法。 public class Test{ public static void main(String[] args) { fangFa(100,100); //这里直接调用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,106,813
精华内容 442,725
关键字:

java静态

java 订阅