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

    2019-07-26 17:43:21
    访问修饰符: public: 共享修饰符,所有的类都可以访问public修饰符修饰的资源。 protected: 受保护的修饰符,同一个包或继承的子类可以访问由protected修饰符修饰的资源 default: 默认修饰符,在定义时不...

    访问修饰符:

    public:

    共享修饰符,所有的类都可以访问public修饰符修饰的资源。

    protected:

    受保护的修饰符,同一个包或继承的子类可以访问由protected修饰符修饰的资源

    default:

    默认修饰符,在定义时不使用修饰符时,系统就会默认当前资源是被默认修饰符修饰,该资源可以被同一个包中的其他类访问

    private:

    私有修饰符,由private关键字修饰的资源只能被当前类所访问,其他类不能够访问该资源。

    在这里插入图片描述

    展开全文
  • 一、访问修饰符访问修饰符 访问修饰符类内访问包内访问包外仅子类访问包外访问非子类 private Y N N N Default Y Y N N protected Y Y Y N public Y Y Y Y ...
    一、访问修饰符
    类访问修饰符
    访问修饰符类内访问包内访问包外仅子类访问包外访问非子类
    private Y N N N
    Default Y Y N N
    protected Y Y Y N
    public Y Y Y Y
     
    接口的访问修饰符:public
     
    二、非访问修饰符
    类的非访问修饰符:abstract、final
    属性的非访问修饰符:static、final、volatile、transient
    方法的非访问修饰符:abstract、static、final、native、synchronized

    转载于:https://www.cnblogs.com/wzdnwyyu/p/11095679.html

    展开全文
  • 访问修饰符访问修饰符 修饰符用来定义类、方法或者变量,通常放在语句的最前端。我们通过下面的例子来说明: public class className { // ... } private boolean myFlag; static final double weeks = ...

    1.Java语言提供了很多修饰符,主要分为以下两类:

        访问修饰符

        非访问修饰符

        修饰符用来定义类、方法或者变量,通常放在语句的最前端。我们通过下面的例子来说明:

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

     

    2.访问控制修饰符

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

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

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

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

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

    我们可以可以通过以下表来说明访问权限:

    修饰符

    当前类内部

    同一包内

    子孙类

    其他包

    其他包子孙类

    public

    Y

    Y

    Y

    Y

    Y

    protected

    Y

    Y

    Y

    N

    Y/N

    default(缺省)

    Y

    Y

    N

    N

    N

    private

    Y

    N

    N

    N

    N

     

    3.非访问修饰符

    为了实现一些其他的功能,Java 也提供了许多非访问修饰符。

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

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

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

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

     

    3.1 static 修饰符

    静态变量:

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

    静态方法:

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

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

    如下例所示,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");
          for (int i = 0; i < 500; ++i){
             new InstanceCounter();
              }
          System.out.println("Created " +
          InstanceCounter.getCount() + " instances");
       }
    }
    以上实例运行编辑结果如下:
    Started with 0 instances
    Created 500 instances
    

     

    3.2 final 修饰符

        final从字面上理解含义为“最后的,最终的”。在Java中也同样表示出此种含义。final可以用来修饰变量(包括类属性、对象属性、局部变量和形参)、方法(包括类方法和对象方法)和类。

    ① final修饰类:

        final修饰类即表示此类已经是“最后的、最终的”含义。因此,用final修饰的类不能被继承,即不能拥有自己的子类。

        如果视图对一个已经用final修饰的类进行继承,在编译期间或发生错误。

    ② final修饰方法:

        final修饰的方法表示此方法已经是“最后的、最终的”含义,亦即此方法不能被重写(可以重载多个final修饰的方法)。

        此处需要注意的一点是:因为重写的前提是子类可以从父类中继承此方法,如果父类中final修饰的方法同时访问控制权限为private,将会导致子类中不能直接继承到此方法,因此,此时可以在子类中定义相同的方法名和参数,此时不再产生重写与final的矛盾,而是在子类中重新定义了新的方法。

    public class B extends A {
     
         public static void main(String[] args) {
     
         }
     
         public void getName() {
             
         }
     }
     
     class A {
     
         /**
          * 因为private修饰,子类中不能继承到此方法,因此,子类中的getName方法是重新定义的、
          * 属于子类本身的方法,编译正常
          */
         private final void getName() {
             
         }
     
         /* 因为pblic修饰,子类可以继承到此方法,导致重写了父类的final方法,编译出错
         public final void getName() {
         
         }
         */
     }
    

    ③  final 修饰变量:

        final修饰的变量表示此变量是“最后的、最终的”含义。一旦定义了final变量并在首次为其显示初始化后,final修饰的变量值不可被改变。

    3.3 abstract 修饰符:后续讲解

    3.4 synchronized 修饰符:后续讲解

    3.5 transient 修饰符:后续讲解

    3.6 volatile 修饰符:后续讲解

     

     

    4.说明

    4.1 static 修饰符 : 代表静态的,可用于修饰  属性、方法、代码块,内部类。

    (1) static 修饰的属性(静态变量或类变量):

        ① 随着类的加载而加载,随着类的消失而消失(生命周期最长)。

        ② static修饰的属性被所有该类的对象所共享

        ③ 一旦某个对象改变该属性值,其他对象该属性值也会随之改变

        ④ 静态变量的存在优先于对象

        ⑤ 可以通过 "类名.类变量"的方式调用

    (2) static 修饰的方法(静态方法或类方法):

        ① 随着类的加载而加载

        ② 静态方法的存在优先于对象

        ③ 可以通过"类名.类方法"的方式调用

        ④ 静态方法中不能调用非静态成员

        ⑤ 静态方法不能使用 this 和 super

    (3) static 修饰的代码块

    ① 静态代码块

    ① 格式:  static{}

    ② 随着类的加载而加载,并且只加载一次

    ③ 静态代码块的执行优先于非静态代码块

    ④ 静态代码块中不能调用非静态成员

    ⑤ 静态代码块可以有多个,依次向下的顺序执行

    ② 非静态代码块

    ① 格式:类中的一对 {}

    ② 在每次创建对象时被调用

    ③ 非静态代码块的执行优先于构造器

    ④ 用于为对象初始化。(通常为共性内容进行初始化)

    ⑤ 非静态代码块可以有多个,依次向下的顺序执行

    (4) 内部类

    ① 静态内部类

    public class Hello {
        static int a = 2; 
           public static void main(String[] args){
                //  new newHello().count(); 
                System.out.println(new newHello().b); 
            }  
           public static class newHello{ 
               int b = 3; 
               public void count(){   
               System.out.println(a); 
               }     
           }  
    }
    

    ② 非静态内部类

    public class Hello {
        int a = 2;
        public static void main(String[] args){
            new Hello().new newHello().count();
        }
       public class newHello {
           public void count(){
               new Hello().a = 1;
               System.out.println("aaa");
           }
       }
    }
    

    (5) 为属性赋初始值的方式顺序:

        ① 默认赋值

        ② 直接显示赋值

        ③ 代码块(静态代码块 非静态代码块)

        ④ 构造器

     

    4.2 final 修饰符:代表最终的,可用于修饰方法 变量、类。

        ① final 修饰的类不能被继承

        ② final 修饰的方法不能被重写

        ③ final 修饰的变量叫常量,一旦被赋值,值不能改变。       

    说明:命名规范

        ① 所有字母都大写,每个单词之间以 "_” 分隔

        ② 常量没有默认值。在使用前必须赋值(直接显示赋值、构造器、代码块)

        ③ 若选择使用构造器为常量赋值,必须保证“所有”构造器都为常量赋值。          

     

    4.3 联合使用 static final

         适用范围:只能修饰成员变量、方法、内部类。

         成员变量:属于类的变量且只能赋值一次。

         方法:属于类的方法且不可以被重写。

         内部类:属于外部类,且不能被继承。

        static和final的意义是不同的,static修饰的时候代表对象是静态的,而final修饰的时候代表对象只能赋值一次,他们连用的时候是因为定义的那个对象既要它是静态的,也要求它的值不能再被修改。

        举例说明:

        static int a=1;

        static final b=1;

        这里a和b的区别在于,a在程序里可以被重新赋值为2或3或等等的整数,而b在程序里不能被重新赋值,b永远都为1,也就是说b是一个常量。

        final int c=1;    

        static final b=1;

        这里c和b的区别在于,b存放在静态空间,不会在程序运行时被释放,它永远占着内存直到程序终止,而c在程序用完它而不会再用到它的时候就会被自动释放,不再占用内存。

        当一个常数或字符串我们需要在程序里反复反复使用的时候,我们就可以把它定义为static final,这样内存就不用重复的申请和释放空间。

    展开全文
  • Java修饰符简单整理Java修饰符访问权限修饰符public 公有访问修饰符protected 受保护的访问修饰符default 默认访问修饰符private 私有访问修饰符abstract抽象修饰符abstract修饰类abstract修饰方法示例代码final最终...

    简单整理Java修饰符

    此为期末考试前复习整理的Java修饰符知识。目前学校的Java课程学习只是浅尝辄止,为了以后方便复习,根据课堂学习进行简单整理。

    1、访问权限修饰符

    public 公有访问修饰符

    • 可被所有其他类访问

    protected 受保护的访问修饰符

    • 该类本身、同一包中的其他类、其他包中的该类子类

    default 默认访问修饰符

    • 类的成员不添加任何修饰符时,默认为default。 同一包中的类可访问。

    private 私有访问修饰符

    • 只有该类本身可访问

    2、abstract抽象修饰符

    abstract修饰符可用来修饰类和类的方法。

    abstract修饰类

    abstract修饰的类为抽象类。

    • 抽象类不能实例化,声明抽象类是为了将来对该类进行扩充。
    • 含有抽象方法的类必须声明为抽象类,而抽象类中允许含有非抽象方法。
    • 抽象类可以不包含抽象方法。
    • 抽象类可从抽象类和非抽象类继承。

    abstract修饰方法

    abstract修饰的方法为抽象方法

    • 抽象方法没有具体实现,抽象方法的具体实现由继承它的子类提供。 也就是说抽象类中的抽象方法不写出方法体形参列表后直接以“;”结尾
    • 继承抽象类的子类,要么必须实现所有的继承来的抽象方法,要么声明为抽象类(此情况允许含有抽象方法)。

    示例代码

    abstract class Son{
    	private int x;
    	public abstract int max(); //抽象类中的抽象方法
    }
    
    class Father extends Son{
    	public int max(){
    		/*抽象方法由子类实现;
    		子类实现抽象方法时,不再写abstract修饰符;
    		*/
    	}
    }
    
    

    3、final最终修饰符

    final修饰符可修饰类、方法和变量

    final修饰变量(表示常量)

    • final修饰的变量可看为常量,一旦被赋值便无法更改
    //直接定义a为常量
    final int a=3; 
    
    // 先定义后赋值,赋值后变量的值不再改变
    final int a;
    a=3;
    

    final修饰类(表示最终类)

    • final修饰的类为最终类,最终类不能被继承。
    • 因为abstract修饰的类为抽象类可以被继承,所以一个类不能同时被final 和abstract修饰
    final class person{
    	//该类无法被继承
    }
    

    final修饰类的方法

    • final修饰的方法可以被子类继承,但不能被覆盖(重写)
    • 可防止父类方法内容被篡改修改
    class Son{
    	public final void speak(){
    		//该方法不能被子类覆盖
    	}
    }
    

    4、接口及其成员的访问属性

    接口是一类特殊的类,其访问修饰符的与类一致。接口的成员有默认的访问修饰权限。
    相关内容整理在另一文中

    展开全文
  • 访问修饰符 static修饰符 final修饰符 abstract修饰符 synchronized修饰符 transient修饰符 volatile修饰符 Java语言提供了很多修饰符,主要分为以下两类: 访问修饰符 (4种) 非访问修饰符(6种) 访问...
  • 参考链接: Java中的可访问和非访问修饰符 Java语言提供了很多修饰符,主要分为以下两类: 访问修饰符 Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。 非...
  • 什么是访问修饰符 (1)访问修饰符就是用来设置控制封装的这个目标的权限范围 (2)权限范围:这个目标可以被哪些对象在什么地方可以访问到这个目标的数据 1.public(公有,访问权限最大) (1).public访问修饰符允许一个类...
  • java的访问修饰符与修饰符 类 访问修饰符 修饰符 class 类名 extends 父类名 implement 接口名 例如: public final class student 访问修饰符 1、public:公共类 2、默认:可以不写,在同一个包中使用 修饰符 1、...
  • 1 访问修饰符 2 非访问修饰符 访问控制四个修饰符 访问控制修饰符定义类、变量、方法的访问权限。Java支持4种访问控制修饰符:public, protected, default, private. public:修饰类、接口、方法、变量,所修饰的...
  • 私有访问修饰符是最严格的访问级别,所以被声明为private的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为private。private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。 public ...
  • Java中各种修饰符与访问修饰符 类: 访问修饰符修饰符class 类名称 extends 父类名称 implement 接口名称 (访问修饰符与修饰符的位置可以互换) 访问修饰符 名称 说明 备注 ...
  • Java访问修饰符

    万次阅读 多人点赞 2019-09-28 22:27:17
    Java中,可以使用访问修饰符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。 分类 private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类) default (即缺省,...
  • 修饰符用来定义类、方法或者变量,通常放在语句的...访问修饰符访问修饰符 访问控制修饰符 Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。 1.默认的,也称为d...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,838
精华内容 10,335
关键字:

访问修饰符