《JAVA编程思想》日志（六）---------访问权限控制

矫情吗；* 2022-08-21 00:11 140阅读 0赞

摘要：java的访问权限修饰词从大到小权限依次是：public,proteced(继承权限)，包访问权限（没有关键词），private。

## 6.1包：类库单元 ##

一个包里会有很多类，所以包也叫类库。在程序中经常看到  
import java.util.ArrayList; 其中java.util就是一个包名，而ArrayList是包内的一个类，包内有很多类，该程序中只用到了ArrayList类，所以导入这个类。

package com.wangjing.Exercise;
    
    public class MyPackage {
       //在这个类中可以封装各种常用方法自定义常用工具类库，例如输出方法等
    
        void MyPackage(){
            //构造方法
        }
        public void print1(){
            System.out.print("C");
        }
        void print2(){}          //默认访问权限，包访问权限
        public static void print3(){   //静态方法
            System.out.print("B");
        }
    
        public static void main(String[] args) {
            System.out.print("A");
        }
    
    }

package com.wangjing.AccessLimitation;//构建包名最好是独一无二的，使用自己的域名wangjing.com
    import com.wangjing.Exercise.MyPackage;//如果用到了另一个包中的某个方法，需要这样导入
    import static com.wangjing.Exercise.MyPackage.*;//导入包中静态的方法，就可以直接调用print3了
    
    public class packageUser { 
    
        public static void main(String[] args) {
            MyPackage myp=new MyPackage();    //此时自动调用其构造方法
            myp.print1();        //print1()是public方法
            //myp.print2(); 因为print2方法在另一个包里不是public，访问权限是包访问权限
            print3();          //静态方法print3无需创建对象就可以直接访问
            myp.print3();
            myp.main(args);
        }
    
    }/*output:CBBA*/

## 6.2 java访问权限修饰词 ##

## 6.2.1包访问权限 ##

如果两个类A和B都是默认的访问权限，那么它们就会被放在同一个默认的包内，通过创建对象的方式就可以相互调用非private方法。

## 6.2.2public ：接口访问权限##

public声明的成员声明自己对每个人都是可用的。

## 6.2.3 private ：你无法访问该类##

除了包含该成员的类外，其他任何类都无法访该成员。有一种用法，构造器是private的，可以通过其他方法创建对象。

package com.wangjing.Exercise;
    
    public class MyPackage {
    
        private void MyPackage(){   //把构造方法声明为private，就不能用构造方法来创建对象了
            //构造方法
        }
        public static MyPackage gouzao(){  //另一种创建创建对象的方法
            return new MyPackage();
        }
        public void print1(){
            System.out.print("C");
            }
    }

package com.wangjing.AccessLimitation;
    import com.wangjing.Exercise.MyPackage;
    import static com.wangjing.Exercise.MyPackage.*;
    
    public class packageUser { 
    
        public static void main(String[] args) {
    // MyPackage myp=new MyPackage(); //如果构造器是private，就不能用该方法创建对象
            MyPackage myp=MyPackage.gouzao();//通过另一种public的gouzao()方法创建对象，直接用 类名.方法 调用
            myp.print1();                    //
        }
    
    }

## 6.2.4 继承访问权限 ##

package com.wangjing.Exercise;
    
    public class MyPackage {
    
        void MyPackage(){   
            System.out.println("基类");
        }
    
        public void print1(){
            System.out.println("public基类方法");
            }
        void print3(){                     //该基类方法是默认访问权限在导出类中不能直接调用
            System.out.println("包访问权限的基类方法");
            }
        protected void print4(){         //如果把基类方法设置成protected，就可以在导出类中调用
            System.out.println("继承权限的基类方法");  //同时该方法也具有包访问权限 
            }
    }
    
     class MyPackage2{
        public void print1(){}
        public static void main(String[] args){
            MyPackage m=new MyPackage();
            m.print4();           //验证protected具有包访问权限,另一个包内则不能访问
            m.print3();     
        }
    }

package com.wangjing.AccessLimitation;
    import com.wangjing.Exercise.MyPackage;
    
    import static com.wangjing.Exercise.MyPackage.*;
    
    public class packageUser extends MyPackage { //继承自基类，就可以使用基类的protected方法
        void packageUser(){
            System.out.println("导出类");
        }
        public void print2(){
            System.out.println("导出类方法");
            }
        public static void main(String[] args) {
            packageUser pu=new packageUser();
            pu.packageUser();          //如果构造方法已经显式的定义，就必须要显式的调用，否则不会调用
            pu.print1();
            pu.print2();
            //pu.print3(); //由于print3方法具有包访问权限，不能调用
            pu.print4();      //print4是protected权限的，通过继承可以使用
        }
    
    }/*output:导出类 public基类方法 导出类方法 继承权限的基类方法*/

## 6.3 接口和实现 ##

访问权限的控制常被称为具体实现的隐藏。把数据和方法包装进类中，以及具体实现的隐藏，共同称为封装。  
同时将接口和实现分离，客户端程序员不用知道具体的实现，可以直接使用接口。保证类库设计者可以随意更改类库，在提高类库性能的前提下，还不影响客户端程序员的代码。

## 6.4 类的访问权限 ##

1.每个编译单元（文件）都只能有一个public类，但是可以包含多个包访问权限的其他类。这表示，每个编译单元都有一个单一的公共接口，用public类来表现。  
2.类的权限只有两种：public和默认的访问权限。  
3.如果不希望其他人拥有该类的访问权限，可以把该类的所有构造器指定为private，从而阻止任何人创建该类的对象。