精华内容
下载资源
问答
  • Java静态类

    千次阅读 2018-09-06 16:48:07
    Java世界里,经常被提到静态这个...最近一个项目里频繁用到static修饰的内部类,再读了一下 《Effective Java》才明白为什么会用static来修饰一个内部类也就是本文的中心——静态类。  如果一个类要被声明为s...

      在Java世界里,经常被提到静态这个概念,static作为静态成员变量和成员函数的修饰符,意味着它为该类的所有实例所共享, 也就是说当某个类的实例修改了该静态成员变量,其修改值为该类的其它所有实例所见。最近一个项目里频繁用到static修饰的内部类,再读了一下 《Effective Java》才明白为什么会用static来修饰一个内部类也就是本文的中心——静态类。

      如果一个类要被声明为static的,只有一种情况,就是静态内部类。如果在外部类声明为static,程序会编译都不会过。在一番调查后个人总结出了3点关于内部类和静态内部类(俗称:内嵌类)

    1.静态内部类跟静态方法一样,只能访问静态的成员变量和方法,不能访问非静态的方法和属性,但是普通内部类可以访问任意外部类的成员变量和方法

     

    2.静态内部类可以声明普通成员变量和方法,而普通内部类不能声明static成员变量和方法。

     

    3.静态内部类可以单独初始化: 

    Inner i = new Outer.Inner();

     普通内部类初始化:

    Outer o = new Outer();
    Inner i = o.new Inner();

     

      静态内部类使用场景一般是当外部类需要使用内部类,而内部类无需外部类资源,并且内部类可以单独创建的时候会考虑采用静态内部类的设计,在知道如何初始化静态内部类,在《Effective Java》第二章所描述的静态内部类builder阐述了如何使用静态内部类:

    复制代码

    public class Outer {
        private String name;
        private int age;
    
        public static class Builder {
            private String name;
            private int age;
    
            public Builder(int age) {
                this.age = age;
            }
    
            public Builder withName(String name) {
                this.name = name;
                return this;
            }
    
            public Builder withAge(int age) {
                this.age = age;
                return this;
            }
    
            public Outer build() {
                return new Outer(this);
            }
        }
    
        private Outer(Builder b) {
            this.age = b.age;
            this.name = b.name;
        }
    }

    复制代码

    静态内部类调用外部类的构造函数,来构造外部类,由于静态内部类可以被单独初始化说有在外部就有以下实现:

    public Outer getOuter()
    {
        Outer outer = new Outer.Builder(2).withName("Yang Liu").build();
        return outer;
    }

     

    对于静态类总结是:1.如果类的构造器或静态工厂中有多个参数,设计这样类时,最好使用Builder模式,特别是当大多数参数都是可选的时候。

                                   2.如果现在不能确定参数的个数,最好一开始就使用构建器即Builder模式。

    原文链接:https://www.cnblogs.com/Alex--Yang/p/3386863.html

     

    展开全文
  • 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静态类读取配置文件内容

    千次阅读 2016-12-15 16:55:30
    java静态类读取配置文件内容

    说明一下,无需导入任何jar包,运用的是jdk自带的ClassLoader加载器,启动加载所有的配置文件内容。

    以下是具体的代码:

    配置文件:application.properties

    server.port=8095
    baidu.domain.name=www.baidu.com
    test.china=\u4E0D\u9519

    PropertyConstants加载配置文件,放入Properties 中
    package zjq.utils;
    
    import java.io.IOException;
    import java.util.Properties;
    
    public class PropertyConstants {
    	private static Properties properties;
    	
    	private static void setProperty(){
    		if (properties==null) {
    			properties = new Properties();
    			ClassLoader loader = Thread.currentThread().getContextClassLoader();
    			try {
    				properties.load(loader.getResourceAsStream("application.properties"));
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	
    	public static String getPropertiesKey(String key){
    		if (properties==null) {
    			setProperty();
    		}
    		return properties.getProperty(key, "default");
    	}
    }
    


    配置文件类,无需注解直接调用Constants 

    public class Constants {
    public static final String SERVER_PORT = PropertyConstants.getPropertiesKey("server.port");
    public static final String TEST_CHINA = PropertyConstants.getPropertiesKey("test.china");
    }

    以上就能实现静态调用配置文件,只需启动加载就行了。


    展开全文
  • 日常小结-java静态类及其应用

    千次阅读 2016-11-08 17:00:09
    概述静态类的三个主要特效、常用的使用方式以及设计思想。

    概述

    静态类必定是内部类,但内部了不一定是静态类。

    特性以及与非静态内部类的区别

    静态类的特效主要分为三点

    • 静态内部类只能访问静态成员和静态方法,普通的内部类可以访问任意方法。
    • 静态内部类可以声明静态方法,但是普通内部类不可以声明静态方法。静态内内部可以定义静态成员变量,但是普通类只能定义final static的静态变量。
    • 静态内部类的对象构造不依赖于外部类,而普通内部类在构造器必须先构造所依赖的外部类的对象。

    java静态类
    stataic class 静态类

    静态类的使用

    1. 静态类可以用来构建静态工厂方法。
      可以先构建一个静态内部类,然后设定参数,最后使用Builder模式构建外部类。
    2. 使用静态内部类实现具体功能,然后由外部类来代理。
      比如这两天看到的java中用队列同步器来构造锁的过程就是这样的实现。具体的之后会写一篇关于队列同步器的文章。

      静态类的存在总的来说可以当成一个独立的类,只不过是这个类可以访问外部类的一些权限。已一部分访问权限为代价换取类本身的独立性。有人认为静态类的存在优势在于在某些情况下,可以降低类的深度,使得软件本身更加简单些。当然也可以写一个独立的类来完成静态内部类的功能,但是这样做不仅复杂,而且还会使得其他无关的类也会引用这个静态内部类。变相的来说相当于一种注释,这个静态内部类只用于这个外部类

    为什么java要分内部类和静态内部类

    其实个人来看。内部类在很多时候都是为了降低包的复杂度的作用,因为java写着写着程序就会变得非常大。比如匿名内部类,也就通常只用这一次,不用再建个文件专门写。内部类,使用的权限更大,静态内部类,独立性更强,一定的使用权限。

    展开全文
  • Java静态类 Builder(建造者)模式

    千次阅读 2019-04-03 11:06:24
    Java世界里,经常被提到静态这个...最近一个项目里频繁用到static修饰的内部类,再读了一下《Effective Java》才明白为什么会用static来修饰一个内部类也就是本文的中心——静态类。 如果一个类要被声明为stat...
  • 原文:...为了理解static关键字在声明中的使用,首先我们需要了解声明。有两种类,一种是top-level class;一种是inner class。 Top-level class
  • java中的静态类

    万次阅读 多人点赞 2019-06-02 06:08:45
    java中的静态类Java世界里,经常被提到静态这个概念,static作为静态成员变量和成员函数的修饰符,意味着它为该类的所有实例所共享,也就是说当某个类的实例修改了该静态成员变量,其修改值为该类的其它所有实例...
  • Java中的静态类以及嵌套类

    千次阅读 2016-05-03 00:04:52
    原文地址: http://www.geeksforgeeks.org/static-class-in-java/ 在Java中类可以是静态的么? 在Java中类可以是静态的。在Java中有静态实例变量,静态方法,...在Java中不能使最顶层类为静态类,而只有嵌套的类可
  • Java静态类详解

    万次阅读 2019-05-06 20:43:11
    Java世界里,经常被提到静态这个...最近一个项目里频繁用到static修饰的内部类,再读了一下《Effective Java》才明白为什么会用static来修饰一个内部类也就是本文的中心——静态类。 如果一个类要被声明为stati...
  • Java中的静态类和非静态类

    千次阅读 2019-08-06 18:32:13
    一、静态类和非静态的定义 1、非静态 一、有名类 class Eat{//不可以直接在main方法中使用 必须创建对象 void sleep() { } } 二、匿名类 Example example =new Example() { }; 2、静态...
  • JAVA 静态内部用法

    千次阅读 2016-01-27 14:13:12
    Java静态内部(static class)   在一个中创建另外一个,叫做成员内部。这个成员内部可以静态的(利用static关键字修饰),也可以是非静态的。   一、静态内部的使用目的。 在 ...
  • JAVA中的静态类

    万次阅读 2019-07-01 15:04:19
    提到JAVA中的静态类,就要提到static这个修饰符,书中说明static作为 静态成员变量 和 成员函数(类中的方法) 的修饰符,注意两个字是“成员”。意味着它为该类的所有实例所共享,也就是说当某个类的实例修改了该...
  • java单例和静态类区别

    千次阅读 2017-04-10 14:15:39
    Java中单例与静态的区别? 静态类比单例具有更好的...静态类很难模拟,因此难于单例测试,单例更容易模拟,因为也比静态类易于编写单元测试,不论神马单例期望神马,你都可以传递模拟对象,例如构造方法或方法参数 如
  • java 静态内部的使用

    万次阅读 2018-11-05 19:06:39
    java 静态内部的使用
  • java静态类.静态方法 。类.方法。 静态类.方法。 对象.方法。他们之间的区别是什么?
  • Java静态类  在Java世界里,经常被提到静态这个概念,static作为静态成员变量和成员函数的修饰符,意味着它为该类的所有实例所共享,也就是说当某个类的实例修改了该静态成员变量,其修改值为该类的其它...
  • 它在实际开发中用的很少,它是在方法中定义的类,既然是方法里头的东西,那么它就不能定义静态类,静态变量或静态方法了,如图,编译器直接报错 它的申明不能用public和private、procted修饰,可以用final和...
  • 首先我们看下RecyclerView的ViewHolder...java静态内部: static class EndViewHolder extends BlocksView.ViewHolder { public EndViewHolder(View itemView) { super(itemView); itemView.setMinimumHeight
  • 最近遇到一个疑惑,为啥静态内部类不可以继承非静态内部类...如上图所以,要想new 非静态内部类,必须得有外部类的实例,我们都知道静态类、静态内部类、一切静态的东西都跟非静态无关系,因为虚拟机内存机制里面他们
  • Java static静态类处理和MAP取键值

    千次阅读 2016-07-19 10:27:56
    Java static静态类处理和MAP取键值
  • JAVA静态内部加载顺序

    千次阅读 2019-05-23 21:16:17
    今天偶然机会碰到了JAVA静态内部加载实例,原本以为和外部一样,但实验结果确出人意料,特此记录。希望大牛们能指出原因所在。 首先给上代码: public class LoadTest2 { public static class Inner{//...
  • java 静态内部和Builder模式

    千次阅读 2015-10-30 22:29:10
    java中可以在内部定义静态内部。可以用于构建多参数的对象,并且保证的一致性。 2. 与非静态内部内的区别 静态内部与非静态内部的区别如下: 在非静态内部中不可以声明静态成员。只有静态内部...
  • Java 静态内部作用

    千次阅读 2019-03-07 11:13:31
    所以没有必要专门用一个Java文件存放这个。 2)静态都是用来修饰的内部成员的。比如静态方法,静态成员变量,静态常量。它唯一的作用就是随着的加载(而不是随着对象的产生)而产生,以致可以用类名+静态成员...
  • JAVA的静态变量、静态方法、静态类

    万次阅读 多人点赞 2012-12-30 20:45:46
    静态变量和静态方法都属于静态对象,它与非静态对象的差别需要做个说明。 (1)Java静态对象和非静态对象有什么区别?  比对如下:  静态对象 非静态对象  拥有属性:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 915,557
精华内容 366,222
关键字:

java静态类

java 订阅