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();
    }
}