人们对 Java 中的 protected 与继承有什么误解？

小鱼儿 2021-09-25 11:50 245阅读 0赞

### 人们对 Java 中的 protected 与继承有什么误解？ ###

*  调用方取决于调用方法所属对象还是调用方法所处位置
 *  Java 的访问控制修饰符
 *  平常所说的 protected 的子类可见实际指的是什么

在 Java 中，访问控制修饰符 protected 给许多人带来了混淆，因为它不仅涉及继承，还涉及包。不过，protected 也有自身在设计上的问题，向来为世人所诟病。在详解这个关键字之前，首先来理清什么是调用。

# 调用方取决于调用方法所属对象还是调用方法所处位置 #

调用，这是一个很基础的词汇，很多人都以为自己弄清了，可事实是他们有时候才如此。请看下面这段代码。假设下面的函数 main 位于一个无关紧要的类中，方法 nextInt 的调用方是谁？

/** * 假设此函数 main 位于一个无关紧要的类中 */
        public static void main(String[] args) { 
            var generator = new Random();
            var randomNum = generator.nextInt(100); // 方法 nextInt 的调用方是谁？
            System.out.println(randomNum);
        }

很多人会不假思索地认为方法 nextInt 的调用方是 generator。他们有一个理所应当但经不起推敲的理由：`generator.nextInt(100)`。因为 nextInt 是 generator 的方法，所以 nextInt 的调用方是 generator。

实际上，调用方应该按调用函数在被调用时所处的位置来算。此处它位于函数 main 中，因此可以说调用方为函数 main，或者更古板一些，说成方法 nextInt 被调用处的那段代码。为什么说调用方不是对象 generator 呢？因为 generator 只是找到函数 nextInt 的一种途径，应该说，generator 才有直接访问函数 nextInt 的权限。这有点类似于快递员。你是从快递员那里拿到快递的，但寄快递这个行为不是快递员发起的。反过来也很好理解。因为调用方法 nextInt 总是要通过对象 generator 的，总不能认为在任何地方调用方法 nextInt，调用方都是 generator 吧！这样的话，调用方一词也失去了意义。

记住，非关键字的对象一定不会成为调用方，**调用方由调用方法所处位置决定**。

# Java 的访问控制修饰符 #

Java 的访问控制多达 4 种。其中，对类有 4 种，对类成员有 4 种。但要记住，首先，**访问控制是对调用方的限制**，关于什么是调用方，前面已有说明。其次，访问控制永远是对外部来说的。不管使用什么访问控制修饰符，**对内都是不存在访问限制的**。或者说，不管使用什么访问控制修饰符，对内永远都是 public。不仅如此，**调用方只要和被调用方所属对象属于同一个类，则调用方拥有该对象关于该类的任何成员的访问权限**。

对类成员的访问控制：

*  private：对任何其它非本类内部类的类都不可见。
 *  public：对任何类都可见。
 *  protected：对同一包的类可见、子类可继承。
 *  无修饰符：对同一包的类可见。
    
    --------------------

对类的访问控制与对类成员的访问控制效果类似，但因为类种类的复杂性，这里不再概括，只是给出相应的对修饰符的使用限制。

<table> 
 <thead> 
  <tr> 
   <th align="center">类的类型\修饰符类型</th> 
   <th align="center">无修饰符</th> 
   <th align="center">public</th> 
   <th align="center">private</th> 
   <th align="center">protected</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">普通的类（非内部类的类）</td> 
   <td align="center">√</td> 
   <td align="center">√</td> 
   <td align="center">×</td> 
   <td align="center">×</td> 
  </tr> 
  <tr> 
   <td align="center">成员内部类、静态内部类</td> 
   <td align="center">√</td> 
   <td align="center">√</td> 
   <td align="center">√</td> 
   <td align="center">√</td> 
  </tr> 
  <tr> 
   <td align="center">局部内部类、匿名内部类</td> 
   <td align="center">√</td> 
   <td align="center">×</td> 
   <td align="center">×</td> 
   <td align="center">×</td> 
  </tr> 
 </tbody> 
</table>

# 平常所说的 protected 的子类可见实际指的是什么 #

为了便于说明，下面构造了三个类，这三个类均位于不同的源文件中。其中，类 Lover 继承了 Friend，但不与其在同一个包中。类 Wife 与 Friend 位于同一个包中，但它们之间没有继承关系。

package home;
    
    public class Friend { 
        private String changeMe() { 
            return "Well, next time.";
        }
    
        protected String nickname() { 
            return "dog";
        }
    
        protected String getMoney() { 
            return "Here you are.";
        }
    
        public static void main(String[] args) { 
            var myFriend = new Friend();
    
            System.out.println(myFriend.changeMe()); // Well, next time.
            System.out.println(myFriend.nickname()); // dog
            System.out.println(myFriend.getMoney()); // Here you are.
        }
    }

package hotel;
    
    import home.Friend;
    
    public class Lover extends Friend { 
        protected String nickname() { 
            return "little dog";
        }
    
        public void testUs() { 
            var myFriend = new Friend();
            System.out.println(myFriend.changeMe()); // compile error!
            System.out.println(myFriend.nickname()); // compile error! notice!
            System.out.println(myFriend.getMoney()); // compile error! notice!
    
            var myLover = new Lover();
            System.out.println(myLover.changeMe()); // compile error!
            System.out.println(myLover.nickname()); // little dog
            System.out.println(myLover.getMoney()); // Here you are.
    
            System.out.println(((Friend)myLover).nickname()); // compile error! notice!
            System.out.println(((Friend)myLover).getMoney()); // compile error! notice!
        }
    
        public static void main(String[] args) { 
            var lover = new Lover();
            lover.testUs();
        }
    }

package home;
    
    public class Wife { 
        public static void main(String[] args) { 
            var husband = new Friend();
    
            System.out.println(husband.changeMe()); // compile error!
            System.out.println(husband.nickname()); // dog
            System.out.println(husband.getMoney()); // Here you are.
        }
    }

可以看出，虽然类 Lover 继承了 Friend，但它却不能使用一个类型为 Friend 的对象的 protected 方法，但与类 Friend 位于同一包的 Wife 却可以。另外一个有意思的现象是，将一个 Lover 对象向下转换（downcasting）成 Friend 对象，居然变得连 Lover 对象的重写方法也不能访问了。可以说，这些一个设计上的缺陷。此外，人们对 Java 中的 protected 也有些误解。实际上，**protected 并未对子类提供任何额外的访问权限**！protected 与 private 关于子类的区别只是，protected 将方法“交给”了子类。这就是说，相对 private，**protected 的作用只是，让子类隐式定义了一个一模一样的方法**，仅此而已。而之所以看起来，子类可以访问基类的方法，只是前面所提到的“`调用方只要和被调用方所属对象属于同一个类，则调用方拥有该对象关于该类的任何成员的访问权限`”的具体体现而已。protected 让基类的方法变成了子类的方法，然后子类自己可以访问自己的方法，就这么简单！换句话说，**继承实际上并不能让子类访问基类的方法**，只是用来减少代码的重复。这就是为什么无法使用 Object 对象的方法 clone 对任意对象进行复制（这里指的是将任意对象先向下转换成 Object，然后再调用方法 clone 来复制）。另外，接口中不能声明 protected 方法的原因也是如此（面向接口编程时，使用接口引用变量无法调用该接口的保护方法）。

不过，对包来说并不是如此，可以看出，类 Friend 与 Wife 位于同一个包中，但类 Friend 与其没有继承关系，也没有定义在同一个源文件中，但类 Friend 却可以访问 Wife 对象的方法。这有什么问题呢？设想这样的一种情况，有一个禁止继承的类，它有一个 protected 方法。原该类的作者希望该类的 protected 方法对外不公开，但该类的作者不能将其改为 private，原因是该方法在该类的基类就已经被定义为 protected，而子类方法的被访问权限不能低于超类方法，因此该作者选择对类使用 final 来阻止继承访问。不过，由于 protected 对包的可见性，该作者大概不能完全如愿。如果定义一个有与该类所属包相同包名的类，就可以轻松访问该类的 protected 方法，这相当于给黑客留了一个后门。因此，从 JDK 1.2 开始，类加载器开始禁止加载包名以“java.”开头的用户自定义类。不过话说回来，不能依赖访问控制修饰符来杜绝所有的不正当访问的问题，因为可以还通过反射等手段来绕过这些权限限制。访问控制修饰符只是反映了类作者对使用该类的一种建议，还要依靠使用者自己遵循契约精神，才能有效防止滥用。