Java内部类和私有字段的可见性 [英] Java Inner Class and Visibility of Private Fields

问题描述

直到今天我才意识到这一点，但是在Java中，私有字段在内部类上并不是真正的私有。您可以实例化一个类，并像访问公共字段一样访问这些字段。我的问题是为什么要用Java完成？哪些设计决策导致封装中断？

 公共类测试{
 public static void main（String [] args） {
 Inner inner = new Inner（）; 
 inner.data =测试; 
 System.out.println（inner.data）; 
 
 Inner1 inner1 = new Inner1（）; 
 inner1.data =测试; 
 System.out.println（inner1.data）; 
 
新测试（）； 
} 
 
 public test（）{
 Inner2 inner2 = new Inner2（）; 
 inner2.data =测试; 
 System.out.println（inner2.data）; 
 
 Inner3 inner3 = new Inner3（）; 
 inner3.data =测试; 
 System.out.println（inner3.data）; 
} 
 
私有最终课程Inner3 {
私有String数据； 
 
 public String getData（）{
 System.out.println（ Inner3.getData（））; 
个返回数据； 
} 
 
 public void setData（String data）{
 System.out.println（ Inner3.setData（String））; 
 this.data =数据； 
} 
} 
 
私有类Inner2 {
私有String数据； 
 
 public String getData（）{
 System.out.println（ Inner2.getData（））; 
个返回数据； 
} 
 
 public void setData（String data）{
 System.out.println（ Inner2.setData（String））; 
 this.data =数据； 
} 
} 
 
私有静态类Inner1 {
私有String数据； 
 
 public String getData（）{
 System.out.println（ Inner1.getData（））; 
个返回数据； 
} 
 
 public void setData（String data）{
 System.out.println（ Inner1.setData（String））; 
 this.data =数据； 
} 
} 
 
私有静态最终类Inner {
私有String数据； 
 
 public String getData（）{
 System.out.println（ Inner.getData（））; 
个返回数据； 
} 
 
 public void setData（String data）{
 System.out.println（ Inner.setData（String））; 
 this.data =数据； 
} 
} 
} 
  

解决方案

它有助于处理匿名类。他们可以访问周围的类（例如方法中的最终变量）。这样就避免了很多设置者/获取者，而这些设置者/获取者至少必须将程序包设为私有，从而与私有类进行更多的共享。 （大多数时候像我一样），只需使用静态私有类，然后这些私有类只能访问私有静态成员，这给我带来了更好的直觉。

I never realized this until today, but in Java private fields are not really private on inner classes. You can instantiate a class and access the fields as though they were public. My question is why was this done in Java? What design decisions led to what seems like a break in encapsulation? Are there any advantages to allowing this?

public class test {
    public static void main(String[] args) {
        Inner inner = new Inner();
        inner.data = "TEST";
        System.out.println(inner.data);

        Inner1 inner1 = new Inner1();
        inner1.data = "TEST";
        System.out.println(inner1.data);

        new test();
    }

    public test() {
        Inner2 inner2 = new Inner2();
        inner2.data = "TEST";
        System.out.println(inner2.data);

        Inner3 inner3 = new Inner3();
        inner3.data = "TEST";
        System.out.println(inner3.data);
    }

    private final class Inner3 {
        private String data;

        public String getData() {
            System.out.println("Inner3.getData()");
            return data;
        }

        public void setData(String data) {
            System.out.println("Inner3.setData(String)");
            this.data = data;
        }
    }

    private class Inner2 {
        private String data;

        public String getData() {
            System.out.println("Inner2.getData()");
            return data;
        }

        public void setData(String data) {
            System.out.println("Inner2.setData(String)");
            this.data = data;
        }
    }

    private static class Inner1 {
        private String data;

        public String getData() {
            System.out.println("Inner1.getData()");
            return data;
        }

        public void setData(String data) {
            System.out.println("Inner1.setData(String)");
            this.data = data;
        }
    }

    private static final class Inner {
        private String data;

        public String getData() {
            System.out.println("Inner.getData()");
            return data;
        }

        public void setData(String data) {
            System.out.println("Inner.setData(String)");
            this.data = data;
        }
    }
}

解决方案

It helps with anonymous classes. They gain access to the class around (like with final variables in methods). Thus avoids a lot of setters/getters which you else had to make at least package private and thus sharing with more than the private class.

If you do not like that behaviour (like me most of the times), just use static private classes who then only have access to private static members which leaves me with a better gut feeling.

这篇关于Java内部类和私有字段的可见性的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！