一. 包的概述和注意事项

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

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

//方案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

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

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

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