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