❶ java匿名內部類具體概念是什麼，在什麼地方用到
java匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類，沒有類名，根據多態，我們使用其父類名。因他是局部內部類，那麼局部內部類的所有限制都對其生效。匿名內部類是唯一一種無構造方法類。大部分匿名內部類是用於介面回調用的。匿名內部類在編譯的時候由系統自動起名Out$1.class。如果一個對象編譯時的類型是介面，那麼其運行的類型為實現這個介面的類。因匿名內部類無構造方法，所以其使用范圍非常的有限。當需要多個對象時使用局部內部類，因此局部內部類的應用相對比較多。匿名內部類中不能定義構造方法。如果一個對象編譯時的類型是介面，那麼其運行的類型為實現這個介面的類。
示例如下：
publicclassOuter{
privatestaticinti=1;
privateintj=10;
publicstaticvoidouter_f1(){
}
publicvoidouter_f2(){
}
//靜態內部類可以用public,protected,private修飾
//靜態內部類中可以定義靜態或者非靜態的成員
staticclassInner{
staticintinner_i=100;
intinner_j=200;
staticvoidinner_f1(){
System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員
outer_f1();//包括靜態變數和靜態方法
}
voidinner_f2(){
//System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員
//outer_f2();//包括非靜態變數和非靜態方法
}
}
publicvoidouter_f3(){
//外部類訪問內部類的靜態成員：內部類.靜態成員
System.out.println(Inner.inner_i);
Inner.inner_f1();
//外部類訪問內部類的非靜態成員:實例化內部類即可
Innerinner=newInner();
inner.inner_f2();
}
publicstaticvoidmain(String[]args){
newOuter().outer_f3();
}
}
❷ Java匿名內部類
創建一個匿名類對象作為wrapping方法的返回值，同時重寫了匿名類的value方法。
return的作用是結束當前方法(C語言里叫函數)，看清楚return所在的方法。
要調用該方法才會執行裡面的代碼。
靜態main方法是程序入口點。
❸ JAVA匿名類是什麼，怎麼用
匿名類是一種特殊的內部類，它是在一個表達式內部包含一個完整的類定義。
內部類是在一個類的內部嵌套定義的類，它可以是其它類的成員，也可以在一個語句塊的內部定義，還可以在表達式內部匿名定義。
匿名類與其他類的不同就在於匿名，也就是沒有名稱。
Java中允許創建子類對象時，除了使用父類的構造方法外，還可以用類體。 匿名類就是一個沒有類申明的類體，因為沒有名稱，所有匿名類不可以申明對象，但卻可以創建對象。 例如：
A是一個子類，那麼下面的代碼就是A的一個子類(匿名類)創建對象。
new A(){
匿名類的類體
};
由於匿名類是一個子類，所以和有一般子類的特徵。可以繼承父類的方法，同樣也可以重寫父類的方法。值得提醒的是，在使用匿名類時，一定是在某個類中直接用匿名類創建對象，因此匿名類必定是內部類，所以和其他匿名類一樣可以訪問外嵌類中的成員變數和方法，匿名類的類體中不可以什麼。
static成員變數和static方法。
盡管匿名類沒有申明的步驟，但可以在創建匿名對象時返回一個引用賦值給匹配參數。 匿名類的常用方式是向方法的參數傳值。
具體方法如下：
abstractclassSpeak{
publicabstractvoidspeakHello();
}
classStudent{
voidf(Speaksp){
sp.speakHello();
}
}
publicclassAnonymousClassDemo{
publicstaticvoidmain(String[]args){
Speakspeak=newSpeak(){
publicvoidspeakHello(){
System.out.println("大家好，祝工作愉快!");
}
};
speak.speakHello();
Studentst=newStudent();
st.f(newSpeak(){
publicvoidspeakHello(){
System.out.println("Iamastudent,howareyou");
}
});
}
}上面代碼的抽象類改成介面同樣適用。
❹ Java匿名內部類怎樣創建有何作用和優點創建線程怎樣使用匿名內部類
1、匿名內部類就是沒有名字的內部類。這是Java為了方便我們編寫程序而設計的一個機制。因為有時候有的內部類只需要創建一個它的對象就可以了，以後再不會用到這個類，這時候使用匿名內部類就比較合適，而且也免去了給它取名字的煩惱。
2、如果滿足下面的一些條件，使用匿名內部類是比較合適的：
·只用到類的一個實例。
·類在定義後馬上用到。
·類非常小（SUN推薦是在4行代碼以下）
·給類命名並不會導致你的代碼更容易被理解。
在使用匿名內部類時，要記住以下幾個原則：
·匿名內部類不能有構造方法。
·匿名內部類不能定義任何靜態成員、方法和類。
·匿名內部類不能是public,protected,private,static。
·只能創建匿名內部類的一個實例。
·一個匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類。
·因匿名內部類為局部內部類，所以局部內部類的所有限制都對其生效。
3、用匿名內部類創建多線程有兩種方式，和創建一個線程是一樣的。
第①種繼承Thread：
new Thread(){
public void run(){
//do something
};
}.start();
第②種實現 Runnable介面：
new Thread(new Runnable() {
public void run() {
//do something
};
}) { }.start();
❺ java 匿名內部類
匿名類是不能有名稱的類，所以沒辦法引用它們。必須在創建時，作為new語句的一部分來聲明它們。這就要採用另一種形式的new語句，如下所示： new <類或介面> <類的主體> 這種形式的new語句聲明一個新的匿名類，它對一個給定的類進行擴展，或者實現一個給定的介面。它還創建那個類的一個新實例，並把它作為語句的結果而返回。要擴展的類和要實現的介面是new語句的操作數，後跟匿名類的主體。如果匿名類對另一個類進行擴展，它的主體可以訪問類的成員、覆蓋它的方法等等，這和其他任何標準的類都是一樣的。如果匿名類實現了一個介面，它的主體必須實現介面的方法。
java 代碼
interface pr
{
void print1();
}
public class noNameClass
{
public pr dest()
{
return new pr(){
public void print1()
{
System.out.println("Hello world!!");
}
};
}
public static void main(String args[])
{
noNameClass c=new noNameClass();
pr hw=c.dest();
hw.print1();
}
}
pr也可以是一個類但是你外部調用的方法必須在你的這個類或介面中聲明外部不能調用匿名類內部的方法
Java中內部匿名類用的最多的地方也許就是在Frame中加入Listner了吧。
如下：
java 代碼
import java.awt.*;
import java.awt.event.*;
public class QFrame extends Frame {
public QFrame() {
this.setTitle(\"my application\");
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
dispose();
System.exit(0);
}
});
this.setBounds(10,10,200,200);
}
}
內部匿名類，就是建立一個內部的類，但沒有給你命名，也就是沒有引用實例的變數。
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
dispose();
System.exit(0);
}
}
new 是建立一個 WindowAdapter對象 ，後面一個 {} 表示這個括弧中的操作作用於這個默認的對名象，而上面的Java程序中後面是一個函數體。
這個用法的作用是：創建一個對象的實例，並且 override 它的一個函數。打開 WindowAdapter 的代碼可以發現。它是一個抽象類。它是對 WindowListener 介面的一個實現。Frame.addWindowListner(); 的參數是一個 WindowListner ，而實現上是傳一個從WindowAdapter 派生出的一個匿名類。
1.怎樣判斷一個匿名類的存在啊？看不見名字，感覺只是父類new出一個對象而已，沒有匿名類的名字。
先看段偽代碼
abstract class Father(){
....
}
public class Test{
Father f1 = new Father(){ .... } //這里就是有個匿名內部類
}
一般來說，new 一個對象時小括弧後應該是分號，也就是new出對象該語句就結束了。
但是出現匿名內部類就不一樣，小括弧後跟的是大括弧，大括弧中是該new 出對象的具體的實現方法。
因為我們知道，一個抽象類是不能直接new 的，必須先有實現類了我們才能new出它的實現類。
上面的偽代碼就是表示new 的是Father的實現類，這個實現類是個匿名內部類。
其實拆分上面的匿名內部類可為
class SonOne extends Father{
... //這里的代碼和上面匿名內部類，大括弧中的代碼是一樣的
}
public class Test{
Father f1 = new SonOne() ;
}
2.匿名內部類的注意事項
注意匿名類的聲明是在編譯時進行的，實例化在運行時進行。這意味著for循環中的一個new語句會創建相同匿名類的幾個實例，而不是創建幾個不同匿名類的一個實例。
在使用匿名內部類時，要記住以下幾個原則：
·匿名內部類不能有構造方法。
·匿名內部類不能定義任何靜態成員、方法和類。
·匿名內部類不能是public,protected,private,static。
·只能創建匿名內部類的一個實例。
·一個匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類。
·因匿名內部類為局部內部類，所以局部內部類的所有限制都對其生效。
·內部類只能訪問外部類的靜態變數或靜態方法。
匿名類和內部類中的中的this :
有時候，我們會用到一些內部類和匿名類。當在匿名類中用this時，這個this則指的是匿名類或內部類本身。這時如果我們要使用外部類的方法和變數的話，則應該加上外部類的類名
3.匿名內部類的作用
Java的內部類和C++中的嵌套類有本質的不同：C++的嵌套類沒有指向包裝類的句柄。僅僅表達一個封裝的概念；但是Java的內部類不同，它可以訪問包裝類的成員（這表示它擁有指向包裝類的句柄）。
匿名內部類是內部類的一種簡化寫法：return new Wrapper {
...
};
等價於：Wrapped extends Wrapper {
...
}
return new Wrapped();
難道匿名內部類就只這一點作用嗎？
考慮一下這樣的case:
interface ICount {
int count();
}
class Parent {
int i = 0;
int count() {
return i++;
}
}
有一個類Child，它既想繼承Parent的count()方法，又想實現ICount介面中的count方法，這個時候怎麼辦呢？內部類就可以大顯身手了：
class Child extends Parent {
ICount getCount() {
return new ICount {
int i = 0;
int count() {
return (i *= 2);
}
}
}
}
至於你說的只有一個方法或者必須有返回值，這個倒是沒有在語法上規定 ， 所以應該不存在這一說法。
❻ java匿名內部類
這個類其實並沒有實現兩個介面的方法
匿名內部類的作用是靈活實現某個介面的方法解除依賴，你的Demo 類 implement 了 dianran,pool 兩個介面，dr() 和 rs() 就是 Demo的成員方法 main 方法同級的 ；
Demo不需要實現兩個介面就可以在實現兩個方法如下：
interface dianran {
abstract void dr();
}
interface pool{
abstract void rs();
}
public class Demo {
public static void main(String args[]){
new dianran(){
@Override
public void dr() {
System.out.println("方法 dr");
}
}.dr();
new pool(){
@Override
public void rs() {
System.out.println("方法 rs");
}
}.rs();
}
}
❼ java內部類和匿名內部類的區別是什麼
//匿名內部類甚至沒有類名,(實際上有).
所以匿名內部類,只有一個實例,而且沒有引用.
如下面那個Thread類的匿名子類,你不能重復使用.
內部類,內部類有名字,但是他在類的內部.
他能訪問外部類的所有數據,包括private的.
甚至如果一個內部類,是在一個方法內的話,方法的局部變數,內部類也可以使用.
總體來說匿名內部類,和內部類效果差別不大.
在事件監聽和線程應用中經常使用.
//匿名內部類
public class T1 {
public static void main(String[] args) {
new Thread() {
public void run() {
System.out.println("runing");
}
}.start();
}
}
//內部嵌套類
public class T1 {
private static final class Thread1 extends Thread {
public void run() {
System.out.println("runing");
}
}
public static void main(String[] args) {
new Thread1().start();
}
}
❽ JAVA中的匿名內部類
選B，C
A；匿名類與其說一個類，不如說他是一個表達式，因為寫匿名類是在一個表達式裡面寫的，所以要注意寫完一個匿名類後要在結尾寫一個「：」
D；new Boo(String s){};這里的內部類雖然繼承了Boo，但是這里實例化的類與Bar一點關系都沒有（雖然他們都繼承了Boo類，就像三角形和四邊形繼承自形狀，你能說三角形是四邊形嗎）
E；匿名類不像普通的內部類，不要向E一樣要Boo.Bar(String s){}; 這樣寫，這樣寫沒有任何意義
new Bar(){} 和new Bar()的區別在於，第一個相當於繼承了Bar類然後實例化Bar的子類對象（也就是說第一個是之類對象），後一個就是Bar對象
匿名類就是一個沒有名字的，把繼承類與實例化子類對象壓縮在一個表達式裡面
Boo(String s){}， Boo(){}這是統一各位類中的兩個構造方法，沒有什麼關系，都是用來初始化對象的，一個是有參數的，一個是沒有參數的，在實例化對象時，只能選擇其中一個
❾ JAVA中局部內部類和匿名內部類的特點和作用是什麼
Java 內部類
分四種：成員內部類、局部內部類、靜態內部類和匿名內部類。
1、成員內部類： 即作為外部類的一個成員存在，與外部類的屬性、方法並列。
注意：成員內部類中不能定義靜態變數,但可以訪問外部類的所有成員。
public class Outer{
private static int i = 1;
private int j=10;
private int k=20;
public static void outer_f1(){
//do more something
}
public void out_f2(){
//do more something
}
//成員內部類
class Inner{
//static int inner_i =100; //內部類中不允許定義靜態變數
int j=100;//內部類中外部類的實例變數可以共存
int inner_i=1;
void inner_f1(){
System.out.println(i);//外部類的變數如果和內部類的變數沒有同名的，則可以直接用變數名訪問外部類的變數
System.out.println(j);//在內部類中訪問內部類自己的變數直接用變數名
System.out.println(this.j);//也可以在內部類中用"this.變數名"來訪問內部類變數
//訪問外部類中與內部類同名的實例變數可用"外部類名.this.變數名"。
System.out.println(k);//外部類的變數如果和內部類的變數沒有同名的，則可以直接用變數名訪問外部類的變數
outer_f1();
outer_f2();
}
}
//外部類的非靜態方法訪問成員內部類
public void outer_f3(){
Inner inner = new Inner();
inner.inner_f1();
}
//外部類的靜態方法訪問成員內部類，與在外部類外部訪問成員內部類一樣
public static void outer_f4(){
//step1 建立外部類對象
Outer out = new Outer();
//***step2 根據外部類對象建立內部類對象***
Inner inner=out.new Inner();
//step3 訪問內部類的方法
inner.inner_f1();
}
public static void main(String[] args){
outer_f4();
}
}
成員內部類的優點：
⑴ 內部類作為外部類的成員，可以訪問外部類的私有成員或屬性。（即使將外部類聲明為PRIVATE，但是對於處於其內部的內部類還是可見的。）
⑵ 用內部類定義在外部類中不可訪問的屬性。這樣就在外部類中實現了比外部類的private還要小的訪問許可權。
注意：內部類是一個編譯時的概念，一旦編譯成功，就會成為完全不同的兩類。對於一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成後出現outer.class和outer$inner.class兩類。
2、局部內部類： 即在方法中定義的內部類，與局部變數類似，在局部內部類前不加修飾符public或private，其范圍為定義它的代碼塊。
注意：局部內部類中不可定義靜態變數，可以訪問外部類的局部變數(即方法內的變數)，但是變數必須是final的。
public class Outer {
private int s = 100;
private int out_i = 1;
public void f(final int k){
final int s = 200;
int i = 1;
final int j = 10;
class Inner{ //定義在方法內部
int s = 300;//可以定義與外部類同名的變數
//static int m = 20;//不可以定義靜態變數
Inner(int k){
inner_f(k);
}
int inner_i = 100;
void inner_f(int k){
System.out.println(out_i);//如果內部類沒有與外部類同名的變數，在內部類中可以直接訪問外部類的實例變數
System.out.println(k);//*****可以訪問外部類的局部變數(即方法內的變數)，但是變數必須是final的*****
// System.out.println(i);
System.out.println(s);//如果內部類中有與外部類同名的變數，直接用變數名訪問的是內部類的變數
System.out.println(this.s);//用"this.變數名" 訪問的也是內部類變數
System.out.println(Outer.this.s);//用外部"外部類類名.this.變數名" 訪問的是外部類變數
}
}
new Inner(k);
}
public static void main(String[] args) {
//訪問局部內部類必須先有外部類對象
Outer out = new Outer();
out.f(3);
}
}
注意：
在類外不可直接生成局部內部類（保證局部內部類對外是不可見的）。要想使用局部內部類時需要生成對象，對象調用方法，在方法中才能調用其局部內部類。通過內部類和介面達到一個強制的弱耦合，用局部內部類來實現介面，並在方法中返回介面類型，使局部內部類不可見，屏蔽實現類的可見性。
3、靜態內部類： 靜態內部類定義在類中，任何方法外，用static定義。
注意：靜態內部類中可以定義靜態或者非靜態的成員
public class Outer {
private static int i = 1;
private int j = 10;
public static void outer_f1(){
}
public void outer_f2(){
}
// 靜態內部類可以用public,protected,private修飾
// 靜態內部類中可以定義靜態或者非靜態的成員
static class Inner{
static int inner_i = 100;
int inner_j = 200;
static void inner_f1(){
System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員
outer_f1();//包括靜態變數和靜態方法
}
void inner_f2(){
// System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員
// outer_f2();//包括非靜態變數和非靜態方法
}
}
public void outer_f3(){
// 外部類訪問內部類的靜態成員：內部類.靜態成員
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部類訪問內部類的非靜態成員:實例化內部類即可
Inner inner = new Inner();
inner.inner_f2();
}
public static void main(String[] args) {
new Outer().outer_f3();
}
}
注意：*******生成（new）一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成：
Outer.Inner in=new Outer.Inner()；
而不需要通過生成外部類對象來生成。這樣實際上使靜態內部類成為了一個頂級類。靜態內部類不可用private來進行定義。*******
例子：
對於兩個類，擁有相同的方法：
class People
{
run();
}
class Machine{
run();
}
此時有一個robot類：
class Robot extends People implement Machine.
此時run()不可直接實現。
注意：當類與介面（或者是介面與介面）發生方法命名沖突的時候，此時必須使用內部類來實現。用介面不能完全地實現多繼承，用介面配合內部類才能實現真正的多繼承。
4、匿名內部類
匿名內部類是一種特殊的局部內部類，它是通過匿名類實現介面。
IA被定義為介面。
IA I=new IA(){};
匿名內部類的特點：
1，一個類用於繼承其他類或是實現介面，並不需要增加額外的方法，只是對繼承方法的事先或是覆蓋。
2，只是為了獲得一個對象實例，不需要知道其實際類型。
3，類名沒有意義，也就是不需要使用到。
public class Outer {
private static int i = 1;
private int j = 10;
public static void outer_f1(){
}
public void outer_f2(){
}
// 靜態內部類可以用public,protected,private修飾
// 靜態內部類中可以定義靜態或者非靜態的成員
static class Inner{
static int inner_i = 100;
int inner_j = 200;
static void inner_f1(){
System.out.println("Outer.i"+i);//靜態內部類只能訪問外部類的靜態成員
outer_f1();//包括靜態變數和靜態方法
}
void inner_f2(){
// System.out.println("Outer.i"+j);//靜態內部類不能訪問外部類的非靜態成員
// outer_f2();//包括非靜態變數和非靜態方法
}
}
public void outer_f3(){
// 外部類訪問內部類的靜態成員：內部類.靜態成員
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部類訪問內部類的非靜態成員:實例化內部類即可
Inner inner = new Inner();
inner.inner_f2();
}
public static void main(String[] args) {
new Outer().outer_f3();
}
}
註：一個匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類，沒有類名，根據多態，我們使用其父類名。因他是局部內部類，那麼局部內部類的所有限制都對其生效。匿名內部類是唯一一種無構造方法類。大部分匿名內部類是用於介面回調用的。匿名內部類在編譯的時候由系統自動起名Out$1.class。如果一個對象編譯時的類型是介面，那麼其運行的類型為實現這個介面的類。因匿名內部類無構造方法，所以其使用范圍非常的有限。當需要多個對象時使用局部內部類，因此局部內部類的應用相對比較多。匿名內部類中不能定義構造方法。如果一個對象編譯時的類型是介面，那麼其運行的類型為實現這個介面的類。
________________________________________________________________________________
內部類總結：
1.首先，把內部類作為外部類的一個特殊的成員來看待，因此它有類成員的封閉等級：private ,protected,默認(friendly),public
它有類成員的修飾符: static,final,abstract
2.非靜態內部類nested inner class,內部類隱含有一個外部類的指針this,因此，它可以訪問外部類的一切資源（當然包括private）
外部類訪問內部類的成員，先要取得內部類的對象,並且取決於內部類成員的封裝等級。
非靜態內部類不能包含任何static成員.
3.靜態內部類：static inner class,不再包含外部類的this指針，並且在外部類裝載時初始化.
靜態內部類能包含static或非static成員.
靜態內部類只能訪問外部類static成員.
外部類訪問靜態內部類的成員，循一般類法規。對於static成員，用類名.成員即可訪問，對於非static成員，只能
用對象.成員進行訪問
4.對於方法中的內部類或塊中內部類只能訪問塊中或方法中的final變數。
類成員有兩種static , non-static，同樣內部類也有這兩種
non-static 內部類的實例，必須在外部類的方法中創建或通過外部類的實例來創建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),並且可直接訪問外部類的信息,外部類對象可通過OuterClassName.this來引用
static 內部類的實例, 直接創建即可，沒有對外部類實例的引用。
內部類不管static還是non-static都有對外部類的引用
non-static 內部類不允許有static成員
方法中的內部類只允許訪問方法中的final局部變數和方法的final參數列表，所以說方法中的內部類和內部類沒什麽區別。但方法中的內部類不能在方法以外訪問，方法中不可以有static內部類
匿名內部類如果繼承自介面,必須實現指定介面的方法,且無參數
匿名內部類如果繼承自類,參數必須按父類的構造函數的參數傳遞