精华内容
下载资源
问答
  • Java访问控制修饰符

    千次阅读 2018-08-24 13:52:37
    Java中,可以使用访问控制符来保护对、变量、方法和构造方法访问。Java 支持 4 种不同访问权限。 default (即缺省,什么也写): 在同一包内可见,使用任何修饰符。使用对象:、接口、变量...

    修饰符用来定义类、方法或者变量,通常放在语句的最前端。

    Java语言提供了很多修饰符,主要分为访问修饰符和非访问修饰符,本篇主要介绍Java的访问控制修饰符。

     

    访问控制修饰符

    Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

    default (即缺省,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。

    private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

    public : 对所有类可见。使用对象:类、接口、变量、方法

    protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

    修饰符 当前类 同一包内 子孙类(同一包) 子孙类(不同包) 其他包
    public Y Y Y Y Y
    protected Y Y Y Y/N N
    default Y Y Y N N
    private Y N N N N

     

    公有访问修饰符-public

    被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

    如果几个相互访问的 public 类分布在不同的包中,则需要导入相应 public 类所在的包。由于类的继承性,类所有的公有方法和变量都能被其子类继承。

    以下函数使用了公有访问控制:

    // Java 程序的 main() 方法必须设置成公有的,否则,Java 解释器将不能运行该类。
    public static void main(String[] args) {
       // ...
    }

     

    受保护的访问修饰符-protected

    protected 需要从以下两个点来分析说明:

    子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;

    子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。

    protected 访问修饰符可以修饰类及其方法和成员变量,但是接口及接口的成员变量和成员方法不能声明为 protected。 

    子类能访问 protected 修饰符声明的方法和变量,这样就能保护不相关的类使用这些方法和变量。下面的父类使用了 protected 访问修饰符,子类重写了父类的 openSpeaker() 方法。

    class AudioPlayer {
        /**
         *如果把openSpeaker()声明为private,那么除了AudioPlayer之外的类将不能访问该方法。
         *如果把openSpeaker()声明为public,那么所有的类都能够访问该方法。
         *如果我们只想让该方法对其所在类的子类可见,则将该方法声明为protected。
         */
        protected boolean openSpeaker(Speaker sp) {
            // 实现细节
        }
    }
     
    class StreamingAudioPlayer extends AudioPlayer {
        protected boolean openSpeaker(Speaker sp) {
            // 实现细节
        }
    }

     

    默认访问修饰符-不使用任何关键字

    使用默认访问修饰符声明的变量和方法,对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

    如下例所示,变量和方法的声明可以不使用任何修饰符。

    String name = "luccy";
    boolean isMan() {
       return true;
    }

     

    私有访问修饰符-private

    私有访问修饰符是最严格的访问级别,所以被声明为 private 的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为 private。

    声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

    private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

    下面的类使用了私有访问修饰符:

    public class Student {
        // name为私有变量,其他类不能直接得到和设置该变量的值。
        private String name; 
        // 为了使其他类能够获取该变量,定义了public 方法:getName() (返回 name的值)
        public String getName() {
            return this.name;
        }
        // 为了使其他类能够修改该变量,定义了public 方法:setName(String)(设置 name的值)
        public void setName(String name) {
            this.name = name;
        }
    }

     

    访问控制和继承

    请注意以下方法继承的规则:

    1)父类中声明为 public 的方法在子类中也必须为 public。

    2)父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。

    3)父类中声明为 private 的方法,不能够被继承。

     

     

     

    展开全文
  • c#类以及类成员的访问修饰符 ​ 在面试中最容易考察到基础知识点非访问修饰符莫属,所以今天我来给大家分享一下c#中访问修饰符的知识点,此文章具有一定的参考价值,...那么我们就来认识一下类的访问修饰符有哪些,

    c#类以及类成员的访问修饰符

    在面试中最容易考察到基础知识点非访问修饰符莫属,所以今天我来给大家分享一下c#中访问修饰符的知识点,此文章具有一定的参考价值,需要的朋友可以来参考鉴赏。如果说此文章写的不是太好,对大家造成了误导,或者说有一些不足指出,还请各位朋友能够指出,在下方评论,我期待大家一起的成长。


    1、什么是访问修饰符?

    (1)访问修饰符就是用来控制封装这个目标的权限范围

    (2)权限范围:(这个目标)可以被哪些对象在什么地方可以访问到合格目标中的数据

    那么我们就来认识一下类的访问修饰符有哪些,并且有哪些作用


    2、类的访问修饰符以及组合访问修饰符有些那些

    当我们在命名空间中定义元素的时候我们可用的只有public和internal来那种。
    在这里插入图片描述提示可知,在命名空间中直接声明只能用public和internal,且默认什么都不加的情况下是internal
    我给大家总结出来:

    修饰符 说明
    public 表示公共的,访问完全不受限制
    internal(默认的) 表示内部的,仅本项目中可以访问,本程序表示同一个程序或同一个程序集中
    abstract 或 internal abstract 类只能在当前项目中访问,不能实例化,只能继承
    public abstract 类可以在任何地方访问,不能实例化,只能继承
    sealed 或 internal sealed 类只能在当前项目中访问,不能派生,只能实例化
    public sealed 类可以在任何地方访问,不能派生,只能实例化

    3、成员的访问修饰符

    修饰符 说明
    public 表示公共的,访问完全不受限制
    internal 表示内部的,仅本项目中可以访问,本程序表示同一个程序或同一个程序集中
    private(默认的) 表示私有的,仅本类中可以使用,其他地方无法访问,包括它的子类也不能访问,并且类的实例都不可以访问
    protected 表示受保护的,仅本类和笨类的子类可以访问,可以跨程序集访问,并且类的实例都不能访问
    protected internal 表示受保护的内部(即受保护或内部),仅当前的项目中或者该类的子类可以访问到

    4、各类型中的成员访问修饰符

    枚举类型(enum) 访问修饰符
    枚举类型(enum) 枚举成员默认为public修饰符,且不能显示使用修饰符
    结构(struct) 机构成员默认为private修饰符。结构成员无法声明为protected成员,因为结构不支持继承
    类(class) 构造函数默认为public修饰符。析构函数不能显示使用访问修饰符且默认为private访问修饰符。类的成员默认访问修饰符为private。
    接口(interface) 接口成员访问修饰符默认为public,且不能显示使用访问修饰符
    嵌套类型 嵌套类型的默认访问修饰符为private,和类、结构的成员默认访问类型一致

    以上是本人查阅相关资料总结的,其中第4个各类型中的访问修饰符目前还没学到,是在查阅资料时意外收获的内容,希望对在学的各位朋友能够起到或大或小的帮助。如果本篇文章有什么纰漏或者不足之处,还请各位远方的朋友能够指出,我期待大家的进步!

    展开全文
  • Java中,可以使用访问控制符来保护对、变量、方法和构造方法访问。Java 支持 4 种不同访问权限。 default(即缺省,什么也写,friendly): 在同一包内可见,使用任何修饰符。使用对象:、接口、变量、...

    在关键字中,有几个比较特殊,可以控制访问权限.

    访问控制修饰符--

    Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

    • default (即缺省,什么也不写,friendly): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。当修饰方法时,可以不必被子类实现.比较好的一个应用是扩展已有很多个实现的一个接口,可以再新添加的方法前面使用此修饰符,已经实现该接口的多个类就可以不必实现新添加的方法.

    • private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)与接口

    • public : 对所有类可见。使用对象:类、接口、变量、方法。

    • protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

    访问权限可以用下面的表格来表示:

    访问控制与继承:

    • 父类中声明为 public 的方法在子类中也必须为 public。

    • 父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。

    • 父类中声明为 private 的方法,不能够被继承。

     

    关键字--

    static修饰符

    • static 用来声明独立于对象的静态变量,无论一个类实例化多少对象,它的静态变量拷贝只有一份.静态变量也被称为类变量,局部变量不能被 static 修饰。
    • static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。

    final修饰符

    • final 类不能被继承,没有类能够继承 final 类的任何特性。
    • final 方法可以被重载,可以被子类继承,但是不能被子类修改,既不能被子类重写(覆盖)。
    • final 变量一旦被赋值后,不能被修改。

    abstract修饰符

    • abstaract 类不能被实例化,含有abstract方法的类一定是抽象类,抽象类不一定含有抽象方法,一个类不能同时被 abstract 和 final 修饰,任何继承抽象类的子类都需要实现父类的所有抽象方法,除非该子类也是抽象类。
    • abstaract 方法没有任何实现,需要子类实现其方法,抽象方法不能被声明成 final 和 static。

    synchronized修饰符

    • synchronized 关键字声明的方法同一时间只能被一个线程访问。。

    transient 修饰符

    • 序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。
    • 该修饰符包含在定义变量的语句中,用来预处理类和变量的数据类型。

    volatile 修饰符

    • volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
    • 一个 volatile 对象引用可能是 null。

    要理解这个关键字,首先要明确两个概念:

    可见性:一个线程对共享变量的修改,能够实时的被其他持有这个变量的线程看到

    线程共享变量:如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是共享变量

    在JVM虚拟机中,规定了线程共享变量的访问规则:

    1.所有的共享变量都寻在主内存中

    2.每个线程都有独立的工作内存,共享变量存储在其中

    3.线程对共享内存的操作都是在自己的工作内存之中

    4.无法访问其他线程工作内存中的共享变量

    这个关键字就能够实现线程共享变量的可见性与禁止指令重排序.与synchronized关键字相比,volatile不具有原子性,即它是非安全的.

    native 修饰符

    • 告诉JVM虚拟机,被修饰的这个类方法是在类的外部定义的.
    展开全文
  • Java的修饰符

    2019-03-29 21:49:42
    Java中,可以使用访问控制符来保护对、变量、方法和构造方法访问。Java 支持 4 种不同访问权限。 default (即缺省,什么也写): 在同一包内可见,使用任何修饰符。使用对象:、接口、变量、方法。 ...

    Java的修饰符

    修饰符用来定义类、方法或者变量,通常放在语句的最前端。Java语言提供了很多修饰符,主要分为以下两类:

    • 访问修饰符

      访问控制修饰符

      Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

      • default (即缺省,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
      • private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
      • public : 对所有类可见。使用对象:类、接口、变量、方法
      • protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
      //默认访问修饰符(default)
      String version = "1.5.1";
      boolean processOrder() {
         return true;
      }
      
      //私有访问修饰符 private
      public class Logger {
         private String format;
         public String getFormat() {
            return this.format;
         }
         public void setFormat(String format) {
            this.format = format;
         }
      }
      
      //公有访问修饰符 public
      public static void main(String[] arguments) {
         // ...
      }
      
      //受保护的访问修饰符 protected
      class AudioPlayer {
         protected boolean openSpeaker(Speaker sp) {
            // 实现细节
         }
      }
       
      class StreamingAudioPlayer extends AudioPlayer {
         protected boolean openSpeaker(Speaker sp) {
            // 实现细节
         }
      }
      
    • 受保护的访问修饰符-protected

      protected 需要从以下两个点来分析说明:

      • 子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;
      • 子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。

      protected 可以修饰数据成员,构造方法,方法成员,不能修饰类(内部类除外)

    访问控制和继承

    请注意以下方法继承的规则:

    • 父类中声明为 public 的方法在子类中也必须为 public。

    • 父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。

    • 父类中声明为 private 的方法,不能够被继承。

    • 非访问修饰符

    static 修饰符

    • 静态变量:

      static 关键字用来声明独立于对象的静态变量,无论一个类实例化多少对象,它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

    • 静态方法:

      static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据,然后计算这些数据。

    final 修饰符

    final 变量:

    final 表示"最后的、最终的"含义,变量一旦赋值后,不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

    final 修饰符通常和 static 修饰符一起使用来创建类常量。

    类中的 final 方法可以被子类继承,但是不能被子类修改。

    public class Test{
      final int value = 10;
      // 下面是声明常量的实例
      public static final int BOXWIDTH = 6;
      static final String TITLE = "Manager";
     
      public void changeValue(){
         value = 12; //将输出一个错误
      }
    }
    

    abstract 修饰符

    抽象类:

    抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。

    一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法,那么该类一定要声明为抽象类,否则将出现编译错误。

    抽象类可以包含抽象方法和非抽象方法。

    abstract class Caravan{
       private double price;
       private String model;
       private String year;
       public abstract void goFast(); //抽象方法
       public abstract void changeColor();
    }
    

    synchronized 修饰符

    synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符

    public synchronized void showDetails(){
    .......
    }
    

    transient 修饰符

    序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。

    该修饰符包含在定义变量的语句中,用来预处理类和变量的数据类型。

    public transient int limit = 55;   // 不会持久化
    public int b; // 持久化
    

    volatile 修饰符

    volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。

    一个 volatile 对象引用可能是 null。

    public class MyRunnable implements Runnable
    {
        private volatile boolean active;
        public void run()
        {
            active = true;
            while (active) // 第一行
            {
                // 代码
            }
        }
        public void stop()
        {
            active = false; // 第二行
        }
    }
    
    展开全文
  • 修饰符

    2018-07-15 23:36:00
    Java中,可以使用访问控制符来保护对、变量、方法和构造方法访问。Java 支持 4 种不同访问权限。 default (即缺省,什么也写): 在同一包内可见,使用任何修饰符。使用对象:、接口...
  • Java中的修饰符

    2019-06-04 17:08:00
    Java中,可以使用访问控制符来保护对、变量、方法和构造方法访问。Java 支持 4 种不同访问权限。 default (即缺省,什么也写): 在同一包内可见,使用任何修饰符。使用对象:、接口、变量、方法。 pr.....
  • 修饰类的修饰符 public:被public修饰的类可以被任何类所使用(本包、其他包、自身) 缺省:缺省的意思就是写权限访问控制符,被此修饰符修饰的类只能被该类自身,本包中的类所使用 abstract:被此修饰符修饰的...
  • Java 修饰符

    2019-03-05 19:43:15
    Java中,可以使用访问控制符来保护对、变量、方法和构造方法访问。Java支持4种不同访问权限。 默认,也称为default,在同一包内可见,使用任何修饰符。 私有,以private修饰符指定,在同一内可见。 ...
  • Java修饰符

    2019-04-25 17:42:40
    Java中,可以使用访问控制符来保护对、变量、方法和构造方法访问。Java支持4种不同访问权限。 1、默认friendly,也称为default,在同一包内可见,使用任何修饰符。 2、私有,以private修饰符指定...
  • java修饰符

    2020-06-15 20:27:05
    Java中,可以使用访问控制符来保护对、变量、方法和构造方法访问。 default (即默认,什么也写): 在同一包内可见,使用任何修饰符。使用对象:、接口、变量、方法。 private 在同一内可见。使用对象:...
  • (1)访问修饰符就是用来设置控制封装这个目标权限范围 (2)权限范围:这个目标可以被哪些对象在什么地方可以访问到这个目标数据 1.public(公有,访问权限最大) (1).public访问修饰符允许一个将其成员变量和成员...
  • Java-修饰符

    2017-08-13 20:34:00
    访问控制符可以保护对、变量、方法和构造方法访问 四中不同访问权限: default,在同一包内可见,使用任何修饰符 private,在同一内可见 public,对所有可见 protected,对同一包内的类和所有子类可见 ...
  • 五 Java修饰符

    2017-11-09 16:22:04
    访问控制修饰符Java中,可以使用访问控制符来保护对、变量、方法和构造方法访问。Javav支持 4 种不同访问权限。 public :对所有可见。使用对象:、接口、变量和方法。 protected:对同一包内的类和所有...
  • Java修饰符详解

    2019-12-15 14:24:51
    Java中,可以使用访问控制符来保护对、变量、方法和构造方法访问。Java 支持 4 种不同访问权限。 default (即默认,什么也写,注意与java8default关键字加以区分): 在同一包内可见,使用任何修饰符。...
  • Java 关键字修饰符

    2020-10-15 14:20:11
    1 访问控制修饰 Java提供了四种定义访问权限...其中private和protected用来修饰外部,外部上一层为包,故外部一般具有两种访问权限:本包内访问、全局访问,对应default和public。 1.1 继承中访问控制
  • 访问修饰符用来控制类中成员可见性 有四个访问修饰符,分别是:default,private,public,protected 1、default(默认):默认权限,不用写。在同一包内访问。 2、private(私有):只能在同一中访问。 ...
  • java学习--修饰符

    2019-04-18 16:59:00
    访问控制修饰符用来修饰类和类内部的成员变量和成员方法,来确定其访问权限 类的访问控制修饰只有两种 default 和 public default(即缺省,什么也写): 只在同一包内可见。能引入其包中  类A为default,当...

空空如也

空空如也

1 2 3 4 5 6
收藏数 118
精华内容 47
关键字:

不可以用来修饰类的控制符