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 }

View Code

 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 }

View Code

 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 }

View Code

 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 }

View Code

 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 }

View Code

 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 }

View Code

 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 //            think_in_java_access_contorl.singleDemo1@6bbc4459
34 //            我是單例設計模式哈哈哈！
35 //            think_in_java_access_contorl.singleDemo1@6bbc4459
36             //注意這2個對象的地址同樣的，說明都是這2個都是同一個都對象的引用，也就是說咱們
37             //無論怎麼樣調用靜態方法，它都是同一個對象
38         }
39 }

View Code

 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 }

View Code

 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 }

View Code