Java中权限设置

 package think_in_java_access_contorl;

 import think_in_java_access_contorl.access.Cookie;

 /**
  * 1.在Java编程思想中有一段很经典的话，明白就会解决很多问题：
  * --当编写一个Java源代码文件时，此文件通常被成为编译单元（有时也被称为转义单元）。每个
  * 个编译单元都必须有一个后缀名为.java，而在编译单元内则可以有一个public类，该类的名称必须
  * 与文件的名称相同（包括大小写，但不包括文件的后缀名.java）。每个编译单元只能有一个public类，否则编译器就不会接受。如果
  * 该编译单元之中还有额外的类的话，那么在包之外世界是无法看见这些类的，这是因为他们不是public类，而且他们主要为主public类提供
  * 支持。
  *
  *
  * 这就解释了为什么，在同一个包下面，主类必须是public或者是默认的。但是我们可以定义别的类，但是这些类的权限是
  * 默认的，为什么？因为他们在同一个包下面，必须使用默认的权限，而默认的权限就是在同一个包可见。
  *
  * 2.Java如何将可执行的字节码 文件加载进去
  * Java可运行程序是一组可以打包并压缩为一个Java文档文件（jar,使用Java的jar文档生成器）的.class文件。Java解析器负责这些
  * 文件的查找，装载和解释。
  *
  * 3.Java中为什么要使用域名的倒叙的形式命名包？
  * 在编程思想中，为了让自己的包名独一无二，那么最有效的方法就是ip地址，就是独一无二的，而Java有主要进行的是企业级的开发，所以使用公司域名的倒叙来区分
  * 包名。目的就在于此。
  * */
 public class Demo1 {

     public static void main(String[] args) {
         Cookie c=new Cookie();
         //c.bite();由于访问权限，所以无法进行访问
     }
 }

 package think_in_java_access_contorl;
 /**
  * 私有构造器获得实例的方法：
  *     如果有一个私有的构造器，并且它的权限设置成为一个私用的权限；如果通过方法获得它的实例。
  *         因为它是私有的，所以权限只在它的类中。在程序的外部是不能进行new操作的，因为无法找到构造器。但是我们可以使用静态方法的形式，通过类名调用方法
  *         进行间接获得，它的实例。
  *
  * */
 public class Demo2_privateDemo_test {

     public static void main(String[] args) {
         Demo2_privateDemo pri= Demo2_privateDemo.make_Demo2_privateDemo();
         pri.smile();
     }
 }

 package think_in_java_access_contorl;

 public class Demo2_privateDemo {

     private Demo2_privateDemo(){
         System.out.println("private 构造器，其他类不能访问！");
     }

     public static  Demo2_privateDemo make_Demo2_privateDemo(){
         return new Demo2_privateDemo();
     }

     public void smile(){
         System.out.println("smile....");
     }
 }

 package think_in_java_access_contorl;

 public class Demo3_protectedDemo_test extends Demo3_protectedDemo {

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

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

 package think_in_java_access_contorl;

  class Example{

 }
  class Ha{
      public static void haha(){
          System.out.println("你好啊");
      }
  }
  //注意这里是没有public 并且上面的类只能是默认的权限
  class Demo4_Object_access_control_2{
     public static void main(String[] args) {
         System.out.println("amazing");
         new Ha().haha();
     }

 }

 package think_in_java_access_contorl;
 /*
  * 单例设计模式（其实就是基于方法的访问权限和类的访问权限设计的模式）
  * */

 class singleDemo1{
     private singleDemo1(){

     }
     //为什么这样设计之后，调用静态方法就可以获得同一个对象：首先，程序调用静态方法，类加载器就会把这个类的class文件加载到方法去并且
     //创建一个Class对象，静态代码块，开辟一个有类相关信息的空间，指向的是singleDemo1的实例。
     //而调用静态的single_example方法相当与指向了同一个singleDemo1的实例。
     private static singleDemo1 single=new singleDemo1();
     public static singleDemo1 single_example(){
         return single;
     } 

     public void method(){
         System.out.println("我是单例设计模式哈哈哈！");
     }
 }

 public class Demo4_Object_access_control_single_design_pattern {

         public static void main(String[] args) {
             //创建了一个单例子，最好理解访问权限的例子
             singleDemo1 single=singleDemo1.single_example();
             System.out.println(single);
             single.method();
             singleDemo1 single2=singleDemo1.single_example();
             System.out.println(single2);
             single2.method();
 //            think_in_java_access_contorl.singleDemo1@6bbc4459
 //            我是单例设计模式哈哈哈！
 //            think_in_java_access_contorl.singleDemo1@6bbc4459
             //注意这2个对象的地址一样的，说明都是这2个都是同一个都对象的引用，也就是说我们
             //不管怎么样调用静态方法，它都是同一个对象
         }
 }

 package think_in_java_access_contorl;

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

 package think_in_java_access_contorl;

 class single{
     private single(){

     }

     private static single singleDemo=new single();
     static single single_method(){
         return singleDemo;
     }

     void method(){
         System.out.println("haha!!!单例设计模式");
     }
 }
 public class safsadf {

     public static void main(String[] args) {
         single singleDemo=single.single_method();
         singleDemo.method();
     }
 }