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

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

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

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

     

    访问控制修饰符

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

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

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

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

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

    修饰符当前类同一包内子孙类(同一包)子孙类(不同包)其他包
    publicYYYYY
    protectedYYYY/NN
    defaultYYYNN
    privateYNNNN

     

    公有访问修饰符-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 的方法,不能够被继承。

     

     

     

    展开全文
  • 用来修饰interface修饰的方法

    万次阅读 2019-04-24 11:02:26
    用来修饰interface的有( )(仅限外部接口) 正确答案: A C D A private B public C protected D static 解析: 1、抽象中的抽象方法(其前有abstract修饰)能用private、...

    不能用来修饰interface的有( )(仅限外部接口)
    正确答案: A C D

    • A private

    • B public

    • C protected

    • D static

    解析:

    1、抽象类中的抽象方法(其前有abstract修饰)不能用private、static、synchronized、native访问修饰符修饰。原因如下:抽象方法没有方法体,是用来被继承的,所以不能用private修饰;static修饰的方法可以通过类名来访问该方法(即该方法的方法体),抽象方法用static修饰没有意义;使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的。是在其子类实现的。所以。锁应该归其子类所有。所以。抽象方法也就不能用synchronized关键字修饰了;native,这个东西本身就和abstract冲突,他们都是方法的声明,只是一个吧方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢?

    2、接口是一种特殊的抽象类,接口中的方法全部是抽象方法(但其前的abstract可以省略),所以抽象类中的抽象方法不能用的访问修饰符这里也不能用。而且protected访问修饰符也不能使用,因为接口可以让所有的类去实现(非继承),不只是其子类,但是要用public去修饰。接口可以去继承一个已有的接口。

    题考察修饰符,函数定义等,故从网上搜罗了下相关资料,总结如下:

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述 类的修饰符整合

    一.类

    类的修饰符:

    Public:可以在其他任何类中使用,默认为统一包下的任意类。

    Abstract:抽象类,不能被实例化,可以包含抽象方法,抽象方法没有被实现,无具体功能,只能衍生子类。

    Final:不能被继承。

    二.变量

    变量修饰符:

    一个类的成员变量的声明必须在类体中,而不能在方法中,方法中声明的是局部变量。

    1. 可访问修饰符:

    2. static:类变量:一个类所拥有的变量,不是类的每个实例有的变量。类变量是指不管类创建了多少对象,系统仅在第一次调用类的时候为类变量分配内存,所有对象共享该类的类变量,因此可以通过类本身或者某个对象来访问类变量。

    3. final:常量。

    4. volatile:声明一个可能同时被并存运行的几个线程所控制和修改的变量。

    实例变量:和类变量对应,即每个对象都拥有各自独立的实例变量。

    三.方法:(和变量对象分为实例方法和类方法,并用有无static修饰区别)

    类方法:使用static关键字说明的方法

    1.第一次调用含类方法的类是,系统只为该类创建一个版本,这个版本被该类和该类的所有实例共享。

    2.类方法只能操作类变量,不能访问实例变量。类方法可以在类中被调用,不必创建实例来调用,当然也可以通过对象来调用。

    实例方法:实例方法可以对当前对象的实例变量操作,而且可以访问类变量。

    方法可以重载,要求:方法名相同,但是参数必须有区别。(参数不同可以使类型不同,顺序不同,个数不同)

    方法的返回类型:若无返回类型,则声明为void.

    方法中的变量作用域:

    1. 成员变量:整个类。

    2. 局部变量:定义起到方法块结束为止。

    3. 方法参数:整个方法或者构造方法。

    4. 异常处理参数:参数传递给异常处理方法。

    构造方法:和类同名的方法。为新建对象开辟内存空间后,用于初始化新建的对象。不能用对象显式的调用。

    静态初始化器:格式:static{<赋值语句组>}

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • Java非访问控制修饰符

    千次阅读 2018-08-24 17:48:22
    final 修饰用来修饰类、方法和变量,final 修饰的类能够被继承,修饰的方法能被继承类重新定义,修饰的变量为常量,是可修改的。 abstract 修饰,用来创建抽象类和抽象方法。 synchroni...

    Java除了提供public、protected等访问修饰符之外,为了实现一些其他的功能,Java 也提供了许多非访问修饰符。

    static 修饰符,用来修饰类方法和类变量。

    final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。

    abstract 修饰符,用来创建抽象类和抽象方法。

    synchronized 和 volatile 修饰符,主要用于线程的编程。

     

    static 修饰符

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

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

    对类变量和方法的访问可以直接使用 类名.变量名 和 类名.方法名 的方式访问。

    如下例所示,static修饰符用来创建类方法和类变量。

    public class InstanceCounter {
       private static int numInstances = 0;
       protected static int getCount() {
          return numInstances;
       }
     
       private static void addInstance() {
          numInstances++;
       }
     
       InstanceCounter() {
          InstanceCounter.addInstance();
       }
     
       public static void main(String[] arguments) {
          System.out.println("Starting with " +
          InstanceCounter.getCount() + " instances"); // Starting with 0 instances
          for (int i = 0; i < 500; ++i){
             new InstanceCounter();
              }
          System.out.println("Created " +
          InstanceCounter.getCount() + " instances");  // Created 500 instances
       }
    }

     

    final 修饰符

    final 变量

    final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变,但是里面的值可以改变。

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

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

    final 方法

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

    声明 final 方法的主要目的是防止该方法的内容被修改。

    如下所示,使用 final 修饰符声明方法。

    public class Test{
        public final void testMethod(){
           // 方法体
        }
    }

    final 类

    final 类不能被继承,没有类能够继承 final 类的任何特性。

    public final class Test {
        // 类体
    }

     

    abstract 修饰符

    抽象类

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

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

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

    abstract class Test{ // 抽象类
       private double height;
       private String name;
       private Date birth;
       public abstract void hear(); // 抽象方法
       public abstract void eat(); // 抽象方法
    }

    抽象方法

    抽象方法是一种没有任何实现的方法,该方法的的具体实现由子类提供。

    任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。

    如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

    抽象方法的声明以分号结尾,例如:public abstract sample();

    public abstract class SuperClass{
        abstract void testMethod(); // 抽象方法
    }
     
    class SubClass extends SuperClass{
        // 实现抽象方法
        void testMethod(){
            //.........
        }
    }

    抽象方法不能被声明成 final 和 static。

    // final不能同时和abstract使用,因为abstract是需要被子类继承覆盖的,否则毫无意义;
    // 而final 用是禁止继承的,两者相互排斥,所以不能共用.
    abstract final void testMethod();
    // static 和 abstract 也是不能连用的,因为 static 是类级别的不能被子类覆盖,
    // 而 abstract 需要被继承实现,两者相互矛盾。
    abstract final void testMethod();

     

    synchronized 修饰符

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

    public synchronized void buyTicket(){
        // .......
    }

     

    transient 修饰符

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

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

    public transient int a = 55;   // 不会持久化
    public int b; // 持久化
    /**
     *当对象被序列化(写入字节序列到目标文件)时,transient阻止实例中那些用此关键字声明的变量持久化;
     *当对象被反序列化时(从源文件读取字节序列进行重构),这样的实例变量值不会被持久化和恢复。
     */
    //定义一个需要序列化的类
    class People implements Serializable{
        String name; //姓名
        transient Integer age; //年龄
        public People(String name,int age){
            this.name = name;
            this.age = age;
        }
        public String toString(){
            return "姓名 = "+name+" ,年龄 = "+age;
        }
    }
    
    public class TransientPeople {
        public static void main(String[] args) throws FileNotFoundException, 
                IOException, ClassNotFoundException {
            People p = new People("爪哇菌",30);
            System.out.println(p); //打印对象的值:  姓名 = 爪哇菌 ,年龄 = 30
            ObjectOutputStream os = new ObjectOutputStream(
                    new FileOutputStream("d://people.txt"));
            os.writeObject(p);//写入文件(序列化)
            os.close();
            ObjectInputStream is = new ObjectInputStream(
                    new FileInputStream("d://people.txt"));
            p = (People)is.readObject();//将文件数据转换为对象(反序列化)
            System.out.println(p); // 年龄数据未定义:  姓名 = 爪哇菌 ,年龄 = null
            is.close();
        }
    }

     

    volatile 修饰符

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

    volatile可以用在任何变量前面,但不能用于final变量前面,因为final型的变量是禁止修改的。

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

    /**
     *通常情况下,在一个线程调用run()方法(在Runnable开启的线程),在另一个线程调用stop()方法。 
     *如果第一行中缓冲区的active值被使用,那么在第二行的active 值为false时循环不会停止。
     *但是以下代码中我们使用了 volatile 修饰 active,所以该循环会停止。
     */
    public class MyRunnable implements Runnable {
        private volatile boolean active;
        public void run() {
            active = true;
            while (active) { // 第一行
                // 代码
            }
        }
        public void stop(){
            active = false; // 第二行
        }
    }

    还有个使用场景是单例模式中采用DCL双锁检测(double checked locking)机制,在多线程访问的情况下,可使用volatitle修改,保证多线程下的可见性。缺点是性能有损失,因此单线程情况下不必用此修饰符。

    class Singleton{
        private volatile static Singleton instance = null;
        private Singleton() {
        }
    
        public static Singleton getInstance() {
            if(instance==null) {
                synchronized (Singleton.class) {
                    if(instance==null)
                        instance = new Singleton();
                }
            }
            return instance;
        }
    }

     

    展开全文
  • Java通过修饰符控制类,属性和方法的访问权限和其他功能,通常放在语句的最前端。例如:public class className { //body of class } private boolean myFlag; static final double weeks = 9.5; protected static...

    Java通过修饰符来控制类,属性和方法的访问权限和其他功能,通常放在语句的最前端。例如:

    public class className
    {
         //body of class
    }
    private boolean myFlag;
    static final double weeks = 9.5;
    protected static final int BOXWIDTH = 42;
    public static void main(String[] arguments)
    {
      //body of method
    }

    Java的修饰符很多,分为访问修饰符和非访问修饰符。
    访问修饰符也叫访问控制符,是指能够控制类,成员变量,方法的使用权限的关键字。
    在面向对象编程中,访问控制符是一个很重要的概念,可以使用它来保护对类,变量,方法和构造方法的访问。
    Java支持四种不同的访问权限:
    这里写图片描述

    public:共有的

    被声明为public的类,方法,构造方法和接口能够被任何其他类访问。
    如果几个相互访问的public类分布在不同的包中,则需要导入响应public类所在的包。由于类的继承性,类所有的共有方法和变量都能被其子类继承。
    下面的方法使用了共有访问控制:

    public static void main(String[] args)
    {
       //body of method
    }

    Java程序的main()方法必须设置成共有的,否则,Java解释器将不能运行该类。

    protected:受保护的

    被声明为protected的变量、方法和构造方法能被同一个包中的任何其他类访问,也能够被不同包中的子类访问。

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

    子类能访问protected修饰符声明的方法和变量,这样就能保护不相关的类使用这些方法和变量。

    下面的父类使用了protected访问修饰符,子类重载了父类的bark()方法。

    public class Dog{
        protected void bark() {
            System.out.println("汪汪,不要过来");
        }
    }
    
    class Teddy extends Dog{  // 泰迪
        void bark() {
            System.out.println("汪汪,我好怕,不要跟着我");
        }
    }

    如果把bark()方法声明为private,那么除了Dog之外的类将不能访问该方法。如果把bark()声明为public,那么所有的类都能够访问该方法。如果我们只想让该方法对其所在类的子类可见,则将该方法声明为protected。

    private:私有的

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

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

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

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

    public class Dog
    {
      private String name;
      private int age;
      public String getName()
      {
        return name;
      }
      public void setName(String name)
      {
        this.name = name;
      }
      public int getAge()
      {
        return age;
      }
      public void setAge(int age)
      {
        this.age = age;
      }
    }

    例子中,Dog类中的name、age变量为私有变量,所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量,定义了两对public方法,getName()/setName() 和 getAge()/setAge(),它们用来获取和设置私有变量的值。
    this 是Java中的一个关键字
    在类中定义访问私有变量的方法,习惯上是这样命名的:在变量名称前面加“get”或“set”,并将变量的首字母大写。例如,获取私有变量 name 的方法为 getName(),设置 name 的方法为 setName()。这些方法经常使用,也有了特定的称呼,称为 Getter 和 Setter 方法。

    默认的:不使用任何关键字

    不使用任何修饰符声明的属性和方法,对同一个包内的类是可见的。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为public。
    如下例所示,类,变量和方法的定义没有使用修饰符:

    class Dog
    {
      String name;
      int age;
    
      void bark()//汪汪叫
      {
        System.out.println("汪汪,不要过来");
      }
    
      void hungry()//饥饿
      {
        System.out.println("主人,我饿了");
      }
    }

    访问控制和继承

    • 父类中声明为public的方法在子类中也必须为public。
    • 父类中声明为protected的方法在子类中要么声明为protected,要么声明为public。不能声明为private。
    • 父类中默认修饰符声明的方法,能够在子类中声明为private。
    • 父类中声明为private的方法,不能够被继承。

    如何使用访问控制符

    访问控制符可以让我们很方便的控制代码的权限:
    • 当需要让自己编写的类被所有的其他类访问时,就可以将类的访问控制符声明为 public。
    • 当需要让自己的类只能被自己的包中的类访问时,就可以省略访问控制符。
    • 当需要控制一个类中的成员数据时,可以将这个类中的成员数据访问控制符设置为 public、protected,或者省略。

    展开全文
  • 类修饰符

    2008-11-08 19:48:00
    转贴自 http://yangzht2008.blogcn.com/diary,7452582....修饰符分为访问控制符和非访问控制符两大修饰符之间的先后排列次序对的性质没有任何影响。一. 非访问修饰符。 1. 抽象: 凡是用abstract修
  • Java 通过修饰符控制类、属性和方法的访问权限和其他功能,通常放在语句的最前端。例如: public class className { // body of class}private boolean myFlag;static final double weeks = 9.5;protected ...
  • Java 通过修饰符控制类、属性和方法的访问权限和其他功能,通常放在语句的最前端。例如: publicclassclassName{ // body of class } privatebooleanmyFlag; staticfinaldoubleweeks=9.5; ...
  • Java修饰符

    千次阅读 2013-11-05 14:36:46
    前言 ...JAVA定义时除了需要使用class关键字说明所定义的数据类型是外,还需要在class之前增加若干的...修饰符分为:可访问控制符和非访问控制符两种 可访问控制符是 : 公共类修饰符 public 非访问控制
  • 的访问控制符

    2016-09-19 20:51:37
    访问控制符主要针对外部访问而言,在一个的内部所有成员之间可以相互访问,访问控制符是透明的。 public: 可以在任何地方进行访问,受任何约束; protected: 可被子访问,不管是同一个包还是不同包 同一...
  • java访问控制修饰符

    2016-12-16 20:24:52
    Java中,可以使用访问控制符来保护对、变量、方法和构造方法的访问。Java支持4种不同的访问权限。
  • Java 访问控制符 修饰符 详解

    千次阅读 2011-08-05 22:26:24
    1.接口  接口是描述一个对外公布的方法签名,所有的对象都能访问到,因此它的属性和方 法能违背接口的这个本质概念。所以接口的属性强制为public static final ...任何手动设置这几个修饰符,必
  • 访问控制修饰符 默认的,也称为default,在同一包内可见,使用任何修饰符;私有的,以private修饰符指定,在同一内可见;共有的,以public修饰符指定,对所有可见;受保护的,以protected修饰符指定,在...
  • java 、属性、方法修饰符总结

    千次阅读 2018-11-12 22:43:06
    修饰可以分为访问修饰符(访问控制符)和非访问修饰符(非访问控制符) 访问修饰符:顾名思义如果在访问范围内可以控制访问。 非访问修饰符:实现一些其他的功能。   一、类修饰符  访问修饰符:public、...
  • 的访问修饰符

    2018-03-19 13:26:30
    Java语言中的访问权限控制符有public.protected.default.private四个,在定义时,访问控制修饰符只能一个。每个Java程序的主类都必须是public,主类必须具有文件名称相同的名字。 在体定义时用到了及其...
  • 修饰符分为:可访问控制符和非访问控制符两种。 可访问控制符是:公共类修饰符 public 非访问控制符有:抽象类修饰符 abstract ;最终类修饰符 final ① 公共类修饰符 public Java 语言中 的可访问控制符...
  • java的访问修饰符

    2019-05-23 16:18:13
    控制符有public.protected.default.private四个,定义类时,只能写一个。 每个程序主类都必须是public,主类名必须与文件名称相同。 1. 访问控制修饰符主要用于定义类... - 用来修饰类的有public.abstract.final...
  • 访问控制符的作用是说明被声明的内容(、属性、方法和构造方法)的访问权限,就像发布的文件一样,在文件中标注...具体的实现就是通过访问控制符中会被其它调用的内容开放出来,而把希望别人调用的内容隐藏起来
  • java 修饰符

    2013-01-14 22:32:20
    修饰符分为访问控制符和非访问控制符两大修饰符之间的先后排列次序对的性质没有任何影响。   一,非访问修饰符。  1, 抽象:  凡是用abstract修饰修饰被称为抽象。抽象就是...
  • Java中的类修饰符

    千次阅读 2018-08-01 10:27:50
    只要把的属性改成默认的就可以了,也就是前面什么控制符加,采用默认的方式。  Java语言程序设计中,定义时除了要使用class 关键字说明所定义的数据类型是,还可以在 class 之前增加若干修饰符来...
  • 2、 修饰符分为:可访问控制符和非访问控制符两种。 可访问控制符是:公共类修饰符 public 非访问控制符有:抽象类修饰符 abstract ;最终类修饰符 final 1、公共类修饰符public: Java 语言中 的可访问...
  • Java 修饰符

    千次阅读 2020-01-02 18:45:28
    Java中,可以使用访问控制符来保护对、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。 default (即默认,什么也写): 在同一包内可见,使用任何修饰符。使用对象:、接口、变量、方法。 ...
  • 1.访问控制修饰符 其实看太多的文字定义完全是浪费时间,一张图就能将访问控制修饰符解释清楚访问权限publicprotecteddefaultprivate本√√√√本包√√√×子类√√××不同包√×××public:都可以访问;...
  • 访问权限 public protected default private 同一个 yes yes yes yes 同一个包 yes yes yes no 子类 yes ...
  • static、final修饰符、内部

    千次阅读 2015-07-20 20:50:12
    static修饰符: final修饰符,内部
  • public修饰类

    千次阅读 2019-04-03 15:07:09
    修饰符分为:可访问控制符和非访问控制符两种。 公共类修饰符 public 非访问控制符有:抽象类修饰符 abstract ;最终类修饰符 final 1 )公共类修饰符 public : Java 语言中的可访问控制符只有一个: public ...
  • 在Java编程语言中有四种权限访问控制符,这四种访问...public能用来修饰类,在一个java源文件中只能有一个类被声明为public,而且一旦有一个类为public,那这个java源文件的文件名就必须要和这个被public所修饰的类...
  • C++ static 修饰符

    千次阅读 热门讨论 2021-05-05 22:40:55
    C++ static 修饰符是什么 & static 修饰符的使用场景以及用法.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 85,178
精华内容 34,071
关键字:

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