類外部訪問
1. c++在類定義的外部，可以被訪問
C public的類成員
可以作為虛函數的是普通函數，析構函數。
使用虛函數的時候，訪問規則是在聲明的時候被確定的，而不是在被「子類重寫」的時候，虛函數的訪問規則不會受到來自被重寫的子類函數的影響，當某個對象A的引用B用來調用該對象的虛函數時，對於該對象A的一切聲明信息，都取決於該對象的引用B，而不是這個引用所引用的對象A。
(1)類外部訪問擴展閱讀：
在C++中，類是支持數據封裝的工具，對象則是數據封裝的實現。C++通過建立用戶定義類支持數據封裝和數據隱藏。
在面向對象的程序設計中，將數據和對該數據進行合法操作的函數封裝在一起作為一個類的定義。對象被說明為具有一個給定類的變數。每個給定類的對象包含這個類所規定的若干私有成員、公有成員及保護成員。
完好定義的類一旦建立，就可看成完全封裝的實體，可以作為一個整體單元使用。類的實際內部工作隱藏起來，使用完好定義的類的用戶不需要知道類是如何工作的，只要知道如何使用它即可。
2. 內部類中的數據成員不能被外部類直接訪問。
class)，也稱為嵌入類(nested class)，它是定義在其他類的內部。內部類作為其外部類的一個成員，與其他成員一樣，可以直接訪問其外部類的數據和方法。只不過相比較外部類只有public和默認的修飾符不同，內部類作為一個成員，可以被任意修飾符修飾。編譯器在編譯時，內部類的名稱為OuterClass$InnerClass.class 。
1、內部類訪問數據變數
當在某些時候，內部類中定義的變數與外部類中變數名稱相同時，如何確保正確地訪問每一個變數呢？
1.1在main中直接從外部類調用內部類的方法
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(this); // the object created from the Inner
System.out.println(Outer.this); // the object created from the Outer
System.out.println(index); // output is 30
System.out.println(this.index); // output is 20
System.out.println(Outer.this.index); // output is 10
}
}
void print()
{
Inner inner = new Inner();//得到內部類的引用
inner.print();
}
}
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
outer.print();
}
}
在這里內部類Inner中關鍵字this指向內部類Inner的對象，如果要想指向外部類的對象，必須在this指針前加上外部類名稱，表示this是指向外部類構造的碎屑，如Outer.this 。
1.2在main中顯式返回內部類引用
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
Inner getInner()
{
return new Inner();//返回一個內部類的引用
}
}
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.getInner();
inner.print();
}
}
Inner是Outer的內部類，所以在類Test中必須用屬性引用符來標識出內部類。
1.3當main方法在Outer類內部
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
Inner getInner()
{
return new Inner();//返回一個內部類的引用
}
public static void main(String[] args)
{
Outer outer = new Outer();
Inner inner = outer.getInner(); // 注意此處變化
inner.print();
}
}
因為main方法在Outer內部，故可以直接引用，不需要屬性引用符。
1.4在main方法中直接產生內部類對象
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // 注意此處變化
inner.print();
}
}
在利用new構造方法構造一個外部類對象時，並沒有連帶著構造一個內部類對象，故需要訪問內部類方法時，必須使用new操作符為這個外部類對象再構造一個內部類對象。
2、局部內部類
在方法中定義的內部類是局部內部類，它只能訪問方法中的final類型的局部變數，因為用final定義的局部變數相當於是一個常量，延長了其生命周期，使得方法在消亡時，其內部類仍可以訪問該變數。另外，它同樣也可以引用定義在外部類的變數和方法。而且方法體中的局部內部類不允許有訪問修飾符。
class Outer
{
int num=10;
public void print(final int aArgs)
{
class Inner
{
int num=20;
public Inner()
{
System.out.println("This is Inner.");//此句可看出它與匿名內部類用法的不同。
}
public void print()
{
int num=30;
System.out.println(this); // the object created from the local Inner
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
System.out.println(aArgs);
}
}
Inner inner=new Inner();//此句必須放在定義類Inner的後面
inner.print();
}
public static void main(String[] args)
{
Outer outer=new Outer();
outer.print(40);
}
}
對於局部類的命名，不管是在一個方法中定義多個類還是在幾個方法中分別定義類，其編譯後命名是：OuterClass$1InnerClass.class
3、匿名內部類
匿名內部類作為一種特殊的內部類，除了具有普通內部類的特點，還有自己的一些獨有特性：
匿名內部類必須擴展一個基類或實現一個介面，但是不能有顯式的extends和implements子句；
匿名內部類必須實現父類以及介面中的所有抽象方法；
匿名內部類總是使用父類的無參構造方法來創建實例。如果是實現了一個介面，則其構造方法是Object()；
匿名內部類編譯後的命名為：OuterClass$n.class，其中n是一個從1開始的整數，如果在一個類中定義了多個匿名內部類，則按照他們的出現順序從1開始排號。
abstract class A
{
abstract public void sayHello();
}
class Outer
{
public static void main(String[] args)
{
new Outer().callInner(new A()
{
public void sayHello()
{
System.out.println(this); // the object created from the anonymous Inner
System.out.println("Hello!");
}
});
}
public void callInner(A a)
{
a.sayHello();
}
}
4、靜態內部類
和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部類的引用。除此之外，在任何非靜態內部類中，都不能有靜態數據，靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層）。不過靜態內部類中卻可以擁有這一切。這也算是兩者的第二個區別吧。一個靜態的內部類,才可以聲明一個static成員，靜態內部類可以訪問外圍類的靜態方法、成員（包括private static的成員）。靜態內部類實例化的時候不必先實例化外圍類，可以直接實例化內部類。而對於非靜態內部類則必須先實例化其外部類，才能再實例化本身。
5．內部類的繼承
當一個類繼承自一個內部類時，預設的構造器不可用。必須使用如下語法：
class WithInner
{
class Inner
{
public void sayHello()
{
System.out.println("Hello.");
}
}
}
public class Test extends WithInner.Inner
{
Test(WithInner wi)
{
wi.super();
}
public static void main(String[] args)
{
WithInner wi=new WithInner();
Test test=new Test(wi);
test.sayHello();
}
}
因為每一個內部類都有一個指向外部類的引用，在繼承一個內部類，必須先創建一個外部類，通過這個外部類引用來調用其內部類的構造方法。如果繼承的內部類是一個靜態內部類，則就不需要這樣，直接super()調用即可；
6、內部類的2種特殊用法
一個類從另一個類派生出來，又要實現一個介面。但在介面中定義的方法與父類中定義的方法的意義不同，則可以利用內部類來解決這個問題。
interface Machine
{
void run();
}
class Person
{
void run()
{
System.out.println("run");
}
}
class Robot extends Person
{
private class MachineHeart implements Machine
{
public void run()
{
System.out.println("heart run");
}
}
Machine getMachine()
{
return new MachineHeart();
}
}
class Test
{
public static void main(String[] args)
{
Robot robot = new Robot();
Machine m = robot.getMachine();
m.run();
robot.run();
}
}
在Robot類內部使用內部類MachineHeart來實現介面Machine的run方法。同時Robot類又繼承了父類Person的run方法。如果不使用內部類MachineHeart而使Robot直接實現介面Machine，則該如何調用父類的run方法？
利用內部類可解決c++中多重繼承所解決的問題
class A
{
void fn1()
{
System.out.println("It' s fn1.");
}
}
abstract class B
{
abstract void fn2();
}
class C extends A
{
B getB()
{
return new B()
{
public void fn2()
{
System.out.println("It' s fn2.");
}
};
}
}
class Test
{
public static void main(String[] args)
{
C c = new C();
c.fn1();
c.getB().fn2();
}
}
類C既要繼承類A又要繼承類B，則可將類B的定義放入類C內部，使之成為內部類。
一般情況下 當我們需要在某一情形下實現一個介面，而在另一情形下又不需要實現這個介面時，我們可以使用內部類來解決這一問題。讓內部類來實現這個介面。另外一個很好的理由是java內部類加上介面可以有效地實現多重繼承。
3. java裡面內部類可以訪問外部類以外的類的屬性嗎
可以,書寫也很簡單,帶上公開類名字即可!
4. Java：關於外部類訪問內部類成員的問題
\\外部類對象可以直接訪問內部類對象的成員變數和方法
你使用的這個方法的旨意是用非靜態的外部類實例化一個內部類對象，外部類能夠訪問成員內部類的成員變數和方法的唯一途徑就是通過實例化一個外部類的對象，然後這個對象通過 對象.makeInner（）來new一個Inner in，此過程調用了Inner（）這個內部類的構造函數。
其實你只是把順序搞錯了，編譯時不回去運行你的函數方法，也就是代碼中：
public void makeInner(){
Inner in = new Inner();
in.seeOuter();
}
這個越權的函數並未去執行訪問其所在類的內部類的成員函數：Inner（）;
且Outer並不是static，所以其只能實例化一個對象，然後對象.makeInner（）;這時處於運行時，此類的對象可以調用此類的內部類的成員方法和成員變數，自然可以調用Inner（）;
說的簡單點：你使用makeInner（）時一定是實例化一個Outer的對象了，不然你無法調用makeInner，對吧，運行makeInner時他一定是在Outer這個類的對象下運行的，Outer的對象是可以訪問其內部類Inner的變數和方法的。所以說：makeInner（）運行時你絕對已經創建了一個Outer的對象了。是這個對象的makeInner（）在運行，而這個Outer的這個對象是可以訪問Outer的內部類Inner的變數和方法的。編譯並非運行，編譯時Outer沒有實例化對象，但makeInner（）也沒被調用運行，所以他編譯時沒有去訪問內部類Inner的東東，等你運行時自然你已經實例化一個對象了，自然也就可以訪問了~~~
5. 外部類可以訪問內部類的方法以及靜態方法和數據域嗎
外部類，內部類，匿名類，外部類就是兩個類並列的class A {} class B {},內部類：class A { class B {}},B可以直接使用包涵它的類的成員變數，內部類不能被除包涵類以外的類調用；還有就是匿名類，也是內部類 classA{new {}}省略定義類名直接定義方法和使用，這個適用於代碼比較簡單且這個類不需要被其他類調用。
並且，外部類可以訪問內部類的方法以及靜態方法和數據域。
6. C++ 對象訪問類成員算是類外訪問還是類內訪問
舉個例子，假設有如下代碼：
classCA
{
public:
inta;
public:
CA(){a=7;}
};
intmain()
{
CAca;
intb=ca.a;
return0;
}
CA是一個類，ca是CA的一個實例，因此ca是CA的對象。
當你在main()函數中執行int b = ca.a;這句代碼時，是main()函數在訪問對象ca的成員變數a，而不是ca自己在訪問它自己的成員變數，這就是外部訪問。那麼，什麼是內部訪問呢？比如CA的構造函數CA()本身是對象ca的成員函數，在這個構造函數的內部也在訪問a，這就是ca自己在訪問自己的成員變數，這就是內部訪問。
簡單點說就是：
如果是在對象ca的外部，以ca.a的形式來訪問ca的成員變數a，這就是外部訪問；如果是ca自己的成員函數（包括但不限於它的構造函數）在訪問ca自己的成員變數，這就是自己訪問自己，是內部訪問。
7. java內部類怎麼訪問外部類的方法
在內部類使用this表示的是對內部類自身的引用，如果想要獲取外部類的引用，應當使用Outer.this，所以訪問外部類的方法：
Outer.this.xxxx()
8. 外部類如何訪問被封裝的類
一 對於外部類來說 內部類相當於它的一個屬性 內部類中的private也相當於它本身的private屬性 所以根據類內可見原則 內部類private是可以被外部類訪問的
二 你在主方法中直接new一個自身類 相當於是在聲明一個新的類 用這個新類去調用它的私有 你說是啥後果 對於jmv來說這就是典型的調用許可權失敗
9. 內部類可以訪問外部類的屬性和方法嗎
外部類名.this.外部類方法
內部類分為：有四種內部類
分別是：靜態內部類，成員內部類，局部內部累，匿名內部類。
匿名內部類因為沒有類名因此：
1.不能有構造方法
2.不能有任何靜態成員方法，或者類
3.不能用修飾符修飾，如public.private,protected
4.必須跟在new一個對象之後
10. C#中類的哪些成員可以在外部直接訪問
public無限制
internal,本項目內的所有類可以調用,其它項目想訪問,需要設置assibly.cs文件