Java中类级和方法级访问控制的区别

在java中，类或方法的访问或两者的访问都可以通过access Modifiers声明。Java中可用的访问修饰符

private修饰符:如果声明只能在类内部访问
default Modifier:如果声明只能在包内部访问
protected Modifier:如果声明为在包内部可访问且仅在其他包的子类中可访问
公共修饰符:如果声明可在任何地方访问

注意: 还有其他修饰符final、strictfp、static、abstract，但它们是非访问修饰符，它们提供对象实例化或权限覆盖等信息，但不用于声明访问。

访问级别的类型

有两种类型的访问级别

1. 类级别的访问

对类的访问是否在包外可见等。称为类级访问。Public和default[package_ private]修饰符用于类级访问。如果我们使用公共修饰符，那么该类可以在任何地方使用，只有一个条件:该类必须可用[import等]。而如果我们使用默认修饰符，则该类只能在声明的包内访问，而不能在其他任何地方访问

Modifier	内部类	内包	外面的包装
public	yes	yes	yes
default	yes	yes	no

2. 方法级访问

对类方法的访问权限，无论该方法是在类或包之外还是在子类内部等。称为方法级访问。所有四个修饰符都用于方法级访问

注意 : 如果我们使用protected或public方法，该类必须是public的，因为在使用其成员之前，类必须在外部包中可用。即使你至少有一个public或protected方法，将类声明为public也是必须的

如果我们使用private修饰符，那么该方法只能在类内部使用。
如果我们使用default修饰符，那么该类只能在声明的包内访问，而不能在其他任何地方访问，class可能是公共的，也可能不是公共的，这没有区别。
如果我们使用protected修饰符，那么类可以在包内的任何地方访问，并且只能在包外的子类中访问。
如果我们使用public修饰符，那么该方法就允许在任何地方使用，条件是该类必须可用。

Modifier	Within class	Within package	outside package by subclass only	Outside package	public class (must/may)
private	yes	no	no	no	may
default	yes	yes	no	no	may
protected	yes	yes	yes	no	must
public	yes	yes	yes	yes	must

示例

演示访问修饰符的示例程序

package salary;
 
public class Manager
{
    private int a = 15;
     
    // This method needs to be private as
    // only the manager will have the
    // power to change employees' salary
    private void change()
    {                    
        System.out.println("salary changed");
    }
   
    // This method needs to be protected
    // as the companies salary
    // column can only be seen by
    // the company employees
    // and their child companies
    protected void sal_column()
    {                 
        System.out.println("salary shown");
    }
   
    // This method needs to be default
    // as individual salary
    // can only be shared within the company
    void indi_sal()
    {              
        System.out.println("your salary is shown");
    }
   
      // This method needs to be public
      // as the cost of a product
      // must be marketized to increase the profits
    public void prod_cost()
    {                 
        System.out.println("product cost");
    }
}
     
class Employee
{
    public static void main(String arg[]){
        Manager mng = new Manager();
       
          // error: change() has private access in Manager
         // mng.change();
       
        // total salary of all employees
        mng.sal_column();
       
        // individual salary
        mng.indi_sal();
       
        // cost of product
        mng.prod_cost(); 
    }
}
 
// Code written by @srivathsanani

编译和执行：

Java中类级和方法级访问控制的区别

package reports;
 
// importing salary package with Manager class
import salary.Manager;
 
 
// The reports of our company needs our
// manager so we inherit Manager class
public class Reports extends Manager
{
    public static void main(String arg[])
    {
        Manager manager = new Manager();
        Reports report = new Reports();
         
        // error: indi_sal() is not public in Manager;
        // cannot be accessed from outside package
        // manager.indi_sal();
        manager.prod_cost();
        report.sal_column();
    }
}
 
 
// AS other companies are not related to our
// company we won't inherit our Manager class
class OtherCompany
{
    public static void main(String arg[])
    {
        Manager manager = new Manager();
        manager.prod_cost();
       
          // error: sal_column() has protected access in Manager
        // manager.sal_column();  
    }
}
 
// code written by @srivathsanani

编译和执行：

Java中类级和方法级访问控制的区别

注意: 只有在包外使用受保护的方法时，才必须使用子类引用

区别

类级别的访问	方法级访问
对类的访问是否在包外可见被称为类级访问。	对类方法的访问权限，无论该方法是在类或包之外还是在子类内部等。称为方法级访问。
只有两个修饰符具有此权限。	所有访问修饰符都是适用的。
将在包内或任何地方访问。	可以在包内部或子类中访问。
提供对类的访问，而不考虑方法访问。	对方法的访问取决于对类的访问。
这提供了顶级访问。	这并不提供顶级完整访问权。
即使我们可以通过应用修饰符来限制类的可访问性，我们也不能高度保护它，因为private修饰符和protected在类级别不适用。	通过在方法级别使用访问private修饰符和protected修饰符，我们可以完全限制方法的可访问性和可用性。