Java 包及访问控制权限

本文涉及的产品
访问控制,不限时长
简介: 学习内容: 掌握包的定义及使用。 掌握Java新特性一一静态导入。 了解Java中的常用系统包。 掌握jar命令的使用。 掌握Java中的4种访问权限。 掌握Java语言的命名规范。

1、包的概念及使用


(1)基本概念

package是在使用多个类或接口时,为了避免名称重复而采用的一种措施,直接在程序中加入package关键字即可

🌼格式如下:

package 包名称.子包名称;

🌼范例:

package org.lxh.test;
class Demo{
    public String getInfo(){
        return "Hello World !!!";
    }
}
public class Test{
    public static void main(String[] args) {
        System.out.println(new Demo().getInfo());
    }
}


此时编译时需要加上相应参数:javac -d.Test.java


-d :表示生成目录,生成的目录以 package 的定义为准

. : 表示在当前所在文件夹中生成


执行完以上命令后,会自动生成相应的文件夹(包),之后再执行类时就必须输入完整的“包.类名称”


(2)import 语句

如果几个类存放在不同的包中,在使用类时就必须通过 import 语句导入


🌼import 的语法格式:


import 包名称.子包名称.类名称;    //手工导入所需要的类
import 包名称.子包名称.*;//由JVM自动加载所需要的类


🌼范例:定义 org.lxh.test 目录下的 Demo1.java


package  org.lxh.test;
public class Demo1{
  public String getInfo(){
    return "Hello World!";
  }
}


🌼范例:在另外一个类中引用Demo类


import org.lxh.test.Demo1;//引用 Demo1 类
public class Test{
    public static void main(String[] args) {
        System.out.println(new Demo1().getInfo());
    }
}


如果在一个类中导入一个包中多个类时,一个个地导入会比较麻烦,可以使用导入“*” 的方式由 JVM 根据需要自己加载的类。但是当一个程序中同时导入了两个包的同名类,使用时就必须明确地写出完整的“包.类名称”。


🌼范例:


import org.lxh.demo.a.*;//包中存在Demo类
import org.lxh.demo.c.*;//包中存在Demo类
public class Test{
  public static void main(String[] args){
  org.lxh.demo.a.Demo d = new org.lxh.demo.a.Demo();
  System.out.println(d.getInfo());
  }
}


(3)系统常见包

在JDK中为了方便用户开发程序,提供了大量的系统功能包,如下图所示:

image.png



java.util包在开发中使用较多,因为其支持大量的工具类操作,像本书中的常用类库、 Java 类集都是围绕此包展开讲解的。

java.lang.reflect这个包一般在面试时有可能会问到,此包属于比较高级的开发包。

(4)Java 新特性 – 静态导入

如果一个类中的方法全部是使用static声明的静态方法,则在导入时就可以直接使用 import static 的方式导入:


import static 包.类.*


🌼范例:定义一个类,全部由静态方法组成


package org.lxh.test;
public class Demo1{
    public static  int add(int i,int j){
        return i+j;
    }
    public static int sub(int i,int j){
        return i-j;
    }
    public static int mul(int i,int j){
        return i*j;
    }
}


🌼使用静态导入:


import static org.lxh.test.Demo1.*;//静态导入
public class Test{
    public static void main(String[] args) {
        System.out.println("3+3 = " + add(3,3));
        System.out.println("3-3 = " + sub(3,3));
    }
}


由于程序中使用了静态导入,所以Demo1 类中的所有静态方法可以直接在 Test 类中使用,而 不需要使用 “类.静态方法()” 的形式使用。


2、jar命令的使用


当开发者为客户开发出了一套 Java 类之后,肯定要把这些类交给用户使用,但是如果所有的类直接通过 *.class 的格式给用户,会比较麻烦,所以一般情况下会将这些 *.class 文件压缩车一个文件交付给客户使用,那么这样的文件就称为 jar 文件(Java Archive File)。


如果要想生成 jar 文件,直接使用 JDK 中 bin 目录里的 jar.exe 就可以将所有的类文件进行压缩,此命令是随 JDK 一起安装的,直接在命令行中输入 jar,即可看到此命令的提示界面:

image.png

当用户得到一个 jar 文件后,可以通过设置 classpath 的方式在系统中注册号此 jar 文件,以供程序使用。


🌼jar 命令主要使用的参数如下:


C:创建新的文档
V:生成详细的输出信息
F:指定存档的文件名


🌼范例:定义一个类:


package org.lxh.test.demo;
public class Test{
    public class Test{
        public String getInfo(){
            return "Hello";
        }
    }
}


🌼进行编译


javac -d.Test.java

🌼编译成功

image.png


将生成的 a 文件夹打包,命名为 my.jar

image.png


这个文件可以直接使用解压软件打开此文件,如果想要使用此文件,需要设置 classpath:set classpath = .;G:\Java\my.jar


以上设置了两个 classpath 目录,一个是从当前所在的文件夹中查找,另外一个就是刚压缩好的*.jar 文件



3、访问控制权限

在 Java 中一共存在 4 种访问控制权限,即 private,default,protected 和 public


(1)private访问权限

private属于私有访问权限,前面已经介绍过private访问权限,可以用在属性的定义、方法的声明上,一旦使用了private关键字声明,则只能在本类中进行访问。

(2)default(默认)访问权限

如果一个类中的属性或方法没有使用任何的访问权限声明,则就是默认的访问权限,默认的访问权限可以被本包中的其他类所访问,但是不能被其他包的类所访问。

(3)protected访问权限

protected属于受保护的访问权限。一个类中的成员如果使用了protected访问权限,则只能被本包及不同包的子类访问。

🌼范例:设置 protected 的访问权限


package org.lxh.test;
public class HelloDemo{
    protected String name = "Java";//只能被本包及不同包的子类访问
}


🌼访问受保护的属性:


import org.lxh.test.HelloDemo;
class SubHelloDemo extends HelloDemo{
    public void print(){
        System.out.println("访问受保护属性:" + super.name);//可以访问 protected 权限
    }
}
public class root {
    public static void main(String[] args) {
        SubHelloDemo sub = new SubHelloDemo();//实例化子类对象
        sub.print();
    }
}


🌼运行结果;


访问受保护属性:Java


(4)public访问权限

public属于公共访问权限。如果一个类中的成员使用了public访问权限,就可以在所有类中被访问,不管是否在同一个包中。

🌼总结访问控制权限:

image.png


4、Java命名规范


声明类、方法、属性等都是有一定的规范的,此规范如下。


  • 类:所有单词的首字母大写,如:JavaTest
  • 方法:第一个单词的首字母小写,之后每个单词的首字母大写,如 getInfo()
  • 属性:第一个单词的首字母小写,之后每个单词的首字母大写,如 studentName
  • 包:所有单词的字母小写,如 org.lxh.demo
  • 常量:所有单词的字母大写,如 FLAG


相关实践学习
消息队列+Serverless+Tablestore:实现高弹性的电商订单系统
基于消息队列以及函数计算,快速部署一个高弹性的商品订单系统,能够应对抢购场景下的高并发情况。
云安全基础课 - 访问控制概述
课程大纲 课程目标和内容介绍视频时长 访问控制概述视频时长 身份标识和认证技术视频时长 授权机制视频时长 访问控制的常见攻击视频时长
目录
相关文章
|
2月前
|
安全 Java API
JAVA并发编程JUC包之CAS原理
在JDK 1.5之后,Java API引入了`java.util.concurrent`包(简称JUC包),提供了多种并发工具类,如原子类`AtomicXX`、线程池`Executors`、信号量`Semaphore`、阻塞队列等。这些工具类简化了并发编程的复杂度。原子类`Atomic`尤其重要,它提供了线程安全的变量更新方法,支持整型、长整型、布尔型、数组及对象属性的原子修改。结合`volatile`关键字,可以实现多线程环境下共享变量的安全修改。
|
11天前
|
安全 Java 数据安全/隐私保护
如何配置 Java 安全管理器来避免访问控制异常
配置Java安全管理器以防止访问控制异常,需在启动JVM时通过 `-Djava.security.manager` 参数启用,并设置安全策略文件,定义权限规则,限制代码执行操作,确保应用安全。
|
15天前
|
Java Apache Maven
Java/Spring项目的包开头为什么是com?
本文介绍了 Maven 项目的初始结构,并详细解释了 Java 包命名惯例中的域名反转规则。通过域名反转(如 `com.example`),可以确保包名的唯一性,避免命名冲突,提高代码的可读性和逻辑分层。文章还讨论了域名反转的好处,包括避免命名冲突、全球唯一性、提高代码可读性和逻辑分层。最后,作者提出了一个关于包名的问题,引发读者思考。
Java/Spring项目的包开头为什么是com?
|
2月前
|
Java API 数据处理
Java 包(package)的作用详解
在 Java 中,包(package)用于组织和管理类与接口,具有多项关键作用:1)系统化组织代码,便于理解和维护;2)提供命名空间,避免类名冲突;3)支持访问控制,如 public、protected、默认和 private,增强封装性;4)提升代码可维护性,实现模块化开发;5)简化导入机制,使代码更简洁;6)促进模块化编程,提高代码重用率;7)管理第三方库,避免命名冲突;8)支持 API 设计,便于功能调用;9)配合自动化构建工具,优化项目管理;10)促进团队协作,明确模块归属。合理运用包能显著提升代码质量和开发效率。
|
2月前
|
Java 数据安全/隐私保护
Java 包(package)的使用详解
Java中的包(`package`)用于组织类和接口,避免类名冲突并控制访问权限,提升代码的可维护性和可重用性。通过`package`关键字定义包,创建相应目录结构即可实现。包可通过`import`语句导入,支持导入具体类或整个包。Java提供多种访问权限修饰符(`public`、`protected`、`default`、`private`),以及丰富的标准库包(如`java.lang`、`java.util`等)。合理的包命名和使用对大型项目的开发至关重要。
|
2月前
|
安全 Java 开发者
Java修饰符与封装:理解访问权限、行为控制与数据隐藏的重要性
Java中的修饰符和封装概念是构建健壯、易维护和扩展的Java应用程序的基石。通过合理利用访问权限修饰符和非访问修饰符,开发者能够设计出更加安全、灵活且高效的代码结构。封装不仅是面向对象编程的核心原则之一,也是提高软件项目质量和可维护性的关键策略。
15 1
|
26天前
|
Java
java中的权限修饰符
java中的权限修饰符
|
3月前
|
Java Maven 数据库
|
4天前
|
监控 安全 Java
在 Java 中使用线程池监控以及动态调整线程池时需要注意什么?
【10月更文挑战第22天】在进行线程池的监控和动态调整时,要综合考虑多方面的因素,谨慎操作,以确保线程池能够高效、稳定地运行,满足业务的需求。
71 38
|
1天前
|
安全 Java
java 中 i++ 到底是否线程安全?
本文通过实例探讨了 `i++` 在多线程环境下的线程安全性问题。首先,使用 100 个线程分别执行 10000 次 `i++` 操作,发现最终结果小于预期的 1000000,证明 `i++` 是线程不安全的。接着,介绍了两种解决方法:使用 `synchronized` 关键字加锁和使用 `AtomicInteger` 类。其中,`AtomicInteger` 通过 `CAS` 操作实现了高效的线程安全。最后,通过分析字节码和源码,解释了 `i++` 为何线程不安全以及 `AtomicInteger` 如何保证线程安全。
java 中 i++ 到底是否线程安全?