2. 程式人生 > 程式設計 >Java private修飾符失效的原因

Java private修飾符失效的原因

阿新 • • 發佈：2020-10-23

失效之Java內部類

在一個內部類裡訪問外部類的private成員變數或者方法。

	public class OuterClass {
 private String language = "en";
 private String region = "US";
 
 
 public class InnerClass {
  public void printOuterClassPrivateFields() {
   String fields = "language=" + language + ";region=" + region;
   System.out.println(fields);
  }
 }
 
 public static void main(String[] args) {
  OuterClass outer = new OuterClass();
  OuterClass.InnerClass inner = outer.new InnerClass();
  inner.printOuterClassPrivateFields();
 }
}

檢視原因

使用javap命令檢視一下生成的class檔案

	15:30 javap -c OuterClass
Compiled from "OuterClass.java"
public class OuterClass extends java.lang.Object{
public OuterClass();
 Code:
 0: aload_0
 1: invokespecial #11; //Method java/lang/Object."<init>":()V
 4: aload_0
 5: ldc #13; //String en
 7: putfield #15; //Field language:Ljava/lang/String;
 10: aload_0
 11: ldc #17; //String US
 13: putfield #19; //Field region:Ljava/lang/String;
 16: return
 
public static void main(java.lang.String[]);
 Code:
 0: new #1; //class OuterClass
 3: dup
 4: invokespecial #27; //Method "<init>":()V
 7: astore_1
 8: new #28; //class OuterClassInnerClass
 11: dup
 12: aload_1
 13: dup
 14: invokevirtual #30; //Method java/lang/Object.getClass:()Ljava/lang/Class;
 17: pop
 18: invokespecial #34; //Method OuterClassInnerClass."<init>":(LOuterClass;)V
 21: astore_2
 22: aload_2
 23: invokevirtual #37; //Method OuterClassInnerClass.printOuterClassPrivateFields:()V
 26: return
 
static java.lang.String access0(OuterClass);
 Code:
 0: aload_0
 1: getfield #15; //Field language:Ljava/lang/String;
 4: areturn
 
static java.lang.String access1(OuterClass);
 Code:
 0: aload_0
 1: getfield #19; //Field region:Ljava/lang/String;
 4: areturn
 
}

在這裡有一個OuterClass方法，

	static java.lang.String access0(OuterClass);
 Code:
 0: aload_0
 1: getfield #15; //Field language:Ljava/lang/String;
 4: areturn
 
static java.lang.String access1(OuterClass);
 Code:
 0: aload_0
 1: getfield #19; //Field region:Ljava/lang/String;
 4: areturn
 
}

根據註釋，可以知道access0返回outerClass的language屬性，access1返回outerClass的region屬性，並且這兩個方法都接受OuterClass的例項作為引數，

對這兩個方法進行反編譯。

15:37 javap -c OuterClassInnerClass
Compiled from "OuterClass.java"
public class OuterClassInnerClass extends java.lang.Object{
final OuterClass this0;
 
public OuterClassInnerClass(OuterClass);
 Code:
 0: aload_0
 1: aload_1
 2: putfield #10; //Field this0:LOuterClass;
 5: aload_0
 6: invokespecial #12; //Method java/lang/Object."<init>":()V
 9: return
 
public void printOuterClassPrivateFields();
 Code:
 0: new #20; //class java/lang/StringBuilder
 3: dup
 4: ldc #22; //String language=
 6: invokespecial #24; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
 9: aload_0
 10: getfield #10; //Field this0:LOuterClass;
 13: invokestatic #27; //Method OuterClass.access0:(LOuterClass;)Ljava/lang/String;
 16: invokevirtual #33; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
 19: ldc #37; //String ;region=
 21: invokevirtual #33; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
 24: aload_0
 25: getfield #10; //Field this0:LOuterClass;
 28: invokestatic #39; //Method OuterClass.access1:(LOuterClass;)Ljava/lang/String;
 31: invokevirtual #33; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
 34: invokevirtual #42; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
 37: astore_1
 38: getstatic #46; //Field java/lang/System.out:Ljava/io/PrintStream;
 41: aload_1
 42: invokevirtual #52; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
 45: return
}

下面程式碼呼叫access$0的程式碼,其目的是得到OuterClass的language 私有屬性。

13: invokestatic #27; //Method OuterClass.access$0:(LOuterClass;)Ljava/lang/String;

下面程式碼呼叫了access$1的程式碼，其目的是得到OutherClass的region 私有屬性。

28: invokestatic #39; //Method OuterClass.access$1:(LOuterClass;)Ljava/lang/String;

即，在內部類構造的時候，會有外部類的引用傳遞進來，並且作為內部類的一個屬性，所以內部類會持有一個其外部類的應用。
this$0就是內部類持有的外部類引用，通過構造方法傳遞引用並賦值。

final OuterClass this0;
 
public OuterClassInnerClass(OuterClass);
 Code:
 0: aload_0
 1: aload_1
 2: putfield #10; //Field this$0:LOuterClass;
 5: aload_0
 6: invokespecial #12; //Method java/lang/Object."<init>":()V
 9: return

繼續失效

public class AnotherOuterClass {
 public static void main(String[] args) {
  InnerClass inner = new AnotherOuterClass().new InnerClass();
  System.out.println("InnerClass Filed = " + inner.x);
 }
 
 class InnerClass {
  private int x = 10;
 }
 
}

和上面一樣，使用Javap反編譯一下

	16:03 javap -c AnotherOuterClassInnerClass
Compiled from "AnotherOuterClass.java"
class AnotherOuterClassInnerClass extends java.lang.Object{
final AnotherOuterClass this0;
 
AnotherOuterClassInnerClass(AnotherOuterClass);
 Code:
 0: aload_0
 1: aload_1
 2: putfield #12; //Field this0:LAnotherOuterClass;
 5: aload_0
 6: invokespecial #14; //Method java/lang/Object."<init>":()V
 9: aload_0
 10: bipush 10
 12: putfield #17; //Field x:I
 15: return
 
static int access0(AnotherOuterClassInnerClass);
 Code:
 0: aload_0
 1: getfield #17; //Field x:I
 4: ireturn
 
}

編譯器自動生成了一個access$0一次來獲取x的值
AnotherOuterClass.class的反編譯結果

16:08 javap -c AnotherOuterClass
Compiled from "AnotherOuterClass.java"
public class AnotherOuterClass extends java.lang.Object{
public AnotherOuterClass();
 Code:
 0: aload_0
 1: invokespecial #8; //Method java/lang/Object."<init>":()V
 4: return
 
public static void main(java.lang.String[]);
 Code:
 0: new #16; //class AnotherOuterClassInnerClass
 3: dup
 4: new #1; //class AnotherOuterClass
 7: dup
 8: invokespecial #18; //Method "<init>":()V
 11: dup
 12: invokevirtual #19; //Method java/lang/Object.getClass:()Ljava/lang/Class;
 15: pop
 16: invokespecial #23; //Method AnotherOuterClassInnerClass."<init>":(LAnotherOuterClass;)V
 19: astore_1
 20: getstatic #26; //Field java/lang/System.out:Ljava/io/PrintStream;
 23: new #32; //class java/lang/StringBuilder
 26: dup
 27: ldc #34; //String InnerClass Filed =
 29: invokespecial #36; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
 32: aload_1
 33: invokestatic #39; //Method AnotherOuterClassInnerClass.access0:(LAnotherOuterClassInnerClass;)I
 36: invokevirtual #43; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
 39: invokevirtual #47; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
 42: invokevirtual #51; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
 45: return
 
}

其中這句話，直接說明通過內部類的例項，獲取到私有屬性x的操作。

 invokestatic #39; //Method AnotherOuterClassInnerClass.access0:(LAnotherOuterClass$InnerClass;)I

在官網文件中是這樣說道的，如果（內部類的）成員和構造方法設定成了私有修飾符，當且僅當其外部類訪問時是允許的。

如何保證不被訪問

使用的方法相當簡單，使用匿名內部類的方法實現

public class PrivateToOuter {
 Runnable mRunnable = new Runnable(){
  private int x=10;
  @Override
  public void run() {
   System.out.println(x);
  }
 };
 
 public static void main(String[] args){
  PrivateToOuter p = new PrivateToOuter();
  //System.out.println("anonymous class private filed= "+ p.mRunnable.x); //not allowed
  p.mRunnable.run(); // allowed
 }
}

以上就是Java private修飾符失效的原因的詳細內容，更多關於Java private修飾符失效的資料請關注我們其它相關文章！

相關推薦

Java private修飾符失效的原因

失效之Java內部類 在一個內部類裡訪問外部類的private成員變數或者方法。 public class OuterClass {

Java訪問修飾符原理及程式碼解析

一、概述 訪問等級比較：public > protected > default > private 無論是方法還是成員變數，這四種訪問許可權修飾符作用都一樣

java oop 修飾符&關鍵字

一、修飾符 Java中四種訪問許可權修飾符： private 預設(default) protected public 修飾類的成員，用來限定物件對該類成員的訪問許可權。

java-abstract修飾符

abstract修飾符 1.語法 例子： package day11; public class TestShape { public static void main(String[] args) {

java-static修飾符

什麼是靜態？ 概念： 　　靜態可以修飾屬性和方法。 　　稱為靜態屬性（類屬性）、靜態方法（類方法）。

Java的修飾符

引言：Java的修飾符根據修飾的物件不同，分為類修飾符、方法修飾符、變數修飾符，其中每種修飾符又分為訪問控制修飾符和非訪問控制修飾符。訪問控制存在的原因：a、讓客戶端程式設計師無法觸及他們不應該觸及的部分

Java訪問修飾符

Java提供了許多訪問修飾符來設定類，變數，方法和建構函式的訪問級別。 四個訪問級別是 -

Java 預設修飾符的作用範圍及常用方法介紹

技術標籤：我的百寶箱日常小知識隨筆java 文章目錄 1. 類（class）可見性修飾符：修飾符：

Java功能修飾符static

技術標籤：Java Java修飾符系列筆記 訪問修飾符 static修飾符 final修飾符 Java訪問修飾符預設時的特例

06-Java訪問修飾符

6.1 訪問修飾符基本介紹 java提供了4種訪問修飾符來控制方法和成員變數的範訪問許可權:

java基礎——許可權修飾符（private）

private(私有許可權) 可以修飾成員變數①： 成員方法②： 構造方法③：   不能修飾類(外部類,內部類不考慮)

Java import匯入及訪問控制權限修飾符原理解析

這篇文章主要介紹了Java import匯入及訪問控制權限修飾符過程解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java四種許可權修飾符知識點詳解

Java中有四種許可權修飾符 public protected (default) private 同一個類 yes yes yes yes 同一個包

一文搞懂JAVA 修飾符

Java語言提供了很多修飾符，主要分為以下兩類： 訪問修飾符 非訪問修飾符 修飾符用來定義類、方法或者變數，通常放在語句的最前端。我們通過下面的例子來說明：

Java入門系列之訪問修飾符作用範圍

前言 之前以為Java和C#中訪問修飾符差不多一樣，後面才瞭解到還是有些差異，本節只講解學習Java中訪問修飾符一些需要注意的地方或者從概念上不太好理解我們會通過實際例子來說明，若有錯誤之處，還請批評指正。

Java—匿名物件/內部類/訪問修飾符/程式碼塊

匿名物件 　　匿名物件是指建立物件時，只有建立物件的語句，卻沒有把物件地址值賦值給某個變數。

2020/7/8 JAVA總結之：匿名物件/內部類/包的宣告與訪問/訪問修飾符/程式碼塊

一、匿名物件 　　　　1、匿名物件的概念： 　　　　　　　　匿名物件是指建立物件時，只有建立物件的語句，卻沒有把物件地址值賦值給某個變數。

5、Java 修飾符

引言：Java的修飾符根據修飾的對象不同，分為類修飾符、方法修飾符、變量修飾符，其中每種修飾符又分為訪問控制修飾符和非訪問控制修飾符。

Java基礎——static修飾符

static static在多種計算機語言在常有用到 static在java語言中作為修飾符也有著重要的地位

[Java基礎]static,final修飾符

一.static 　　1.static能修飾的範圍及語法: 　 class TestStatic{ static { } static class ClassStatic{