精华内容
下载资源
问答
  • 访问修饰符protected的权限理解 在Core Java中这样一段话“在Object类中,clone方法被声明为protected,因此无法直接调用anObject.clone()。子类只能直接调用受保护的clone方法克隆它自己。为此,必须重新...

    2017-11-04 22:28:39

    • 访问权限修饰符的权限

    • 访问修饰符protected的权限理解

    在Core Java中有这样一段话“在Object类中,clone方法被声明为protected,因此无法直接调用anObject.clone()。子类只能直接调用受保护的clone方法克隆它自己。为此,必须重新定义clone方法,并将它声明为public,这样才能让所有的方法克隆对象”。但是不是所有的子类都可以访问受保护的方法吗?不是每个子类都是Object的之类吗?下面就用例子来说明下protected访问修饰符的问题。
    1、在package1中创建SuperClass.java文件,里面有一个protected方法:

        package package1;  
          
        public class SuperClass {  
            protected void method(){  
                System.out.println("This is a protected method in the super class .");  
            }  
        }  
    

     

     2、在同一个包中创建SubClass1.java文件,类SubClass1和类SubClass2均继承自SuperClass:

        package package1;  
          
        public class SubClass1 extends SuperClass {  
            public static void main(String[] args) {  
                SuperClass sup = new SuperClass();  
                SubClass1 sub1 = new SubClass1();  
                SubClass2 sub2 = new SubClass2();  
                sup.method();  //Compile OK  
                sub1.method();  //Compile OK  
                sub2.method();  //Compile OK  
            }  
        }  
        class SubClass2 extends SuperClass{  
              
        }  
    

    编译全部通过,不难理解,protected方法对同包中的类是可见的

     

    3、如果在另一个包package2中创建SubClass1.java文件,内容与包package1中的SubClass1.java内容相同。

        package package2;  
          
        import package1.SuperClass;  
          
        public class SubClass1 extends SuperClass {  
            public static void main(String[] args) {  
                SubClass1 sub1 = new SubClass();  
                SubClass2 sub2 = new SubClass2();  
                Sub1.method();  //Compile OK  
                sub2.method();  //Compile Error  
            }  
          
        }  
        class SubClass2 extends SuperClass{  
              
        }  
    

    这样编译器会在sub2.method()处报错误The method clone from the type SuperClass is not visiuable。这种情况下,sub1和sub2都从父类中继承到名为method()的protected方法,sub1.method()编译通过,而sub2.method()编译没有通过,因为sub2是他所在的类的父类的另一个子类。由此我们可以想到:不能在一个子类中访问另一个子类protected方法,尽管这两个子类继承自同一个父类

     

    4、如果我们在package2的SubClass1.class中重写SubClass2类中的SuperClass的method方法。

        package package2;  
          
        import package1.SuperClass;  
          
        public class SubClass1 extends SuperClass {  
            public static void main(String[] args) {  
                SubClass1 sub1 = new SubClass1();  
                SubClass2 sub2 = new SubClass2();  
                sub1.method();  //Compile OK  
                sub2.method();  //Compile OK  
            }  
          
        }  
        class SubClass2 extends SuperClass{  
            protected void method(){  
                super.method();  
            }  
        }  
    

    这种情况跟第一种类似,protected方法可以被同一个包中的类访问。当在SubClass2类中覆盖method()方法时,SubClass2类和SubClass1类在同一个包下,所以此protected方法对SubClass1类可见现在应该可以理解“为此,必须重新定义clone方法,并将它声明为public,这样才能让所有的方法克隆对象这句话了吧

     

    5、如果在子类中调用父类对象的protected方法

        package package2;  
          
        import package1.SuperClass;  
          
        public class SubClass extends SuperClass {  
            public static void main(String[] args) {  
                SuperClass sup = new SuperClass();  
                SubClass sub = new SubClass();  
                sup.method(); //Compile Error  
                sub.method();  //Compile OK  
            }  
          
        }  
    

    这里我在SubClass继承另一个包中的SuperClass,这个SuperClass中有一个名为method()的protected方法。在SubClass类中调用SubClass类的实例sub的method()方法,编译不会报错。而同样调用SuperClass类的实例sup的method()方法,编译报错!

    现在必须明确的是:类SubClass确实是继承了类SuperClass(包括它的method方法),所以在类SubClass中可以调用自己的method方法。但类SuperClass的protected方法对其不同包子类SubClass来说,是不可见的。

     

    转载于:https://www.cnblogs.com/TIMHY/p/7784931.html

    展开全文
  • protected修饰符总结

    2014-12-26 19:46:28
    晚上敲代码的时候,发现调用JTextField的protected getColumnWidth()方法报错。 看来自己以前对protected的理解是错误的,于是测试一下。 写一个父类和两个子类 public class A{ protected void a(){ System....

    晚上敲代码的时候,发现调用JTextField的protected getColumnWidth()方法报错。
    看来自己以前对protected的理解是错误的,于是测试一下。
    写一个父类和两个子类

    public class A{
        protected void a(){
            System.out.println("父类a方法");
        }
    }
    public class B1 extends A{
        public static void main(String[] args){
            new B2().a();
            new B1().a();
            new A().a();
        }
    }
    public class B2 extends A
        public static void main(String[] args){
            new B2().a();
            new B1().a();
            new A().a();
        }
    }


    写一个测试类
    public class Test {
        public static void main(String[] args){
            new B2().a();
            new B1().a();
            new A().a();
        }
    }


    B1与A放在同一个包中。三条语句都可以正常编译运行

    B2放在另一个包。只能调用自己的A方法。其他两条语句无法通过编译


    当测试类与A在同一个包中时,三条语句都可以正常编译运行。

    当测试类与A不在同一个包中时,三条语句均无法通过编译。 


    以上测试说明只要与父类在同一个包中,则可以调用父类和任意子类的该protected方法。

    如果与父类不同同一包中,则只有子类可以调用自己所继承的protected方法,其他情况均无法调用。


    展开全文
  • protexted访问修饰符,应该是访问修饰符中最难理解的一个修饰符.一般称之为受保护的访问权限. 其简单理解为protected修饰的成员对于本包和其子类可见. 但这不太够,往下可以引申为两点: 基类的protected成员是包内...

    protexted访问修饰符,应该是访问修饰符中最难理解的一个修饰符.一般称之为受保护的访问权限.

    其简单理解为protected修饰的成员对于本包和其子类可见.

    但这不太够,往下可以引申为两点:

    • 基类的protected成员是包内可见的,并且对子类可见;
    • 若子类与基类不在同一包中,那么在子类中,子类实例可以访问其从基类继承而来的protected方法,而不能访问基类实例的protected方法。

    解释:

    • 在一个引用类,和被引用类在一个包的时候,protected成员是可见的(不管是不是子类)

    • 子类如果不在一个包中,子类不能访问基类的protexted成员,但可以访问继承自基类的protexted成员

      形象的解释一下这话,假设你知道你父亲私房钱放在什么地方.当你和你父亲住在一起的时候,你可以去拿你父亲的私房钱用,此时这个钱,根属于你的父亲(你母亲如果知道你父亲私房钱的地址也可以去拿来用),但是如果一旦你们分家,你和别的人组成了新的家庭,你就不可以直接去父亲家里拿钱用了.你能用的,只有你父亲给你的钱,也就是你继承的钱,这时候这个钱是根属于你的.

    • 受保护,这三个字特别有意思,个人感觉,protected关键字的目的是为了保护数据只在同包和子类中能够被访问引用.就像是钱,这个玩意,只能一家人或者你的子女能够用,如果子女分家了,他们只能用自己继承了的钱.绝对不会有外人能够花这笔钱.

    如何判断可不可用

    光知道上面的定义,还不够,我们必须要还得了解怎么去判断,方法是:

    • 确定出该protected成员来自何方,其可见性范围是什么,然后就可以判断出当前用法是否可行了

    实例

    这有几个网上的例子,我做了部分的修改,我们可以来分析一下

    例子1

    package family1;
    public class Father {
        protected void Money() {}    // 父类Father1中的protected方法
    }
    
    package family1;
    public class Son1 extends Father{}
    
    package family1;
    public class mother {
        public static void main(String[] args) {
            Son1 son1 = new Son1();
            son1.Money(); // Compile OK     ----(1)
            son1.clone(); // Compile Error     ----(2)
            
            Son2 son = new Son11();    
        	son2.Money(); // Compile OK     ----(3)
       		son2.clone(); // Compile Error     ----(4)
    }
    
        
    package family2;
    public class Son2 extends Father{}
    
    • 首先来看 (1)为什么成立? son1的Money,追溯到根源,是谁的钱?是father的钱.那问题来了,father和mother是一family1的中的.所以mother当然可以用father的money啊.所以(1)是成立的

    • (3)和(1)是同理,虽然 son2 和mother不在一个family了,son2找到了老婆,但son2的money不是自己找的,是来源于father的,所以mother当然能用了.

    • (2)为什么错? 首先 clone()方法object中的方法.所以任何类都继承于object.那为什么(2)错呢?mother和son1在一个family中,都继承了clone,但mother是去那了son2的clone,但clone最终来源并不是和mother在一个family.有点绕

      搞个形象的解释.你父亲分别给了你和你兄弟没人一万块.结果你兄弟用完了钱,直接过来就把你的一万块给拿走了,你能够干?很明显不能,这钱是父亲给你的,你兄弟凭啥给你拿走,对吧?同理在(2)中 son2 的clone()是object给的,又不是mother给的,mother凭啥拿啊,就像你二舅要拿你爷爷给的压岁钱,你能给他?

    • (4)同理与(2)

    例子2

    package family1;
    class father {
        protected Object clone() throws CloneNotSupportedException{
           return super.money();
        }
    }
     
    package family2;
    public class son extends father {
        public static void main(String args[]) {
           father fa = new father();
           fa.money(); // Compile Error         ----(1)
     
           son s = new son();
           s.money(); // Complie OK         ----(2)
        }
    }
    
    • 看这里例子,首先为什么(1)错误.解释是:若子类与基类不在同一包中,那么在子类中,子类实例可以访问其从基类继承而来的protected方法,而不能访问基类实例的protected方法。不够简单易懂,但是我们可以从另一个想一下,如果你现在没钱了,但你father有钱,那咋办呢?去找father要啊,但你要怎么去要money呢?

      如果你直接把你father喊过来(实例化father对象),然后对他说,老头子,快给点钱花花,他能给吗?比不可能给啊

    • 那要咋办呢?也就是第二种方法,你先明确自己的地位,自己是个son(实例化自己),然后好声好气的跟father要钱。也就是第二种方法,所以(2)是对的

    • 二者的区别在于(1)方法是将自己当做外人,而(2)方法是将自己作为一家人。

    • 需要注意的是,也可采用super.money去要钱,也是可以的

    展开全文
  • 三种修饰符有何目标?

    千次阅读 2020-02-25 19:00:48
    修饰符的作用是在原有组件之上添加一些额外特性,修饰符有很多个,不同的修饰符所能修饰的组件不同,表现出的特性也不同; 多个修饰符可以一起使用,组件所表现的特性也会根据修饰符的数量不断叠加。 abstract可以...

    什么是修饰符?

    • 修饰符的作用是在原有组件之上添加一些额外特性,修饰符有很多个,不同的修饰符所能修饰的组件不同,表现出的特性也不同;
    • 多个修饰符可以一起使用,组件所表现的特性也会根据修饰符的数量不断叠加。

    abstract可以修饰什么?

    • 可以修饰类、方法,被修饰的类称之为抽象类,被修饰的方法称之为抽象方法

    抽象类如何定义?

    • 在class关键字前添加 abstract 修饰符:
      abstract 修饰符

    抽象类有什么特点?

    • 可以声明引用不能创建对象。

    抽象方法如何定义?

    • 在方法返回值前添加 abstract 修饰符,注意该方法不能有实现部分“{ }” :
      在这里插入图片描述

    抽象方法有什么特点?

    • 只有声明没有实现,必须存在于抽象类中。

    如何使用抽象类?

    1、编写一个类继承抽象类
    在这里插入图片描述
    2、覆盖父类中的所有抽象方法去掉abstract修饰符 添加实现部分“{ }”
    在这里插入图片描述
    3、使用多态语法创建对象,调用方法。
    在这里插入图片描述
    注意:如果子类没有覆盖父类中的抽象方法,那么子类也会“被迫”成为抽象类。

    static可以修饰什么?

    • 可以修饰属性、方法、初始化代码块,被修饰的属性称之为静态属性,被修饰的方法称之为静态方法,被修饰的初始化代码块称之为静态代码块。

    静态属性如何定义?

    定义属性时在数据类型前添加static修饰符:
    在这里插入图片描述

    静态属性有什么特点?

    • 静态属性是所有对象所共享的属性,不必创建对象,可以通过类名.属性名直接访问。

    静态方法如何定义?

    • 在方法的返回值前添加static 修饰符:
      在这里插入图片描述

    静态方法有什么特点?

    1、静态方法可以使用类名.方法名直接调用;
    2、静态方法与对象无关不能使用this或super关键字;
    3、在静态方法中只能访问静态属性与静态方法;

    静态代码块如何定义?

    • 在方法的返回值前添加static 修饰符:
      在这里插入图片描述

    静态代码块有什么特点?

    • 静态代码块会在《类加载》时执行,可以在静态代码块中初始化静态属性。

    什么是类加载?

    • 当虚拟机第一次使用某一个类时(new对象,调用静态成员,使用子类),虚拟机会将.class中的信息加载到内存中便于后续使用; 当基本信息加载完毕后会执行《静态代码块》中的语句。

    final可以修饰什么?

    • 可以修饰属性、局部变量、方法、类;被修饰的变量称之为常量,被修饰的属性称之为常亮属性;被修饰的方法为最终方法,被修饰的类为最终类。

    如何定义常量?

    • 方法中定义局部变量时,在数据类型前加入final修饰符:
      在这里插入图片描述

    常量有什么特点?

    • 只能被赋值一次且终身不能被修改(重新赋值)。

    如何定义常量属性?

    • 定义属性时,在数据类型前加入final修饰符:
      在这里插入图片描述

    常量属性有什么特点?

    • 只能赋值一次,没有默认值,必须手动赋值。
      手动直接赋值:
      在这里插入图片描述
      静态属性的赋值机会有三次,此赋值机会为最基本、最直接、最常用的。

    如何定义最终方法?

    • 在方法的返回值类型前加入 final 修饰符:
      在这里插入图片描述

    最终方法有什么特点?

    • 最终方法不能被子类所覆盖。

    如何定义最终类?

    • 在定义类时 class 关键字前加入 final:
      在这里插入图片描述

    最终类有什么特点?

    • 最终类不能被继承。

    什么修饰符可以连用?

    1、访问权限修饰符( private/default/protected/public)可以与 static、final连用。
    2、访问权限修饰符(private/default/protected)可以与 abstract 连用。
    3、static/final可以连用,通常会与public 一起来修饰属性, 用来表示公开静态常量。

    展开全文
  • Java四种访问权限, 其中三种访问权限修饰符,分别为private,public和protected,还有一种不带任何修饰符。 private: Java语言中对访问权限限制的最窄的修饰符,一般称之为“私有的”。被其修饰的类、属性以及...
  • 非访问控制符:抽象类修饰符 abstract ;最终类修饰符 final 1、公共类修饰符 public : Java 语言中类的可访问控制符只有一个: public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工具。供其它类...
  • 修饰符

    2020-11-17 20:17:14
    权限修饰符(public) 修饰符 同一个类中 同一个包中 子类与无关类 不同包的 子类 不同包的 无关类 private √ 默认 √ √ protected √ √ √ public √ √ √ √ package ...
  • 访问修饰符

    2017-09-12 22:42:36
    访问修饰符访问修饰符 概述 说明 继承中的特点概述
  • 访问权限 public protected default private 同一个类 yes yes yes yes 同一个包 yes yes yes no 子类 yes ...
  • 非访问控制符:抽象类修饰符 abstract ;最终类修饰符 final 1、公共类修饰符public: Java 语言中类 的可访问控制符只有一个: public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工具供其它类...
  • 修饰符

    2021-03-31 16:48:18
    非访问控制符:抽象类修饰符 abstract ;最终类修饰符 final 1、公共类修饰符 public : Java 语言中类的可访问控制符只有一个: public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工具。供其它类...
  • 由于所学的很多修饰符联用来修饰属性方法的问题,我做一个简单的修饰符总结,还拿出修饰符联用修饰方法和属性为什么不能修饰的例子来给大家一个便于记忆的方法和窍门! 一定要看三个修饰符的总结,真香警告! ...
  • 四种权限修饰符

    万次阅读 2018-06-09 13:54:30
    修饰符 权限修饰符: public protected 默认 private 状态修饰符: static 静态的意思,可以修饰成员变量,成员方法,不能修饰类,不能修饰构造方法 被修饰的变量,方法可以通过类名进行调用 final ...
  • 非访问控制符:抽象类修饰符 abstract ;最终类修饰符 final  1、公共类修饰符 public : Java 语言中类 的可访问控制符只有一个: public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工具供...
  • Java中各类修饰符的使用总结(看完这篇就够了)

    万次阅读 多人点赞 2018-06-07 18:45:24
    引言:Java的修饰符根据修饰的对象不同,分为类修饰符、方法修饰符、变量修饰符,其中每种修饰符又分为访问控制修饰符和非访问控制修饰符。访问控制存在的原因:a、让客户端程序员无法触及他们不应该触及的部分 b、...
  • 四种权限修饰符及其常见修饰符

    千次阅读 2018-12-29 22:46:17
    1、四种权限修饰符 private(私有的) , 默认 , protected(受保护的) , public(公共的) ; 结论: 本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类) private Y //被private修饰只能在本类中...
  • 一、修饰符 1.访问修饰符(access modifiers),如public/private等 成员的访问控制符 同一个类中 同一个包中 不同包中的子类 不同包中的非子类 private yes 默认(包可访问) ...
  • 1、 接口的修饰符只有:public ...非访问控制符:抽象类修饰符 abstract ;最终类修饰符 final 1、公共类修饰符 public : Java 语言中类 的可访问控制符只有一个: public 即公共的。每个
  • 成员和类的默认访问修饰符是 private。 公有(public)成员 公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值,可以直接通过对象来设置或读取公有变量的值。 私有(private)...
  • 3. 简述 private、 protected、 public、 internal 修饰符的访问权限。private : 私有成员, 在类的内部才可以访问。protected : 保护成员,该类内部和继承类中可以访问。public : 公共成员,完全公开,没有访问限制...
  • 类访问修饰符

    2019-03-25 15:14:03
    数据封装是面向对象编程的一个重要特点,它...关键字public、private、protected称为访问修饰符。一个类可以多个 public、protected 或 private 标记区域。 公有(public)成员 公有成员在程序中类的外部是可...
  • 内部类与权限修饰符

    2020-11-26 20:00:21
    在Java当中提供了四种权限修饰符,使用不同的访问权限修饰符修饰时,被修饰的内容会不同的访问权限。 public: 公共的 protected: 受保护的 (default): 默认不写 private:私有的 不同的权限...
  • C++——类访问修饰符

    2018-12-07 22:19:29
    类访问修饰符 数据封装是面向对象...关键字 public、private、protected 称为访问修饰符。 共有成员(public) 公有成员在程序中类的外部是可访问的。可以不使用任何成员函数来设置和获取公有变量的值 #in...
  • Java 中的修饰符

    2020-02-14 18:42:11
    Java 提供了一系列的修饰符,用于控制...访问修饰符的作用是可以让我们指定哪些类可以访问给定的类及其变量、构造函数和方法。 我们可以为类、类的构造函数、变量和方法分别指定访问修饰符修饰符通常放在语句的...
  • java基础—修饰符

    2019-09-24 16:38:25
    1、 类修饰符: public : Java 语言中类的可访问控制符只有一个: public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工具。供其它类和程序使用的应定义为 public 类。 abstract :凡是用 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,303
精华内容 6,921
关键字:

protected修饰符有何特点