《Java编程思想》：第六章 访问权限控制

最新推荐文章于 2023-04-07 13:43:25 发布
最新推荐文章于 2023-04-07 13:43:25 发布
阅读量400 收藏 1
点赞数 2
分类专栏： JAVA的一些小事
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42331530/article/details/119489206
版权

第六章 访问权限控制

包：库单元

​ 我们之所以要导入包名，就是要提供一个管理名字空间的机制。所有类成员的名称都是彼此隔离开的。A类中的方法f()与B类中具有相同特征标记（参数列表）的方法f()不会彼此冲突。

​ 当编写一个Java源代码文件时，此文件通常被称为编译单元（有时也被称为转译单元）。每个编译单元都必须有一个后缀名 . java,而在编译单元内则可以有一个 public类，该类的名称必须与文件的名称相同(包括大小写，但不包括文件的后缀名.java)。每个编译单元只能有一个public类，否则编译器就不会接受。如果在该编译单元之中还有额外的类的话，那么在包之外的世界是无法看见这些类的，这是因为它们不是 public类，而且它们主要用来为主 public类提供支持。

代码组织

​ 当编译一个.java文件时，在.java文件中的毎个类都会有一个输出文件，而该输出文件的名称与.java文件中毎个类的名称相同，只是多了一个后缀名 .class因此，在编译少量.java文件之后，会得到大量的.class文件。如果用编译型语言编写过程序，那么对于编译器产生一个中间文件(通常是一个obj文件)，然后再与通过链接器（用以创建一个可执行文件）或类库产生器( librarian,用以创建一个类库)产生的其他同类文件捆绑在一起的情况，可能早已司空见惯。但这并不是Java的工作方式。Java可运行程序是一组可以打包并压缩为ー个Java文档文件（JAR,使用Java的jar文档生成器）的.class文件。Java解释器负责这些文件的查找、装载和解释。

​ Java解释器的运行过程如下：

​ 首先，找出环境变量 CLASSPATH(可以通过操作系统来设置，有时也可通过安装程序一用来在你的机器上安装Java或基于Java的工具一来设置）。CLASSPATH包含一个或多个目录，用作査找.class文件的根目录。

​ 从根目录开始，解释器获取包的名称并将每个句点替换成反斜杠，以从 CLASSPATH根中产生一个路径名称（于是， packagefoo.bar.baz就变成为 foo\bar \baz或 foo/bar/baz或其他，这一切取决于操作系统）。得到的路径会与 CLASSPATH中的各个不同的项相连接，解释器就在这些目录中査找与你所要创建的类名称相关的.class文件。(解释器还会去査找某些涉及Java解释器所在位置的标准目录。)

练习1:(1)在某个包中创建一个类，在这个类所处的包的外部创建该类的一个实例。

包类

package access.mypackage;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/3 21:03
 */
public class MyPackagedClass {
    public MyPackagedClass(){
        System.out.println("This is MyPackagedClass().");
    }
}

引用包类

import access.mypackage.*;
/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/3 21:04
 */
public class UnpackagedMyClass {
    public static void main(String[] args) {
        MyPackagedClass my = new MyPackagedClass();
    }
}

image-20210803210706558

制定工具库

​ 具备了这些知识以后，现在就可以创建自己的工具库来减少或消除重复的程序代码了。例如，我们已经用到的 System.out. println()的别名可以减少输入负担，这种机制可以用于名为 Print的类中，这样，我们在使用该类时可以用一个更具可读性的静态 import语句来导入：

包类Print

package net.tangwenbo.util;

import java.io.PrintStream;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/3 21:10
 */
public class Print {
    /**
     * print with a newline;
     */
    public static void print(Object object){
        System.out.println(object);
    }

    /**
     * print a newline by itself
     */
    public static void print(){
        System.out.println();
    }

    /**
     * print with no line break
     */
    public static void printb(Object object){
        System.out.print(object);
    }

    /**
     * The new Java SE5 print() (from C)
     */
    public static PrintStream printf(String format,Object... args){
        return System.out.printf(format,args);
    }
}

测试包类Print

import static net.tangwenbo.util.Print.*;
/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/3 21:17
 */
public class PrintTest {
    public static void main(String[] args) {
        print("Available from now on!");
        print(100);
        print(100L);
        print(3.14159);
    }
}

image-20210803212112314

​ 这个类库的第二个构件可以是在第4章中引入的 range()方法，它使得 foreach语法可以用于简单的整数序列:

包类Range

package net.tangwenbo.util;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/3 21:22
 */
public class Range {
    /**
     * Produce  a sequence [0...n)
     * @param n 数组长度
     * @return 按照顺序赋值好的数组
     */
    public static int[] range(int n){
        int[] result = new int[n];
        for (int i = 0; i < n; i++) {
            result[i] = i;
        }
        return result;
    }

    /**
     *
     * @param start 开始的数组下标
     * @param end  结束的数组下标
     * @return 数组长度为start-end的数组，并且已经按照顺序赋好了对应的值
     */
    public static int[] range(int start,int end){
        int sz = end - start;
        int[] result = new int[sz];
        for (int i = 0; i < sz; i++) {
            result[i] = start + i;
        }
        return result;
    }

    /**
     *
     * @param start 开始的数组下标
     * @param end 结束的数组下标
     * @param step 跳步
     * @return 数组长度为start-end的数组，并且进行了step的跳步，按照顺序赋好了对应的值
     */
    public static int[] range(int start,int end,int step){
        int sz = end -start;
        int[] result = new int[sz];
        for (int i = 0; i < sz; i++) {
            result[i] = start + (i * step);
        }
        return result;
    }
}

测试类

import static net.tangwenbo.util.Range.*;
import static net.tangwenbo.util.Print.*;
/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/3 21:29
 */
public class RangeTest {
    public static void main(String[] args) {
        int[] a = range(5);
        printArray(a);
        int[] b = range(0,10);
        printArray(b);
        int[] c =range(0,10,3);
        printArray(c);
    }

    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            printb(array[i]+" ");
        }
        print();
    }
}

image-20210803214037721

练习3:(2)创建两个包： debug和 debuoff,它们都包含一个相同的类，该类有一个 debug()方法。第一个版本显示发送给控制台的 String参数，而第二个版本什么也不做。使用静态 import语句将该类导入到一个测试程序中，并示范条件编译效果。

//debug包类
package access.debug;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/3 21:48
 */
public class Debug {
    public static void debug(String s){ }
}


//debugoff包类
package access.debugoff;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/3 21:48
 */
public class Debug {
    public static void debug(String s){
        System.out.println(s);
    }
}

测试类:

import access.debugoff.Debug;


/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/3 21:50
 */
public class DebugTest {
    public static void main(String[] args) {
        Debug.debug("debugoff Test");
    }
}

image-20210803215416949

Java访问权限修饰词

包访问权限

​ 在Java中如果一个类没有使用任何访问权限修饰词。默认访问权限没有任何关键字，但通常是指包访问权限(有时也表示成为 friendly)。这就意味着当前的包中的所有其他类对那个成员都有访问权限，但对于这个包之外的所有类，这个成员却是 private。由于一个编译单元（即一个文件），只能隶属于一个包，所以经由包访问权限，处于同一个編译单元中的所有类彼此之间都是自动可访问的。

public：接口访问权限

​ 使用关键字 public,就意味着 public之后紧跟着的成员声明自己对每个人都是可用的，尤其是使用类库的客户程序员更是如此。

private：你无法访问

​ 关键字 private的意思是，除了包含该成员的类之外，其他任何类都无法访问这个成员。由于处于同一个包内的其他类是不可以访问 private成员的，因此这等于说是自己隔离了自己。从另一方面说，让许多人共同合作来创建一个包也是不大可能的，为此 private就允许你随意改变该成员，而不必考虑这样做是否会影响到包内其他的类。

protected:继承访问权限

​ 关键字 protected处理的是继承的概念，通过继承可以利用一个现有类—我们将其称为基类，然后将新成员添加到该现有类中而不必碰该现有类。还可以改变该类的现有成员的行为。为了从现有类中继承，需要声明新类 extends（扩展）了一个现有类，就像这样：

class Foo extends Bar{}

​ 类定义中的其他部分看起来都是一样的。
​ 如果创建了一个新包，并自另一个包中继承类，那么唯一可以访问的成员就是源包的 public成员。(当然，如果在同一个包内执行继承工作，就可以操纵所有的拥有包访问权限的成员。)有时，**基类的创建者会希望有某个特定成员，把对它的访问权限赋予派生类而不是所有类。**这就需要 protected来完成这一工作。 protected地提供包访问权限，也就是说，相同包内的其他类可以访问 protected元素。

练习4:(2)展示 protected方法具有包访问权限，但不是 public.

package access.cookie2;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/4 21:35
 */
public class Cookie {
    public Cookie(){
        System.out.println("Cookie contstructor");
    }
    protected void bite(){
        System.out.println("bite.");
    }
}

package access.cookie2; // 与Cookie在同一个包下

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/4 21:36
 */
public class CookieMonster {
    public static void main(String[] args) {
        Cookie x = new Cookie();
        x.bite(); // package access to protected method
    }
}

image-20210804214030275

import access.cookie2.*;// 与Cookie不在同一个包下
/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/4 21:38
 */
public class CookieThief {
    public static void main(String[] args) {
        Cookie cookie = new Cookie();
//        cookie.bite();  // access protected
    }
}

练习5:(2)创建一个带有 public, private, protected和包访问权限域以及方法成员的类。创建该类的一个对象，看看在你试图调用所有类成员时，会得到什么类型的编译信息。请注意，处于同一个目录中的所有类都是默认包的一部分。

package access;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/4 21:43
 */
public class FourWays {
    int a = 0;
    public int b = 1;
    protected int c = 2;
    private int d = 3;
    FourWays(){
        System.out.println("FourWays() constructor");
    }
    void showa(){
        System.out.println(a);
    }
    public void showb(){
        System.out.println(b);
    }
    protected void showc(){
        System.out.println(c);
    }
    private void showd(){
        System.out.println(d);
    }
}


package access;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/4 21:45
 */
public class AccessTest {
    public static void main(String[] args) {
        FourWays fw = new FourWays();
        fw.showa();
        fw.showb();
        fw.showc();
        fw.a = 10;
        fw.b = 20;
        fw.c = 30;
        fw.showa();
        fw.showb();
        fw.showc();
        //! fw.showd(); // private access, compiler can't touch
    }
}

image-20210804214722566

练习6:(1)创建一个带有 protected数据的类。运用在第一个类中处理 protected数据的方法在相同的文件中创建第二个类。

package access;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/4 21:48
 */
class SomeData{
    protected int a = 13;
}
class DataChanger{
    static void change(SomeData sd,int i){
        sd.a = i;
    }
}
public class ProtectedData {
    public static void main(String[] args) {
        SomeData sd = new SomeData();
        System.out.println(sd.a);
        DataChanger.change(sd,99);
        System.out.println(sd.a);
    }
}

image-20210804215102231

类的访问权限

​ 在Java中，访问权限修饰词也可以用于确定库中的哪些类对于该库的使用者是可用的。如果希望某个类可以为某个客户端程序员所用，就可以通过把关键字 public作用于整个类的定义来达到目的。这样做甚至可以控制客户端程序员是否能创建一个该类的对象。然而，这里还有一些额外的限制：

  1. 每个编译单元（文件）都只能有一个 public类。这表示，每个编译单元都有单一的公共接口，用 public类来表现。该接口可以按要求包含众多的支持包访问权限的类。如果在某个编译单元内有一个以上的 public类，编译器就会给出出错信息。

  2. public:类的名称必须完全与含有该编译单元的文件名相匹配，包括大小写。所以对于Widget而言，文件的名称必须是 Widget.java,而不是 widget.java或 WIDGET. java。如果不匹配，同样将得到编译时错误。

  3. 虽然不是很常用，但编译单元内完全不带 public类也是可能的。在这种情况下，可以随意对文件命名。(尽管随意命名会使得人们在阅读和维护代码时产生混淆。)

    练习7:(1)根据描述 access和 Widget的代码片段创建类库。在某个不属于 access类库的类中创建一个 Widget实例。

package access; // access包下有Widget类
import static net.tangwenbo.util.Print.*;
/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/7 15:49
 */
public class Widget {
    public Widget(){
        print("Widget()");
    }
}

package Test; // 测试包下有MakeWidget类
import access.*; // 引入access类
/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/7 15:50
 */
public class MakeWidget {
    public static void main(String[] args) {
        Widget widget = new Widget();
    }
}

image-20210807155424103

​ 在创建一个包访问权限的类时，仍旧是在将该类的域声明为 private时才有意义——应尽可能地总是将域指定为私有的，但是通常来说，将与类（包访问权限）相同的访问权限赋予方法也是很合理的。既然一个有包访问权限的类通常只能被用于包内，那么如果对你有强制要求，在此种情况下，编译器会告诉你，你只需要将这样的类的方法设定为 public就可以了。

​ 请注意，类既不可以是 private的(这样会使得除该类之外，其他任何类都不可以访问它)，也不可以是 protected的。所以对于类的访问权限，仅有两个选择：包访问权限或 public。如果不希望其他任何人对该类拥有访问权限，可以把所有的构造器都指定为 private,从而阻止任何人创建该类的对象，但是有一个例外，就是你在该类的 static成员内部可以创建。下面是一个示例：

package access;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/7 15:58
 */
class Soup1{
    private Soup1(){}

    /**
     * 只允许该类的静态成员内部创建
     * @return 该类的实例
     */
    public static Soup1 makeSoup(){
        return new Soup1();
    }
}
class Soup2{
    private Soup2(){}

    /**
     * 创建该类的一个静态对象，并且返回该类的引用
     */
    private static Soup2 ps1 = new Soup2();
    public static Soup2 access(){
        return ps1;
    }
    public void f(){
        System.out.println("f()");
    }
}
public class Lunch {
    public static void main(String[] args) {
//        Soup1 soup1 = new Soup1(); // 不能够创建该类对象，因为其构造器被设置为了私有

    }
    void testStatic(){
        Soup1 soup = Soup1.makeSoup();
    }
    void testSingleton(){
        Soup2.access().f();
    }
}

​ 初看起来可能有点令人迷惑不解。方法名称( makeup)前面的词Soup1告知了该方法返回的东西。本书到目前为止，这里经常是void,意思是它不返回任何东西。但是也可以返回一个对象引用，示例中就是这种情况。这个方法返回了一个对Soup1类的对象的引用。

​ Soup1类和Soup2类展示了如何通过将所有的构造器指定为 private来阻止直接创建某个类的实例。请一定要牢记，如果没有明确地至少创建一个构造器的话，就会帮你创建一个默认构造器（不带有任何参数的构造器）。如果我们自己编写了默认的构造器，那么就不会自动创建它了。如果把该构造器指定为 private,那么就谁也无法创建该类的对象了。但是现在别人该怎样使用这个类呢？上面的例子就给出了两种选择：在 Soup1中，创建一个 static方法，它创建一个新的Soup1对象并返回一个对它的引用。如果想要在返回引用之前在Soup1上做一些额外的工作，或是如果想要记录到底创建了多少个Soup1对象（可能要限制其数量），这种做法将会是大有裨益的。

​ Soup2用到了所谓的设计模式，这种特定的模式被称为 singleton（单例），这是因为你始终只能创建它的一个对象。Soup2类的对象是作为Soup2的一个 static private成员而创建的，所以有且仅有一个，而且除非是通过 public方法 access(),否则是无法访问到它的。

练习8:(4)效仿示例 Lunch.java的形式，创建一个名为 ConnectionManager的类，该类管理一个元素为 Connection对象的固定数组。客户端程序员不能直接创建 Connection对象，而只能通过 ConnectionManager中的某个 static方法来获取它们。当 ConnectionManager之中不再有对象时，它会返回null引用。在main()之中检测这些类。

package access;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/7 16:27
 */
class Connection{
    private static int count =0;
    private int i = 0;
    private Connection(){
        System.out.println(" Connection()");
    }

    static Connection makeConnection(){
        count++;
        return new Connection();
    }
    public static int howMany(){
        return count;
    }
    public String toString(){
        return ("Connection "+count);
    }
}
public class ConnectionManager {
    static int howManyLeft = 3;
    static Connection[] ca = new Connection[3];
    {
        for(Connection x:ca){
            x = Connection.makeConnection();
        }
    }
    public static Connection getConnection(){
        if(howManyLeft>0){
            return ca[--howManyLeft];
        }else {
            System.out.println("No more connections.");
        }
        return null;
    }

    public static void main(String[] args) {
        ConnectionManager cm = new ConnectionManager();
        System.out.println(cm.howManyLeft);
        getConnection();
        System.out.println(howManyLeft);
        getConnection();
        System.out.println(howManyLeft);
        getConnection();
        System.out.println(getConnection());
        System.out.println(howManyLeft);
    }
}


 Connection()
 Connection()
 Connection()
3
2
1
No more connections.
null
0

练习9:(2)在 access/local目录下编写以下文件(假定 access/local目录在你的 CLASSPATH中)：

package access.local;

/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/7 16:24
 */
 class PackagedClass {
    public PackagedClass(){
        System.out.println("创建一个PackagedClass类");
    }

}

然后在 accesss/local之外的另一个目录中创建下列文件:

package access.Foregin;
import access.local.*;
/**
 * @author Tangwenbo
 * @version JDK 1.8
 * @date 2021/8/7 16:26
 */
public class Foregin {
    public static void main(String[] args) {
        PackagedClass pc = new PackagedClass(); // 编译报错
    }
}

解释一下为什么编译器会产生错误。如果将 Foreign类置于 access local包之中的话，会有所改变吗？

​ 报错的原因是PackagedClass 不是public的，所以在foreign包不能对local包内的PackagedClass类进行访问，如果将其移动到同一个包下，则编译可以通过。

猫奴.
关注
专栏目录
控制用户访问--用户和权限
hellowheat的专栏
05-27 1399
控制用户访问        在多用户环境中，要维护数据库访问和使用的安全性。通过Oracle服务器数据库安全性，可以执行以下任务：     1.控制数据库访问     2.授予对数据库中特定对象的访问权限     3.通过Oracle数据字典确认给定的和接收的权限     4.为数据库对象创建同义词        数据库的安全性可以分为以下两类：系统安全性和数据安全性。系统安全性包括在系统级别上对
Java编程思想__访问权限控制
NULL
04-10 250
访问控制( 或隐藏具体实现)与最初的实现并不恰当 有关。 Java提供了访问修饰词,以供类库开发人员向客户端程序员指明那些是可用的,那些是不可用的。访问权限控制的等级,从最大权限到最小的权限依次为: public , protected , 包访问权限(没有关键词) 和 private 。 ...
Java编程思想——访问权限控制
旧城故人往事的博客
10-26 434
6. 访问权限控制如何把变动的事物与不变动的事物区分开来是面向对象设计中需要考虑的一个基本问题。在修改和完善代码的压力下，如何保证某些代码是不可变动，哪些是有权限可以变动的。为了解决这一问题，java提供了访问权限修饰词，供类库开发人员向客户端程序员指明哪些是可用的，哪些是不可用的，权限等级从大到小依次为：public、protected、包访问权限（默认）、private。6.1 包：库单元包内含
Java编程思想 访问权限控制总结
勤劳的搬运工
06-19 188
访问控制(或隐藏具体实现)与 最初的实现并不恰当 有关 包：库单元 包内包含有一组类 它们在单一的名字空间之下被组织在了一起 使用包中类 可以使用全名来指定 或者import关键字 要想导入包中所有的类 只需要使用 * 一个Java编译单元中 只可以有一个public类 并且名称要与文件的名称相同(包括大小写) 代码组织 当编译一个.java文件时 在.java文件中的每个类都会有一个输出文件 而...
《Java 编程思想》第六章 初始化和清理（JDK 8版）
∑
06-09 1014
文章目录初始化和清理利用构造器保证初始化方法重载区分重载方法重载与基本类型返回值的重载无参构造器this关键字在构造器中调用构造器static 的含义垃圾回收器`finalize()` 的用途你必须实施清理终结条件垃圾回收器如何工作成员初始化指定初始化构造器初始化初始化的顺序静态数据的初始化显式的静态初始化非静态实例初始化数组初始化动态数组创建可变参数列表枚举类型本章小结 初始化和清理 "不安全"的编程是造成编程代价昂贵的罪魁祸首之一。有两个安全性问题：初始化和清理。C 语言中很多的 bug 都是因为程序
Java编程思想笔记(全)
最新发布
06-14
第六章介绍了Java中的访问控制机制。访问控制用于限制类、变量、方法和构造函数的可见性，从而保护程序的安全性和完整性。本章详细阐述了public、private、protected以及默认访问修饰符的含义及其应用场合。掌握这些...
Java面向对象编程详解：类、对象、继承与权限控制
"第04章 Java与面向对象编程.pdf" Java是一种强大的编程语言，它以其面向对象的特性而闻名。面向对象编程（Object-Oriented Programming, OOP）是Java的核心，它允许开发者通过模拟真实世界中的实体和交互来设计...
tij4-code:java编程思想第四版-GIT
03-24
"tij4-code:java编程思想第四版-GIT" 指的是该书的源代码已经托管在了Git版本控制系统中，方便读者查阅和学习。Git是一种分布式版本控制系统，用于跟踪对文件或项目的修改，非常适合软件开发团队协作和管理代码。 ...
Java编程思想第四版第六章习题
Jieker的博客
07-11 664
断更了一天，今天开始第六章，隔热感觉有点像C++的Iclude。 闲话少说，直接上题，编译器IDEA。 1.在某个包中创建一个类，在这个类所处的包的外部创建该类的一个实例。 class A： /** * @ClassName:A * @Description:A * @author: hszjj * @date: 2019/7/10 21:40 */ package A; im...
Java编程思想（第四版）1
08-03
《Java编程思想（第四版）》是一本深入探讨Java编程技术的经典著作，旨在帮助开发者克服程序开发中的复杂性。本书涵盖了从基础到高级的多个Java编程主题，包括对象导向编程的核心概念、类的设计与复用、多态性、异常...
Java编程思想 第六章 访问权限控制
name_sakura的博客
01-11 358
文章目录
java编程思想课后练习题——访问权限控制
小歪歪的博客
04-27 363
本文主要依据《Java编程思想》的示例及课后练习，通过个人编写，同时参考答案的代码写法。主要目的是用于自己熟悉编码风格，同时可以给更多人提供参考。（只完成了部分练习） 练习1： package 访问权限控制; import 控制执行流程.PackageClass;//导入需创建的类的实例所在的包 /** * @作者 Jiacy * @日期2021年4月21日 * @描述：在某个包中创建一个类，在这个类所处的包的外部创建该类的一个实例 * @version * */ public cl.
Java编程思想第六章访问权限控制练习题解答(待更新完整.......)
不负如来不负卿
11-15 721
练习解答练习１练习2练习3 练习１ 先在另一个包建立代码，命名为ch6Ex1.java package ch5; public class ch6Ex1 { public ch6Ex1(){ System.out.println("hello world"); } } 练习2 先定义一个Vector.java: package ch6.Exercise2; p...
Java若依框架权限隔离微调，基于groovy动态脚本实现动态隔离
darkkara的博客
04-07 444
由于若依的权限隔离过于简单，满足不了现有的需求，采用了Groovy脚本对方法进行动态的将sql注入到目标sql中，在一些很难进行配置实现的地方将功能实现了配置化。
Java，设计，功能权限和数据权限，用户、角色、权限和用户组
zhaohuodian的博客
08-28 9806
ACL是一种访问控制机制，包含三个关键要素：用户（User）、资源（Resource）和操作（Operate），当用户请求操作资源时，检查资源的权限列表，如果资源的权限列表中存在该用户的操作权限则允许，否则拒绝。RBAC模型，三个基础组成部分：用户（User）、角色（Role）和权限（Privilege），通过定义角色的权限，授予用户某个角色从而来控制用户的权限，实现了用户和权限的逻辑分离（区别于ACL模型）；...
private,protected,public,默认四种访问控制权限
踏雁寻花
07-15 4271
在Java中一共规定了四种访问控制权限： No. 位置 private default protected public 1 本类 2 本包中的其他类 3 不同包的子类 4 不同包的非子类
java 事务级别_Java 事务及隔离级别
weixin_39614834的博客
02-16 289
Java事务1) 说到事务，不得不提的就是ACID特性，再次回顾：Ø 原子性(atomicity)：组成事务处理的语句形成了一个逻辑单元，不能只执行其中的一部分。Ø 一致性(consistency)：在事务处理执行前后，数据库是一致的(数据库数据完整性约束)。Ø 隔离性(isolcation)：一个事务处理对另一个事务处理的影响。Ø 持续性(durability)：事务处理的效...
java 访问权限_Java的四种访问权限
weixin_36177719的博客
01-29 1570
❝ 所谓访问权限，指的就是本类中的成员变量、成员方法对其他类的可见性 ❞试想一想，当我们修改一个非常庞大的项目时，如果所有变量和方法都是公共权限，那么后端中任何类都有权限去修改它的变量和方法，很有可能修改后就导致项目无法运行，对客户端的代码就会造成一定的影响引入访问权限的概念就变得尤为重要Java中有四种访问权限，分别是「public、protected、包访问权限(默认)、private」，如果...
java访问权限控制
fxkcsdn的博客
08-05 1712
1.控制访问权限的两个原因 （1）第一是为了使用户不要触碰那些他们不该触碰的部分，这些部分对于类内部的操作是必要的，但是它并不属于客户端程序员所需接口的一部分。 （2）第二个原因，也是最重要的原因，是为了让类库设计者可以更改类的内部工作方式，而不必担心这样会对客户端程序员产生重大的影响。例如，最初可能会以一种方式创建一个类，然后发现如果更改程序结构，可以大大提高运行速度。如果接口和实现可以被明
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值