在同一个包下 - 都可以访问

    1. /**
    2. *
    3. * 演示访问权限在包中的使用
    4. */
    5. package Test14_Demo.Demo05;/*
    6. @create 2020--12--02--14:33
    7. */
    8. public class AccessClass {
    9. //私有化的方法
    10. private void method1() {
    11. System.out.println("私有化方法");
    12. }
    13. //默认权限的方法
    14. void method2() {
    15. System.out.println("默认权限的方法");
    16. }
    17. //受保护的方法 - 对子类的保护 - 不在一个包下也可以使用
    18. protected void method3() {
    19. System.out.println("受保护的方法");
    20. }
    21. public void method4() {
    22. System.out.println("公共方法");
    23. }
    24. //测试访问权限的方法
    25. public void testAccess() {
    26. method1();
    27. method2();
    28. method3();
    29. method4();
    30. }
    31. public static void main(String[] args) {
    32. //实例化对象
    33. AccessClass ac = new AccessClass();
    34. ac.testAccess();
    35. //测试本类中的权限
    36. ac.method1();
    37. ac.method2();
    38. ac.method3();
    39. ac.method4();
    40. }
    41. }

    在同一个包下但在不同的类中:

    1. /**
    2. *
    3. * 访问权限测试
    4. */
    5. package Test14_Demo.Demo05;/*
    6. @create 2020--12--02--14:39
    7. */
    8. public class AccessDemo {
    9. public static void main(String[] args) {
    10. //创建对象
    11. AccessClass ac = new AccessClass();
    12. //私有的 - 本类中访问
    13. //ac.method1();
    14. ac.method2();
    15. ac.method3();
    16. ac.method4();
    17. }
    18. }

    在不同的包下 - 且继承之后:

    1. /**
    2. *
    3. * 访问权限测试
    4. */
    5. package Test14_Demo.Demo06;/*
    6. @create 2020--12--02--14:39
    7. */
    8. import Test14_Demo.Demo05.AccessClass;
    9. public class AccessDemo extends AccessClass {
    10. public static void main(String[] args) {
    11. //创建对象
    12. AccessClass ac = new AccessClass();
    13. //私有的 - 本类中访问
    14. //ac.method1();
    15. //ac.method2();//默认的权限符 - 只能在本包和本类中被访问
    16. //ac.method3();//保护的 - 同包和同类以及子类
    17. ac.method4();
    18. }
    19. public void method0() {
    20. //调用父类中的内容
    21. //super.method1();私有的不可以
    22. //super.method2();默认的权限方法不可调用
    23. super.method3();//可以访问,因为这里继承了父级,利用super可以访问
    24. super.method4();//可以访问,因为是公共的
    25. }
    26. }