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