Java中权限设置

 1 package think_in_java_access_contorl;
 2
 3 import think_in_java_access_contorl.access.Cookie;
 4
 5 /**
 6  * 1.在Java编程思想中有一段很经典的话，明白就会解决很多问题：
 7  * --当编写一个Java源代码文件时，此文件通常被成为编译单元（有时也被称为转义单元）。每个
 8  * 个编译单元都必须有一个后缀名为.java，而在编译单元内则可以有一个public类，该类的名称必须
 9  * 与文件的名称相同（包括大小写，但不包括文件的后缀名.java）。每个编译单元只能有一个public类，否则编译器就不会接受。如果
10  * 该编译单元之中还有额外的类的话，那么在包之外世界是无法看见这些类的，这是因为他们不是public类，而且他们主要为主public类提供
11  * 支持。
12  *
13  *
14  * 这就解释了为什么，在同一个包下面，主类必须是public或者是默认的。但是我们可以定义别的类，但是这些类的权限是
15  * 默认的，为什么？因为他们在同一个包下面，必须使用默认的权限，而默认的权限就是在同一个包可见。
16  *
17  * 2.Java如何将可执行的字节码 文件加载进去
18  * Java可运行程序是一组可以打包并压缩为一个Java文档文件（jar,使用Java的jar文档生成器）的.class文件。Java解析器负责这些
19  * 文件的查找，装载和解释。
20  *
21  * 3.Java中为什么要使用域名的倒叙的形式命名包？
22  * 在编程思想中，为了让自己的包名独一无二，那么最有效的方法就是ip地址，就是独一无二的，而Java有主要进行的是企业级的开发，所以使用公司域名的倒叙来区分
23  * 包名。目的就在于此。
24  * */
25 public class Demo1 {
26
27     public static void main(String[] args) {
28         Cookie c=new Cookie();
29         //c.bite();由于访问权限，所以无法进行访问
30     }
31 }

 1 package think_in_java_access_contorl;
 2 /**
 3  * 私有构造器获得实例的方法：
 4  *     如果有一个私有的构造器，并且它的权限设置成为一个私用的权限；如果通过方法获得它的实例。
 5  *         因为它是私有的，所以权限只在它的类中。在程序的外部是不能进行new操作的，因为无法找到构造器。但是我们可以使用静态方法的形式，通过类名调用方法
 6  *         进行间接获得，它的实例。
 7  *
 8  * */
 9 public class Demo2_privateDemo_test {
10
11     public static void main(String[] args) {
12         Demo2_privateDemo pri= Demo2_privateDemo.make_Demo2_privateDemo();
13         pri.smile();
14     }
15 }

 1 package think_in_java_access_contorl;
 2
 3 public class Demo2_privateDemo {
 4
 5     private Demo2_privateDemo(){
 6         System.out.println("private 构造器，其他类不能访问！");
 7     }
 8
 9     public static  Demo2_privateDemo make_Demo2_privateDemo(){
10         return new Demo2_privateDemo();
11     }
12
13     public void smile(){
14         System.out.println("smile....");
15     }
16 }

 1 package think_in_java_access_contorl;
 2
 3 public class Demo3_protectedDemo_test extends Demo3_protectedDemo {
 4
 5     public static void main(String[] args) {
 6         Demo3_protectedDemo_test pro=new Demo3_protectedDemo_test();
 7         //这就是在外面的包下面只能是子类进行访问
 8         pro.protected_Demo();
 9         //为什么要这样设计？
10         //如果我们不设置protected_Demo()的权限，让他默认权限，那么我们在另外一个包中无法访问到这个方法
11         //我们可以修改权限为public 但是所有人都可以访问到了。我们就向让子类进行访问，其他的包下面无法访问，
12         //所以Java使用了关键字protected
13         //访问权限的控制这就是一种封装
14     }
15 }

 1 package think_in_java_access_contorl;
 2 /*
 3  * 注意这个protected其实就是为了继承而生的，他就是子类继承父类，父类给的专门的权限
 4  * 同一包下面的类当然可以访问他。
 5  * */
 6 public class Demo3_protectedDemo {
 7     protected void protected_Demo(){
 8         System.out.println("我是protected访问权限！");
 9     }
10 }

 1 package think_in_java_access_contorl;
 2
 3
 4  class Example{
 5
 6 }
 7  class Ha{
 8      public static void haha(){
 9          System.out.println("你好啊");
10      }
11  }
12  //注意这里是没有public 并且上面的类只能是默认的权限
13  class Demo4_Object_access_control_2{
14     public static void main(String[] args) {
15         System.out.println("amazing");
16         new Ha().haha();
17     }
18
19 }

 1 package think_in_java_access_contorl;
 2 /*
 3  * 单例设计模式（其实就是基于方法的访问权限和类的访问权限设计的模式）
 4  * */
 5
 6 class singleDemo1{
 7     private singleDemo1(){
 8
 9     }
10     //为什么这样设计之后，调用静态方法就可以获得同一个对象：首先，程序调用静态方法，类加载器就会把这个类的class文件加载到方法去并且
11     //创建一个Class对象，静态代码块，开辟一个有类相关信息的空间，指向的是singleDemo1的实例。
12     //而调用静态的single_example方法相当与指向了同一个singleDemo1的实例。
13     private static singleDemo1 single=new singleDemo1();
14     public static singleDemo1 single_example(){
15         return single;
16     }
17
18     public void method(){
19         System.out.println("我是单例设计模式哈哈哈！");
20     }
21 }
22
23 public class Demo4_Object_access_control_single_design_pattern {
24
25         public static void main(String[] args) {
26             //创建了一个单例子，最好理解访问权限的例子
27             singleDemo1 single=singleDemo1.single_example();
28             System.out.println(single);
29             single.method();
30             singleDemo1 single2=singleDemo1.single_example();
31             System.out.println(single2);
32             single2.method();
33 //            [email protected]
34 //            我是单例设计模式哈哈哈！
35 //            [email protected]
36             //注意这2个对象的地址一样的，说明都是这2个都是同一个都对象的引用，也就是说我们
37             //不管怎么样调用静态方法，它都是同一个对象
38         }
39 }

 1 package think_in_java_access_contorl;
 2
 3 public class Demo4_Object_access_control {
 4     //既然方法有访问权限，那么类也可以有访问权限：
 5     //设计者为什么设计一个类的访问权限只有2中，一个是public，一个是默认的权限？
 6     //--如果是public 那么都可以访问（本类，同一个包下，外面的包，继承的类），如果是默认的，那么就是
 7     //--只能在同一个包下面访问，但是类是不可以设置成为私有的，如果设置成为私有的，那么他将失去任何意义。就就是说
 8     //--你创建的这个类，本类外面没有一人能看见。也就无法进行获得具体存在的事物，--对象。（Java使用了另外的一个方式，就是让构造方法私有，通过静态方法创建对象）
 9     //--protected也是不能作用类的访问权限。protected只是针对一个子类中的方法而进行的权限设定。
10     //Java规定，在一个类中只能有一个public ,不能有多个public,并且规定文件名字和类的名字一样，也是基于这种考虑。
11     //但是并不是说必须有一个public,可以有另外的方式，那就是默认的类权限。程序也可以执行。
12     //所以说Java的每一个规定都是有道理的。
13 }

 1 package think_in_java_access_contorl;
 2
 3 class single{
 4     private single(){
 5
 6     }
 7
 8     private static single singleDemo=new single();
 9     static single single_method(){
10         return singleDemo;
11     }
12
13     void method(){
14         System.out.println("haha!!!单例设计模式");
15     }
16 }
17 public class safsadf {
18
19     public static void main(String[] args) {
20         single singleDemo=single.single_method();
21         singleDemo.method();
22     }
23 }