一. 包的概述和注意事项
包的概述：
概述：其实就是文件夹
作用：对类进行分类管理
包的划分:
举例：
学生的增加，删除，修改，查询
老师的增加，删除，修改，查询
以及以后可能出现的其他的类的增加，删除，修改，查询
基本的划分：按照模块和功能分。
实例
//方案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
归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问：
- 要想仅能在本类中访问使用private修饰
- 要想本包中的类都可以访问除了private修饰符,其它都可以
- 要想本包中的类与其他包中的子类可以访问使用protected修饰
- 要想所有包中的所有类都可以访问使用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();
}
}
网友评论