Java基础系列20-包package

x33g5p2x  于2021-12-18 转载在 其他  
字(3.4k)|赞(0)|评价(0)|浏览(415)

一. 包的概述和注意事项

包的概述:
  概述:其实就是文件夹
  作用:对类进行分类管理

包的划分:
  举例:
    学生的增加,删除,修改,查询
    老师的增加,删除,修改,查询
    以及以后可能出现的其他的类的增加,删除,修改,查询
  基本的划分:按照模块和功能分。
  实例

  1. //方案1:按照功能分
  2. com.javastudy.add
  3. AddStudent
  4. AddTeacher
  5. com.javastudy.delete
  6. DeleteStudent
  7. DeleteTeacher
  8. ...
  9. //方案2:按照模块分
  10. com.javastudy.student
  11. AddStudent
  12. DeleteStudent
  13. ...
  14. com.javastudy.teacher
  15. AddTeacher
  16. DeleteTeacher

定义包的格式:

  1. package 包名
  2. //如果是多级包,用 . 隔开即可

注意事项:
  package语句必须是程序的第一条可执行的代码
  package语句在一个java文件中只能有一个

二. 导包的格式及使用

导包概述:
  不同包下的类之间的访问,我们发现,每次使用不同包下的类的时候,都需要加包的全路径。比较麻烦。这个时候,java就提供了导包的功能。
  在IDEA中已经实现自动导包的功能了,不需要手动输入import进行导包

导包格式:

  1. import 包名;

代码:
Java_test.package1

  1. package Java_test;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-29
  6. * @remark 导包的格式及使用
  7. *
  8. */
  9. public class package1 {
  10. public void show() {
  11. System.out.println("show");
  12. }
  13. }

Java_study.package2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-29
  6. * @remark 导包的格式及使用
  7. *
  8. */
  9. public class package2 {
  10. public void method() {
  11. System.out.println("method");
  12. }
  13. }

Java_test.packageTest

  1. package Java_test;
  2. import Java_study.package2;
  3. //使用其他包下的类需要使用import进行导包
  4. /**
  5. *
  6. * @author 只是甲
  7. * @date 2021-06-29
  8. * @remark 导包的格式及使用
  9. *
  10. */
  11. public class packageTest1 {
  12. public static void main(String[] args) {
  13. //同一个package下的class直接调用
  14. package1 s1 = new package1();
  15. s1.show();
  16. //类不在同一个包下,使用的时候,要加类的全路径名称
  17. Java_study.package2 t1 = new Java_study.package2();
  18. t1.method();
  19. //这样做太麻烦了,java就提供了一个导包的功能 import Java_study.package2;
  20. package2 t2 = new package2();
  21. t2.method();
  22. }
  23. }

测试记录:

  1. show
  2. method
  3. method

三. 四种权限修饰符的概述和访问特点

归纳一下:在日常开发过程中,编写的类、方法、成员变量的访问:

  1. 要想仅能在本类中访问使用private修饰
  2. 要想本包中的类都可以访问除了private修饰符,其它都可以
  3. 要想本包中的类与其他包中的子类可以访问使用protected修饰
  4. 要想所有包中的所有类都可以访问使用public修饰。

代码:
父类package3

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-29
  6. * @remark 本类 四种权限修饰符的概述和访问特点
  7. *
  8. */
  9. public class package3 {
  10. private void show1() {
  11. System.out.println("show1");
  12. }
  13. void show2() {
  14. System.out.println("show2");
  15. }
  16. protected void show3() {
  17. System.out.println("show3");
  18. }
  19. public void show4() {
  20. System.out.println("show4");
  21. }
  22. public static void main(String[] args) {
  23. package3 p3 = new package3();
  24. p3.show1();
  25. p3.show2();
  26. p3.show3();
  27. p3.show4();
  28. }
  29. }

子类package4

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-29
  6. * @remark 同一个包下(子类) 四种权限修饰符的概述和访问特点
  7. *
  8. */
  9. public class package4 extends package3 {
  10. public static void main(String[] args) {
  11. package3 f = new package3();
  12. //f.show1(); 同一个包下(子类) 不能访问对象private修饰的方法
  13. f.show2();
  14. f.show3();
  15. f.show4();
  16. }
  17. }

本类下的测试类package5

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-29
  6. * @remark 同一个包下(无关类) 四种权限修饰符的概述和访问特点
  7. *
  8. */
  9. public class package5 extends package3 {
  10. public static void main(String[] args) {
  11. package3 f = new package3();
  12. //f.show1(); 同一个包下(子类) 不能访问对象private修饰的方法
  13. f.show2();
  14. f.show3();
  15. f.show4();
  16. }
  17. }

不同类下的子类package6

  1. package Java_test;
  2. import Java_study.package3;
  3. import Java_study.package4;
  4. /**
  5. *
  6. * @author 只是甲
  7. * @date 2021-06-29
  8. * @remark 不同包下(子类) 四种权限修饰符的概述和访问特点
  9. *
  10. */
  11. public class package6 extends package3 {
  12. public static void main(String[] args) {
  13. package3 f = new package3();
  14. //f.show1(); //不同包下(子类中父类对象) 不能访问对象private修饰的方法
  15. //f.show2(); //不同包下(子类中父类对象) 不能访问对象默认的方法
  16. //f.show3();//不同包下(子类中父类对象) 不能访问对象protected修饰的方法
  17. f.show4();
  18. System.out.println("========");
  19. package4 s1 = new package4();
  20. //s1.show1(); //不同包下(子类) 不能访问对象private修饰的方法
  21. //s1.show2(); //不同包下(子类) 不能访问对象默认的方法
  22. //s1.show3();
  23. s1.show4();
  24. }
  25. }

不同子类下的其它类

  1. package Java_test;
  2. import Java_study.package3;
  3. /**
  4. *
  5. * @author 只是甲
  6. * @date 2021-06-29
  7. * @remark 不同包下(其它类) 四种权限修饰符的概述和访问特点
  8. *
  9. */
  10. public class package7 {
  11. public static void main(String[] args) {
  12. package3 f = new package3();
  13. //f.show1(); //不同包下(无关类) 不能访问对象private修饰的方法
  14. //f.show2(); //不同包下(无关类) 不能访问对象默认的方法
  15. //f.show3();//不同包下(无关类) 不能访问对象protected修饰的方法
  16. f.show4();
  17. }
  18. }

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/115303081

相关文章