㈠ InnerClass(String s) { // 內部類構造方法 System.out.println(s); }這個方法有什麼用
這個方法是用肢猛來構造InnerClass對象的。java中所有的類都需要有構造方法，如果你不寫的話編譯器會默認指定一個。
如果沒有這個構造方法，你創建InnerClass對象時需要這么寫：
InnerClass ic = new InnerClass();
但如果有這個構造方法，你創建肆山時需要這么寫：
InnerClass ic = new InnerClass("隨便寫一個字元串");
其實說白了，構造方法就指定了你創建對象時需要的參數，如果你不寫構造方法，系統會指定一個不需歷雹橋要任何輸入參數的構造方法。
㈡ java,局部內部類可以有構造方法嗎
可以，只要是類都有構造函數。
比如：
class則滾Circle{
孫梁余classDraw{//內部類
publicDraw(inta){//內部類的構造函數
}
渣橡}
}
㈢ Java類的基本組成和使用是怎樣的
通過對實例化對象的使用來進行行為。
㈣ Java在外界如何調用局部內部類
內部類和成員變數一樣，通過外部類的實例調用內部類。
可以先創建外部類實例。
用外部類實例調用內部類構造方法創建內部類實例。
再用這個內部類實例調用內部類成員方法。
Aa=newA();
A.Bb=a.newB();
b.do1();//do是關鍵字，所以這里在do後面加了個1，否則無法編譯。
㈤ java中構造方法和拷貝構造方法是什麼意思
構造方法是一種特殊的方法，它是一個與類同名且沒有返回值類型的版方法。對象的創權建就是通過構造方法來完成，其功能主要是完成對象的初始化。當類實例化一個對象時會自動調用構造方法。構造方法和其他方法一樣也可以重載。
拷貝構造方法就是用一個已經實例化的對象來new另一個對象
給個例子：
publicclassTest{
privateinthour;
privateintminute;
privateintsecond;
//構造方法
publicTest(){
}
//拷貝構造方法
publicTest(Testt){
super();
this.hour=t.hour;
this.minute=t.minute;
this.second=t.second;
}
}
㈥ java的內部類的外嵌類里必須要有空的構造方法嗎
不模彎一定吧，有帶參的構造方法也行啊。不過如果沒有有毀高參構造方法的話，會默認提供一個無參構造方法。加了有參構造方法，無參構造方法就需要自旦余悶己定義啦～
㈦ 一個java內部類有幾個分類
共枝裂手有四種內部類，源孫分別是:
1.常規內部類
2.靜態內部類
3.局部內部類
4.匿名內部類
㈧ Java匿名內部類怎樣創建有何作用和優點創建線程怎樣使用匿名內部類
1、匿名內部類就是沒有名字的內部類。這是Java為了方便我們編寫程序而設計的一個機制。因為有時候有的內部類只需要創建一個如褲它的對象就可以了，以後再不會用到這個類，這時候使用匿名內部類就比較合適，而且也免橡手去了給它取名字的煩惱。x0dx0ax0dx0a2、如果滿足下面的一些條件，使用匿名內部類是比較合適的： x0dx0a·只用到類的一個實例。 x0dx0a·類在定義後馬上用到。 x0dx0a·類非常小（SUN推薦是在4行代碼以下） x0dx0a·給類命名並不會導致你的代碼更容易被理解。 x0dx0a在使用匿名內部類時，梁橡嫌要記住以下幾個原則： x0dx0a·匿名內部類不能有構造方法。 x0dx0a·匿名內部類不能定義任何靜態成員、方法和類。 x0dx0a·匿名內部類不能是public,protected,private,static。 x0dx0a·只能創建匿名內部類的一個實例。 x0dx0a·一個匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類。 x0dx0a·因匿名內部類為局部內部類，所以局部內部類的所有限制都對其生效。 x0dx0ax0dx0a3、用匿名內部類創建多線程有兩種方式，和創建一個線程是一樣的。x0dx0a第①種繼承Thread：x0dx0anew Thread(){x0dx0apublic void run(){x0dx0a//do somethingx0dx0a};x0dx0a}.start();x0dx0ax0dx0a第②種實現 Runnable介面：x0dx0anew Thread(new Runnable() {x0dx0apublic void run() {x0dx0a //do somethingx0dx0a};x0dx0a}) { }.start();
㈨ Java裡面什麼是內部類、外部類、匿名內部類，構造函數等等
內部類復：把類放在方法內
外部類：制正常的類
匿名內部類：顧名思義，沒有名字的內部類。當程序中使用匿名內部類時，在定義匿名內部類的地方往往直接創建該類的一個對象
構造函數：構造方法的方法名必須與類名相同。構造方法沒有返回類型，也不能定義為void，在方法名前面不聲明方法類型。構造方法的主要作用是完成對象的初始化工作，它能夠把定義對象時的參數傳給對象的域。
㈩ java中內部類
在java語言中，有一種類叫做內部類(inner 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內部類加上介面可以有效地實現多重繼承。