java 修饰符全解

1、类的修饰符分为：可访问控制符和非访问控制符两种。

可访问控制符是：公共类修饰符 public

非访问控制符有：抽象类修饰符 abstract ；最终类修饰符 final

1 ）公共类修饰符 public ： Java 语言中类的可访问控制符只有一个： public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工具供其它类和程序使用的应定义为 public 类。

2 ）抽象类修饰符 abstract ：凡是用 abstract 修饰符修饰的类，被称为抽象类。所谓抽象类是指这种类没有具体对象的一种概念类。这样的类就是 Java 语言的 abstract 类。

3 ） 最终类修饰符 final ：当一个类不可能有子类时可用修饰符 final 把它说明为最终类。被定义为 final 的类通常是一些有固定作用、用来完成某种标准功能的类。

4 ）类缺省访问控制符：如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。此时，这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。

2 ．域的控制修饰符也分为：可访问控制符和非访问控制符两类。

可访问控制符有 4 种：公共访问控制符： public ；私有访问控制符： private ；保护访问控制符： protected ；私有保护访问控制符： private protected

非访问控制符有 4 种：静态域修饰符： static ；最终域修饰符： final ；易失 ( 共享 ) 域修饰符： volatile ；暂时性域修饰符： transient

1 ）公共访问控制符 public ：用 public 修饰的域称为公共域。如果公共域属于一个公共类，则可以被所有其它类所引用。由于 public 修饰符会降低运行的安全性和数据的封装性，所以一般应减少 public 域的使用。

2 ）私有访问控制符 private ： 用 private 修饰的成员变量 ( 域 ) 只能被该类自身所访问，而不能被任何其它类 ( 包括子类 ) 所引用。

3 ）保护访问控制符 protected ：用 protected 修饰的成员变量可以被三种类所引用：①该类自身；②与它在同一个包中的其它类；③在其它包中的该类的子类。使用修饰符 protected 的主要作用是允许其它包中它的子类来访问父类的特定属性。

4 ）私有保护访问控制符 private protected ：用修饰符 private protected 修饰的成员变量可以被该类本身或该类的子类两种类访问和引用。

5 ）静态域修饰符 static ：用 static 修饰的成员变量仅属于类的变量，而不属于任何一个具体的对象，静态成员变量的值是保存在类的内存区域的公共存储单元，而不是保存在某一个对象的内存区间。任何一个类的对象访问它时取到的都是相同的数据；任何一个类的对象修改它时 , 也都是对同一个内存单元进行操作。

6 ）最终域修饰符 final ：最终域修饰符 final 是用来定义符号常量的。一个类的域 ( 成员变量 ) 如果被修饰符 final 说明，则它的取值在程序的整个执行过程中都是不变的。

7 ）易失 ( 共享 ) 域修饰符 volatile ：易失 ( 共享 ) 域修饰符 volatile 是用来说明这个成员变量可能被几个线程所控制和修改。也就是说在程序运行过程中，这个成员变量有可能被其它的程序影响或改变它的取值。因此，在使用中要注意这种成员变量取值的变化。通常 volatile 用来修饰接受外部输入的域。

8 ）暂时性域修饰符 transient ：暂时性域修饰符 transient 用来定义一个暂时性变量。其特点是：用修饰符 transient 限定的暂时性变量，将指定 Java 虚拟机认定该暂时性变量不属于永久状态，以实现不同对象的存档功能。否则，类中所有变量都是对象的永久状态的一部分，存储对象时必须同时保存这些变量。

3 ．方法的控制修饰符也分为：可访问控制符和非访问控制符两类。

可访问控制符有 4 种：公共访问控制符： public ；私有访问控制符： private ；保护访问控制符： protected ；私有保护访问控制符： private protected

非访问控制符有 5 种：抽象方法控制符： abstract ；静态方法控制符： static ；最终方法控制符： final ；本地方法控制符： native ；同步方法控制符： synchronized

1 ）抽象方法控制符 abstract ：用修饰符 abstract 修饰的方法称为抽象方法。抽象方法是一种仅有方法头，没有方法体和操作实现的一种方法。

2 ）静态方法控制符 static ：用修饰符 static 修饰的方法称为静态方法。静态方法是属于整个类的类方法；而不使用 static 修饰、限定的方法是属于某个具体类对象的方法。 由于 static 方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员变量，而只能处理属于整个类的成员变量，即 static 方法只能处理 static 的域。

3 ）最终方法控制符 final ：用修饰符 final 修饰的方法称为最终方法。最终方法是功能和内部语句不能更改的方法，即最终方法不能重载。这样，就固定了这个方法所具有的功能和操作，防止当前类的子类对父类关键方法的错误定义，保证了程序的安全性和正确性。所有被 private 修饰符限定为私有的方法，以及所有包含在 final 类 ( 最终类 ) 中的方法，都被认为是最终方法。

4 ）本地方法控制符 native ：用修饰符 native 修饰的方法称为本地方法。为了提高程序的运行速度，需要用其它的高级语言书写程序的方法体，那么该方法可定义为本地方法用修饰符 native 来修饰；

5 ）同步方法控制符 synchronized ：该修饰符主要用于多线程共存的程序中的协调和同步。

关于Java中各种修饰符与访问修饰符的说明

类：

访问修饰符  修饰符  class  类名称  extends  父类名称 implement  接口名称

（访问修饰符与修饰符的位置可以互换）

访问修饰符
名称	说明	备注
public	可以被所有类访问（使用）	public 类必须定义在和类名相同的同名文件中
package	可以被同一个包中的类访问（使用）	默认的访问权限，可以省略此关键字，可以定义在和public 类的同一个文件中

修饰符
名称	说明	备注
final	使用此修饰符的类不能够被继承
abstract	如果要使用abstract 类，之前必须首先建一个继承abstract 类的新类，新类中实现abstract 类中的抽象方法。	类只要有一个abstract 方法，类就必须定义为abstract ，但abstract 类不一定非要保护abstract 方法不可

变量

l         Java 中没有全局变量，只有方法变量、实例变量（类中的非静态变量）、类变量（类中的静态变量）。

l          方法中的变量不能够有访问修饰符。所以下面访问修饰符表仅针对于在类中定义的变量。

l          声明实例变量时，如果没有赋初值，将被初始化为null （引用类型）或者0 、false （原始类型）。

l          可以通过实例变量初始化器来初始化较复杂的实例变量，实例变量初始化器是一个用{} 包含的语句块，在类的构造器被调用时运行，运行于父类构造器之后，构造器之前。

l          类变量（静态变量）也可以通过类变量初始化器来进行初始化，类变量初始化器是一个用static{} 包含的语句块，只可能被初始化一次。

访问修饰符
名称	说明	备注
public	可以被任何类访问
protected	可以被同一包中的所有类访问 可以被所有子类访问	子类没有在同一包中也可以访问
private	只能够被当前类的方法访问
缺省 无访问修饰符	可以被同一包中的所有类访问	如果子类没有在同一个包中，也不能访问

修饰符
名称	说明	备注
static	静态变量（又称为类变量，其它的称为实例变量）	可以被类的所有实例共享。 并不需要创建类的实例就可以访问静态变量
final	常量，值只能够分配一次，不能更改	注意不要使用const ，虽然它和C 、C++ 中的const 关键字含义一样 可以同static 一起使用，避免对类的每个实例维护一个拷贝
transient	告诉编译器，在类对象序列化的时候，此变量不需要持久保存	主要是因为改变量可以通过其它变量来得到，使用它是为了性能的问题
volatile	指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理

方法

访问修饰符  修饰符  返回类型 方法名称（ 参数列表 ） throws  违例列表

l          类的构造器方法不能够有修饰符、返回类型和throws 子句

l          类的构造器方法被调用时，它首先调用父类的构造器方法，然后运行实例变量和静态变量的初始化器，然后才运行构造器本身。

l          如果构造器方法没有显示的调用一个父类的构造器，那么编译器会自动为它加上一个默认的super() ，而如果父类又没有默认的无参数构造器，编译器就会报错。super 必须是构造器方法的第一个子句。

l          注意理解private 构造器方法的使用技巧。

访问修饰符
名称	说明	备注
public	可以从所有类访问
protected	可以被同一包中的所有类访问 可以被所有子类访问	子类没有在同一包中也可以访问
private	只能够被当前类的方法访问
缺省 无访问修饰符	可以被同一包中的所有类访问	如果子类没有在同一个包中，也不能访问

修饰符
名称	说明	备注
static	静态方法（又称为类方法，其它的称为实例方法）	提供不依赖于类实例的服务 并不需要创建类的实例就可以访问静态方法
final	防止任何子类重载该方法	注意不要使用const ，虽然它和C 、C++ 中的const 关键字含义一样 可以同static 一起使用，避免对类的每个实例维护一个拷贝
abstract	抽象方法，类中已声明而没有实现的方法	不能将static 方法、final 方法或者类的构造器方法声明为abstract
native	用该修饰符定义的方法在类中没有实现，而大多数情况下该方法的实现是用C 、C++ 编写的。	参见Sun 的Java Native 接口（JNI ），JNI 提供了运行时加载一个native 方法的实现，并将其于一个Java 类关联的功能
synchronized	多线程的支持	当一个此方法被调用时，没有其它线程能够调用该方法，其它的synchronized 方法也不能调用该方法，直到该方法返回

接口

访问修饰符  interface  接口名称  extends  接口列表

l          接口不能够定义其声明的方法的任何实现

l          接口中的变量总是需要定义为“public static final  接口名称”，但可以不包含这些修饰符，编译器默认就是这样，显示的包含修饰符主要是为了程序清晰

访问修饰符
名称	说明	备注
public	所有
无访问修饰符（默认）	同一个包内

.

JAVA 修饰符public final static abstract transient

关键字: public final static abstract ...

1.public protected default private 组 

位置            private 默认 protected   public 
同一个类               是 是 是     是 
同一个包内的类    否 是 是     是 
不同包内的子类    否 否 是     是 
不同包并且不是子类    否 否 否     是 

public 访问权限最高,不论是不是同一个包或是否是子类 都可以访问 
protected 其次只有是不同包且不是子类的无法访问外，其它均可 
默认级别 次之,要求只能是同一个包中的类才能访问 
private 只能是同一个类才能访问 

这些修饰符可以修饰方法或者属性，但是类只能用public 或者不写. 

Java代码  

1. package test;  
2.   
3. //访问修饰符的使用  
4. public class PublicClass{  
5.   
6.          public String publicVariable = "publicVariable" ;  
7.          private String privateVar = "private var";  
8.          protected String protectedVar ="protected var";  
9.          String defaultVar="defaultVar";  
10.   
11.          private void showPrivate(){  
12.                    System.out.println("Nobody will access!");  
13.               }  
14.   
15.          public void showPublic(){  
16.                    System.out.println("showPublic method!");  
17.               }  
18.   
19.          public void showProtected(){  
20.                    System.out.println("Show protected method!");  
21.               }  
22.   
23.          void showDefault(){  
24.                    System.out.println("Show default method!");  
25.               }  
26.      }  

Java代码  

1. package test;  
2.   
3. //import test.PublicClass;  
4. class Test{  
5.          private String var =" private variable in class-Test!";  
6.            
7.          public static void main(String args[]){  
8.                    Test t = new Test();  
9.                    PublicClass pClass = new PublicClass();  
10.                    //另外一个类中的共有属性和方法是可以被外界所访问的  
11.                    System.out.println("可以访问到的资源属性:"+pClass.publicVariable);//可访问  
12.                    pClass.showPublic();       // 可访问  
13.                    /* 
14.                     *以下两条编译错误，在另外一个类中的私有方法是访问不到的 
15.                     **/  
16.                    //System.out.println("可以访问到的资源属性:"+pClass.privateVariable );     //不能访问  
17.               //   pClass.showPrivate();       //不能访问  
18.              //私有变量自己可以访问  
19.               System.out.println("私有变量自己可以访问"+t.var);  
20.             //protected 成员可以被该类的成员和子类的成员访问。  
21.               // 还可以被同一个包中内的其他类成员访问  
22.               System.out.println("可以访问到的资源属性:"+pClass.protectedVar);//可访问  
23.               pClass.showProtected();//可访问  
24.               System.out.println("可以访问到的资源属性:"+pClass.defaultVar);//可访问  
25.               pClass.showDefault();//可访问  
26.               }  
27.      }  

2. final 修饰符 
        final 具有 不可更改的意思，它可以修饰非抽象类，非抽象成员方法和变量。 
        用 final 修饰的类不能被继承，没有子类 如 String 
       用 final 修饰的方法不能被子类的方法覆盖 
        用 final 修饰的变量表示常量，只能被赋值一次 
        用 final 不能修饰构造方法，因为方法覆盖这一概念仅适用于类的成员方法，而不适用于类的构造方法，父类的构造方法和子类的构造方法之间不存在覆盖关系，因此用 final 修饰构造方法是豪无意义的。 

        父类中用 private 修饰的方法不能被子类的方法覆盖，因此 private 类型的方法默认是 final 类型的。 
        
final 类 
        String  类 ，不让继承，封装实现的细节。 

final 方法 
        在某些情况下，出于安全的原因，父类不允许子类覆盖某个方法，此时可以把这个方法声明为 finnal 类型。java.lang.Object 类，getClass（）为 final 类型，equals（）不为 final 类型。   

final 变量 
        用 final 修饰的变量表示取值不会改变的常量。 
        final 修饰符可以修饰静态变量，实例变量和局部变量，分别表示静态常量，实例常量和局部常量。 

        例如 出生日期，年龄的限制等。 
        final 变量都必须显示初始化，否则会导致编译错误。 
        final 变量只能被赋值一次。 
  
在程序中使用 final 修饰符来定义常量的作用 
        提高程序的安全性，禁止非法修改取值固定并且不允许修改的数据 
        提高程序代码的可维护性。 


3.transient 关键字 
   首先是JAVA的序列化，简单来说就是将某一个类存储以文件形式存储在物理空间，下次再从本地还原的时候，还可以将它转换回来，这种形式便利了网络上的一些操作。 

   序列化只能保存对象的非静态成员交量，不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符都不能保存。 

   以文件形式描述某些信息时，容易涉及到安全问题，因为数据位于Java运行环境之外，不在Java安全机制的控制之中。对于这些需要保密的字段，不应保存在永久介质中 ，或者不应简单地不加处理地保存下来 ，为了保证安全性。应该在这些字段前加上transient关键字。 它的意思是临时的，即不会随类一起序列化到本地，所以当还原后，这个关键字定义的变量也就不再存在。 

如果TransTest 类的一个对象被序列化，i的内容不被保存，但j的将被保存。 

Java代码  

1. class TransTest {     
2.   transient int i;   //不需要保存     
3.    int j;            //需要保存     
4.     

4. volatile关键字 不常用 

Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。 

这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。 

而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。 

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。 

由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。 


5.Synchronize 关键字 
   先提出问题，如果开启多线程同时操作同一实例变量，Thread-0线程从主内存中取出的值a 为 1，然后a++;  Thread-1线程也从主内存中取出的值 a 进行 a+=2操作;Thread-0存入2到主内存中，Thread-1也存入，这样就覆盖了Thread-0存入的值. 
  
   原因是在JAVA 的内存模型中，是每一个进程都有一个主内存，每个线程都有自己的内存，线程从主内存取得数据，计算后再存回到主内存中. 

   解决这个问题就可以使用 synchronize关键字. 
   使用synchronized修饰此方法后，把下面的这几个步骤当作一个原子操作:取数据，操作数据，存数据。原子操作是不能够被打断的，所以就保证了数据的一致性，这样在同一时间有线程再执行，虽然在效率上比较有影响，但是能够保证在同一时间只有一个线程能够访问到这一块内存单元。 

6.static 关键字 
    static 修饰符可以用来修饰类的成员变量，成员方法和代码块。 
        用 static 修饰的成员变量表示静态变量，可以直接通过类来访问。 
        用 static 修饰的成员方法表示静态方法，可以直接通过类名来访问。 
        用 static 修饰的程序代码块表示静态代码块，当JAVA虚拟机加载类时，就会执行该代码块。 
        被 static 所修饰的成员变量和成员方法标明归某个类所有，它不依赖于类的特定实例，被类的所有实例共享。只要这个类被加载，JAVA虚拟机就能根据类名在运行时数据区的方法区定位到它们。 

     static 变量 
     类的成员变量有两种，一个是实例变量，没有被 static 修饰，一种是被 static 修饰过的变量，叫类变量或者静态变量。 

     静态变量和实例变量的 区别：  
     静态变量在内存中只有一个拷贝，运行时JAVA虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。可以直接通过类名访问静态变量。 
     对于实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响。 

      static 方法 
      成员方法分为静态方法和实例方法。用 static 修饰的方法叫做静态方法，或者类方法。静态方法和静态变量一样，不需要创建类的实例，可以直接通过类名来访问。 

      因为静态方法不需要通过它所属的类的任何实例就会被调用，因此在静态方法中不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。 

Java代码  

1.         
2. class StaticTest{  
3.   
4.         static int num =100;  
5.         int num1 = 20;  
6.   
7.         static void staticMethod(){  
8.            System.out.println("StaticMethod!");  
9.            //System.out.println(this.num); //编译错误，在static 方法内，不能使用this 关键字  
10.               //System.out.println(this.num1);//编译错误，在static 方法内，不能使用this 关键字  
11.              //   System.out.println(num1);//编译错误，在static 方法内，不能直接访问非 static 变量或者方法  
12.   
13.             System.out.println(StaticTest.num);  
14.         }  
15.               
16.           void LocalMethod(){  
17.                        System.out.println("StaticMethod!");  
18.            }  
19.   
20.                      
21.   
22.               public static void main(String args[]){  
23.                        StaticTest t = new StaticTest();  
24.   
25.                        //静态变量被所有的实例共享  
26.                           t.staticMethod();  
27.                        System.out.println(t.num);  
28.                        StaticTest.staticMethod();  
29.                        System.out.println(StaticTest.num);  
30.                    }  
31.         }  
32.   
33.       //  总结：在静态方法内不允许访问非静态变量 不能出现 this 和 supper   

      static 代码块 
      类中可以包含静态代码块，它不存在于任何方法体中。在JAVA虚拟机加载类时会执行这些静态代码块。如果类中包含多个静态块，那么JAVA虚拟机将按照他们在类中出现的顺序依次执行它，并且每个代码块只会被执行一次。 
        

Java代码  

1. class StaticBlock{  
2.   
3.              static int i =5;  
4.              int j;  
5.              static{  
6.                       System.out.println("First :"+i++);  
7.                   }  
8.   
9.              static{  
10.                       System.out.println("Sencond :" +i++);  
11.                   }  
12.                   
13.              public static void main(String args[]){  
14.                       StaticBlock s1 = new StaticBlock();  
15.                       StaticBlock s2 = new StaticBlock();  
16.                       System.out.println("Last :"+i);  
17.                   }  
18.        }  

      静态方法必须被实现 
      静态方法用来表示某个类所特有的功能，这种功能的实现不依赖于类的具体实例，也不依赖于它的子类。既然如此，当前类必须为静态方法提供实现，即一个静态的方法不能被定义为抽象方法。 

      static 和 abstract 永远不能放在一起用 

      如果一个方法是静态的，它就必须自力更生，自己实现该方法。 
      如果一个方法是抽象的，那么它就只表示类所具有的功能，但不会去实现它，在子类中才会去实现它。 

        作为程序入口的 main() 方法是静态方法 

        因为把 main() 方法定义为静态方法，可以使得JAVA虚拟机只要加载了 main 方法所属的类，就能执行 main() 方法，而无须创建这个类的实例。 

        在 main() 方法中不能直接访问实例变量和实例方法。 

7.abstract 修饰符 
        abstract 修饰符可以用来修饰类和成员方法 

        用 abstract 修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化，即不允许创建抽象类本身的实例。没有用 abstract 修饰的类称为具体类，具体类可以被实例化。 

        用 abstract 修饰的方法表示抽象方法，抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现。没有用 abstract 修饰的方法称为具体方法，具体方法具有方法体。 

        abstract 语法规则： 

        抽象类可以没有抽象方法，但包括了抽象方法的类必须被定义为抽象类。如果子类没有实现父类中所有的抽象方法，那么子类也必须被定义为抽象类。 
        
以下一个父类 

Java代码  

1. package test;  
2.   
3. //抽象类  
4.   
5. abstract class Shape{  
6.   
7. //受保护的属性  
8.      protected double length;  
9.     protected double width;  
10.        
11.     //构造方法  
12.      Shape(double num1,double num2){  
13.                this.length = num1;  
14.                this.width = num2;  
15.        }               
16.      //定义了一个抽象方法，方法体为空，只要有类继承就必须实现这个抽象方法，否则子类也必须声明为抽象类  
17.      abstract double area();            
18. }  

其中一个抽象方法 abstract double area(); 

现有一子类去实现这个父类，会出现什么情况？ 

Java代码  

1. package test;  
2.   
3. //子类继承父类  
4. class Square extends Shape{  
5.   
6.             Square(double num1,double num2){  
7.                   super(num1,num2);  
8.                }  
9. }  

ERROR！！！ 


父类有一抽象方法 abstract double area(); 

子类必须去实现，否则本身也只能为抽象类。 

所以，要么： 

Java代码  

1. package test;  
2.   
3.  //子类继承父类  
4.   
5. class Square extends Shape{  
6.   
7.             Square(double num1,double num2){  
8.                    super(num1,num2);  
9.                }  
10.   
11.             //实现抽象方法  
12.             double area(){  
13.                    System.out.println("正方形的面积为: ");  
14.                    return length*width;  
15.                }  
16. }  

要么： 

Java代码  

1. package test;  
2. //子类继承父类  
3. abstract class Square extends Shape{  
4.   
5.         Square(double num1,double num2){  
6.                    super(num1,num2);  
7.                }  
8. }  

没有抽象构造方法，也没有抽象静态方法。 

Java代码  

1. abstract class Base{  
2.     abstract Base() ;// 编译出错，构造方法不能是抽象的  
3.     static abstract void method() ;//编译出错， static 和 abstract 不能连用  
4.      static void method2(); //合法  
5. }  

    
抽象类中可以有非抽象的构造方法，创建子类的实例时可能会调用这些构造方法。抽象类不能被实例化，然而可以创建一个引用变量，其类型是一个抽象类，并让它引用非抽象的子类的一个实例。 

     

Java代码  

1. abstract class Base{}  
2.   
3.       class Sub extends Base{  
4.          public static void main(String args[]){  
5.           Base base1 = new Base (); //编译出错，不能创建抽象类B ase 的实例  
6.           Base base1 = new Sub(); // 合法，可以创建具体类Sub 的实例  
7.   
8.       }}  

        抽象类及抽象方法不能被 final 修饰符修饰。因为抽象类只允许创建子类，它的抽象方法才能被实现，并且只有它的具体子类才能被实例化，而用final 修饰的类不允许拥有子类，用 final 修饰的方法不允许被子类方法覆盖，因此把abstract 修饰符与 final 修饰符连用，会导致自相矛盾。 

.

.

.

转载于:https://www.cnblogs.com/leokou/archive/2011/06/30/2094282.html