① C#里,一個類嵌套另一個類有什麼好處
1、從作用域的角度看，嵌套類被隱藏在外圍類之中，該類名只能在外圍類中使用。如果在外圍類的作用域內使用該類名時，需要加名字限定。
2、從訪問許可權的角度來看，嵌套類名與它的外圍類的對象成員名具有相同的訪問許可權規則。不能訪問嵌套類的對象中的私有成員函數，也不能對外圍類的私有部分中的嵌套類建立對象。
3、嵌套類中說明的成員不是外圍類中對象的成員，反之亦然。嵌套類的成員函數對外圍類的成員沒有訪問權，反之亦然。國此，在分析嵌套類與外圍類的成員訪問關系時，往往把嵌套類看作非嵌套類來處理.
由引可見，嵌套類僅僅是語法上的嵌入。
② 簡述 private、 protected、 public、 internal 修飾符的訪問許可權。
public：類或成員可以由同一程序集中的任何其他代碼或引用它的另一個程序集訪問。
private：只能通過同一個類或結構中的代碼訪問類型或成員。
protected：類或成員只能由同一個類中的代碼訪問，或者在從該類派生的類中訪問。
internal：類或成員可以由同一程序集中的任何代碼訪問，但不能從另一個程序集訪問。
(2)嵌套類訪問許可權擴展閱讀：
private、 protected、 public、 internal 修飾符除了可以單獨使用，還可以組合使用。
protected internal：訪問僅限於從包含類派生的當前程序集或類型。
private protected： 訪問僅限於從當前程序集中的包含類派生的包含類或類型。
除了使用protected internal或private protected組合時，成員或類只允許使用一個訪問修
飾符。名稱空間上不允許訪問修飾符。命名空間沒有訪問限制。
根據成員聲明發生的上下文，僅允許某些聲明的可訪問性。如果在成員聲明中未指定訪問修飾
符，則使用默認輔助功能。
頂級類型（不嵌套在其他類型中）只能具有internal或public可訪問性。這些類型的默認可訪
問性是internal。
③ Java內部類的問題
什麼是內部類
在一個類內部的類，我們稱之為內部類。
內部類可以很好地實現隱藏，一般的非內部類是不允許有 private 與 protected 許可權的，但內部類可以。內部類擁有外圍類的所有元素的訪問許可權。
內部類分類：
內部類可以分為：實例內部類、靜態內部類和成員內部類，每種內部類都有它特定的一些特點。
在類 A 中定義類 B，那麼類 B 就是內部類，也稱為嵌套類，相對而言，類 A 就是外部類。如果有多層嵌套，例如類 A 中有內部類 B，而類 B 中還有內部類 C，那麼通常將最外層的類稱為頂層類（或者頂級類）。
④ 在C#中類，結構，介面，枚舉及嵌套類型等的默認訪問修飾符及其成員默認訪問修飾符分別是什麼
在類里定義的不管是什麼如果你什麼都沒有加就默認是private，在類的這個級別中是public
⑤ 關於C++中頭文件循環包含的問題
互相嵌套的情況
在每個h文件中
比如 a.h中 有A類 使用B類
b.h中有B類 使用A類。
那麼 在b.h的最上面 聲明A類。
class A;
就這一句。
在a.h中，最上面同樣加
class B;
這樣就不會報錯了。
不過 最好設計成不互相包含的情況。
⑥ 在類中如何實現類的嵌套
java中類嵌套就是內部類，下面給你一個例子，解釋了各種內部類的內容和應用：
import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.TextField;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
/**
* java內部類
*
* 內部類是指在一個外部類的內部在定義一個類
* 內部類作為外部類的一個成員，並且依附外部類而存在。
* 內部類可以為靜態，可用protected和private修飾（而外部類不可以，外部類只能用public和default）。
* 分類：成員內部類、局部內部類、靜態內部類、匿名內部類。
* @author Administrator
*
*/
public class Outer {
/**
* 成員內部類 代碼
*/
private static int i=1;
private int j=10;
private int k=20;
public static void outer_f1(){
}
public void outer_f2(){
}
/**
* 外部類的非靜態方法訪問成員內部類
*/
public void outer_f3(){
Inner inner=new Inner();
inner.inner_f1();
}
/**
* 外部類的靜態方法訪問成員內部類
*/
public static void outer_f4(){
//step1 建立外部類對象
Outer outer=new Outer();
//step2 根據外部類對象建立內部類對象
Inner inner=outer.new Inner();
//step3 訪問內部類方法
inner.inner_f1();
}
/**
* 成員內部類
* 作為外部類的一個成員存在，與外部類的屬性、方法並列。
* 優點：
* 1、內部類作為外部類的成員，可以訪問外部類的私有成員或屬性。（即使聲明為private，但是對於處於其內部的內部類還是可見的。）
* 2、可以內部類定義在外部類不可訪問的屬性。這樣就在外部類中實現了比外部類private還要小的額訪問許可權。
* 注意：
* 1、內部類是一個編譯時的概念，一旦編譯成功，就會成為完全不同的兩個類。
* 對於一個名為Outer的外部類和其內部定義的名為Inner的內部類。編譯完成後出現Outer.class 和 Outer$Inner.class 兩個類
* 2、當Outer是一個private類時，外部類對於其外部訪問是私有的，所以就無法建立外部類對象，進而也無法建立內部類對象。
* @author Administrator
*
*/
class Inner{
//static int inner_i=100; 內部類中不允許定義靜態變數，內部類作為外部類的一個成員，成員內部不允許定義靜態變數.
int j=100;//內部類和外部類的實例變數可以共存
private int inner_i=1;
void inner_f1(){
System.out.println(inner_i);
System.out.println(j);//在內部類中訪問內部類自己的變數直接使用變數名
System.out.println(this.j);//或者使用this.變數名
System.out.println(Outer.this.j);//在內部類中訪問外部類中與內部類同名的實例變數 用外部類名.this.變數名
System.out.println(k);//如果內部類中沒有與外部類同名的變數，則可以直接用變數名訪問外部類變數
outer_f1();
outer_f2();
}
}
/**
* 局部內部類代碼
*/
private int s=100;
private int out_i=1;
public void outer_f5(final int k){
final int s=200;
int i=1;
final int j=10;
/**
* 局部內部類
* 在方法中第一的內部類稱為局部內部類。
* 與局部變數類似，在局部內部類前不加修飾符public和private，其范圍為定義它的代碼塊
* 注意：
* 1、在類外不可直接生產局部內部類（保證局部內部類對外是不可見的）。
* 2、要想使用局部內部類時需要生產對象，對象調用方法，在方法中才能調用局部內部類。
* 3、通過內部類和介面達到一個強制的弱耦合，用局部內部類來實現介面，並在方法中返回介面類型，使局部內部類不可見，屏蔽實現類的可見性。
* @author Administrator
*
*/
class Inner{
int s=300;//可以定義與外部類同名的變數
//static int m=20;不可以定義靜態變數
/**
* 內部類構造函數
*/
Inner(int k){
inner_f(k);
}
int inner_i=100;
/**
* 內部類的方法
* @param k
*/
void inner_f(int k){
System.out.println(out_i);//如果內部類沒有與外部類同名的變數，在內部類中可以直接訪問外部類的實例變數
System.out.println(j);//可以訪問外部內的局部變數（即方法內的變數，但是變數必須是final）
System.out.println(s);//如果內部類中有與外部類同名的變數，直接用變數名訪問的是內部類的變數
System.out.println(this.s);//用this.變數名 訪問的也是內部類變數
System.out.println(Outer.this.s);///用外部類名.this.內部類變數名 訪問的是外部類變數
}
}
new Inner(k);
}
/**
* 靜態內部類代碼
* 注意：
* 前三種內部類與變數類似，所以可以對照參考變數
*/
private static int a=1;
private int b=10;
public static void outer_f6(){
}
public void outer_f7(){
}
/**
* 靜態內部類
* 靜態內部類可以使用public，protected，private修飾
* 靜態內部類中可以定義靜態和非靜態的成員
* 注意：
* 一個靜態內部類不需要一個外部類的成員：只是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成
* Outer.Inner2 in=new Outer.Inner2();
* 這實際上靜態內部類成為了一個頂級類。
* 靜態內部類不可用private來進行定義。
* 當類與介面（或者是介面與介面）發生方法命名沖突的時候，此時必須使用內部類來實現。用介面不能完全地實現多繼承，用介面配合內部類才能實現真正的多繼承。
* 例子：class People{ run(); } interface Machine{ run(); } class Robot extends People implement Machine
* @author Administrator
*
*/
static class Inner2{
static int inner_i=100;
int inner_j=200;
static void inner_f1(){
System.out.println("Outer.a:"+a); //靜態內部類只能訪問外部類的靜態成員
outer_f6();//包括靜態變數和靜態方法
}
void inner_f2(){
//System.out.println("Outer.b:"+b); 靜態內部類不能訪問外部類的非靜態成員
//outer_f7(); X 包括非靜態變數和非靜態方法
}
}
/**
* 外部類訪問靜態內部類
*/
public void outer_f8(){
//外部內訪問內部類的靜態成員：內部類.靜態成員
System.out.println(Inner2.inner_i);
Inner2.inner_f1();
//外部類訪問內部類非靜態成員：實例化內部類
Inner2 inner=new Inner2();
System.out.println(inner.inner_j);
inner.inner_f2();
}
/**
* 匿名內部類
*
* 匿名內部類就是沒有名字的內部類。
* 注意：
* 1、匿名內部類不能有構造函數
* 2、匿名內部類不能定義任何靜態成員、方法和類
* 3、匿名內部類不能是public、protected、private、static
* 4、只能創建匿名內部類的一個實例
* 5、一個匿名內部類一定是在new後面，用其隱含實現一個介面或實現一個類。
* 6、因匿名內部類為局部內部類，所以局部內部類的所有限制都對其生效
* @return
*/
public Contents outer_f9(){
return new Contents (){
private int i=10;
@Override
public int getValue() {
// TODO Auto-generated method stub
return i;
}
};//在匿名內部類末尾的分號，並不是用來標記此內部類結束（C++中是那樣）。實際上，它標記的是表達式的結束，只不過這個表達式正巧包含了內部類罷了。因此，這與別的地方使用的分號是一致的。
//等同於
// class MyContents implements Contents {
// private int i=10;
// @Override
// public int getValue() {
// // TODO Auto-generated method stub
// return i;
// }
//
// }
// return new MyContents();
}
public Wrapping outer_f10( int x){
final int z=x;
return new Wrapping(x){
public void dest(){
System.out.println("outer_f10: "+z);//可以訪問外部內的局部變數（即方法內的變數，但是變數必須是final）
}
};
}
public static void main(String[] args){
outer_f4();//成員內部類
new Outer().outer_f5(4);//局部內部類
new Outer().outer_f8();//靜態內部類
new Outer().outer_f9().getValue();//匿名內部類
new Outer().outer_f10(8).dest() ;//匿名內部類
InnerClassTest obj=new InnerClassTest();
obj.launchFrame();
}
}
/**
* 一個內部類的簡單應用
*
* @author Administrator
*
*/
class InnerClassTest{
private Frame f;
private TextField tf;
public InnerClassTest(){
f=new Frame("Inner classes example");
tf=new TextField(30);
}
public void launchFrame(){
Label label=new Label("Click and drag the mouse");
f.add(label,BorderLayout.NORTH);
f.add(tf,BorderLayout.SOUTH);
//成員內部類
f.addMouseMotionListener(new MyMouseMotionListener());/*參數為內部類對象*/
//等效 匿名內部類
// f.addMouseMotionListener(new MouseMotionAdapter(){
// public void mouseDragged(MouseEvent e) {
// String s="Mouse dragging: x="+e.getX()+"Y="+e.getY();
// tf.setText(s);
// }
//
// });
f.setSize(300,200);
f.setVisible(true);
}
class MyMouseMotionListener extends MouseMotionAdapter{ /*內部類開始*/
public void mouseDragged(MouseEvent e) {
String s="Mouse dragging: x="+e.getX()+"Y="+e.getY();
tf.setText(s); }
}
//內部類結束
}
interface Contents{
int getValue();
}
class Wrapping{
int j;
Wrapping(int i){
j=i;
}
public void dest(){
System.out.println("Wrapping:"+j);
}
}
⑦ C++中類的定義可以嵌套嗎
可以，前者一般稱為嵌套類，嵌套類一般為於定義執行類。class A{ class B{}; };外圍類與嵌套類相互獨立，相互沒有特殊訪問許可權且對A的構造不會影響到B，只有需要使用到B的時候才會去實現，嵌套類的名子在其外圍類的作用域中可見，但在其他類作用域或者定義外圍類的作用域中是不可見的，嵌套類實際上是定義了其外圍類的一個類型成員，外圍類決定了對這個嵌套類的訪問，如果嵌套類定了靜態（static）成員，則也需要在外圍類的外部進行定義。函數中也是可以嵌套類的，稱為局部類，一般用於簡單定義，此類型只在它的局部作用域中是可見的局部類的所有成員必須在類定義體內部內行定義，而且局部類是不允許聲明靜態成員的，因為沒有辦法定義。
這些是您問的問題的一些基本概念，可能有些地方不全面，如需深入了解請查看相關資料
⑧ C++中私有類和公有類在什麼情況下用啊
你應該是想問「局部類」吧，C++中允許在類和函數中定義類，類中定義的類叫做嵌套類（他是否能被外界訪問需要看的訪問許可權，用法與類的成員類型相同），函數中定義的類叫做"局部類"，他只能在該函數內部使用，但很少有人這么用，因為外部定義的類同樣能完成這樣的的功能，C++ primer中有詳細解釋。
⑨ c++中的類中類有哪些用法
嵌套類
在一個類中定義的類稱為嵌套類，定義嵌套類的類稱為外圍類。
定義嵌套類的目的在於隱藏類名，減少全局的標識符，從而限制用戶能否使用該類建立對象。這樣能夠提高類的抽象能力，並且強調了兩個類(外圍類和嵌套類)之間的主從關系。下面是個嵌套類的例子：
class A
{
public:
class B
{
public:
…
private:
…
};
void f();
private:
int a;
}
其中，類B是個嵌套類，類A是外圍類，類B定義在類A的類體內。
對嵌套類的若干說明：
1、從作用域的角度看，嵌套類被隱藏在外圍類之中，該類名只能在外圍類中使用。假如在外圍類的作用域內使用該類名時，需要加名字限定。
2、從訪問許可權的角度來看，嵌套類名和他的外圍類的對象成員名具備相同的訪問許可權規則。不能訪問嵌套類的對象中的私有成員函數，也不能對外圍類的私有部分中的嵌套類建立對象。
3、嵌套類中的成員函數能夠在他的類體外定義。
4、嵌套類中說明的成員不是外圍類中對象的成員，反之亦然。嵌套類的成員函數對外圍類的成員沒有訪問權，反之亦然。國此，在分析嵌套類和外圍類的成員訪問關系時，往往把嵌套類看作非嵌套類來處理。這樣，上述的嵌套類可寫成如下格式：
class A
{
public:
void f();
private:
int a;
};
class B
{
public:
…
private:
…
};
由引可見，嵌套類僅僅是語法上的嵌入。
5、在嵌套類中說明的友元對外圍類的成員沒有訪問權。
6、假如嵌套類比較復雜，能夠只在外圍類中對嵌套類進行說明，關於嵌套的周詳的內容可在外圍類體外的文檔域中進行定義。