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