Java基础系列20-包package

港控/mmm° 2022-09-06 10:26 167阅读 0赞

### 文章目录 ###

*  一. 包的概述和注意事项
 *  二. 导包的格式及使用
 *  三. 四种权限修饰符的概述和访问特点
 *  参考:

# 一. 包的概述和注意事项 #

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

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

//方案1：按照功能分
        com.javastudy.add
            AddStudent
            AddTeacher
        com.javastudy.delete
            DeleteStudent
            DeleteTeacher
    		...
    
    //方案2：按照模块分
        com.javastudy.student
            AddStudent
            DeleteStudent
            ...
        com.javastudy.teacher
            AddTeacher
            DeleteTeacher

定义包的格式:

package 包名
    //如果是多级包，用 . 隔开即可

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

# 二. 导包的格式及使用 #

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

导包格式：

import 包名;

**代码:**  
Java\_test.package1

package Java_test;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-29
     * @remark  导包的格式及使用
     *
     */
    public class package1 {
    	public void show() {
    		System.out.println("show");
    	}
    
    }

Java\_study.package2

package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-29
     * @remark  导包的格式及使用
     *
     */
    public class package2 {
    	public void method() {
    		System.out.println("method");
    	}
    
    }

Java\_test.packageTest

package Java_test;
    
    import Java_study.package2;
    
    //使用其他包下的类需要使用import进行导包
    /**
    * 
    * @author  只是甲
    * @date    2021-06-29
    * @remark  导包的格式及使用
    *
    */
    public class packageTest1 {
    	public static void main(String[] args) {
    		//同一个package下的class直接调用
    		package1  s1 = new package1();
    		s1.show();
    		
    		//类不在同一个包下，使用的时候，要加类的全路径名称
    		Java_study.package2 t1 = new Java_study.package2();
    		t1.method();
    		
    		
    		//这样做太麻烦了，java就提供了一个导包的功能 import Java_study.package2;
    		package2 t2 = new package2();
    		t2.method();
    	}
    
    }

**测试记录:**

show
    method
    method

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

![image.png][]

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

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

**代码:**  
父类package3

package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-29
     * @remark  本类   四种权限修饰符的概述和访问特点
     *
     */
    public class package3 {
    	private void show1() {
    		System.out.println("show1");
    	}
    	
    	void show2() {
    		System.out.println("show2");
    	}
    	
    	protected void show3() {
    		System.out.println("show3");
    	}
    	
    	public void show4() {
    		System.out.println("show4");
    	}
    	
    	public static void main(String[] args) {
    		package3 p3 = new package3();
    		p3.show1();
    		p3.show2();
    		p3.show3();
    		p3.show4();
    	}
    
    }

子类package4

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

本类下的测试类package5

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

不同类下的子类package6

package Java_test;
    
    import Java_study.package3;
    import Java_study.package4;
    /**
     * 
     * @author  只是甲
     * @date    2021-06-29
     * @remark  不同包下(子类)   四种权限修饰符的概述和访问特点
     *
     */
    public class package6 extends package3 {
    	public static void main(String[] args) {
    		package3 f = new package3();
    		//f.show1(); //不同包下(子类中父类对象) 不能访问对象private修饰的方法
            //f.show2(); //不同包下(子类中父类对象) 不能访问对象默认的方法
            //f.show3();//不同包下(子类中父类对象) 不能访问对象protected修饰的方法
            f.show4();
            
            System.out.println("========");
            
            package4 s1 = new package4();
            //s1.show1(); //不同包下(子类) 不能访问对象private修饰的方法
            //s1.show2(); //不同包下(子类) 不能访问对象默认的方法
            //s1.show3();
            s1.show4();
            
    	}
    
    }

不同子类下的其它类

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

# 参考: #

1.  https://blog.csdn.net/qq\_43529621/article/details/115303081

[image.png]: /images/20220829/be4e5ed37ae94aecb49422876c380138.png