匿名内部类java中为什么常说匿名内部类为局部内部类????
匿名内部类 时间:2021-09-27 阅读:(
)
局部内部类 与匿名内部类的区别 求解啊
//匿名内部类甚至没有类名,(实际上有).
所以匿名内部类,只有一个实例,而且没有引用.
如下面那个Thread类的匿名子类,你不能重复使用.
内部类,内部类有名字,但是他在类的内部.
他能访问外部类的所有数据,包括private的.
甚至如果一个内部类,是在一个方法内的话,方法的局部变量,内部类也可以使用.
总体来说匿名内部类,和内部类效果差别不大.
在事件监听和线程应用中经常使用.java内部类,匿名内部类这些是什么?求详细用法,还有语法。
一、内部类:
内部类是定义在另一个类中的类,使用它的原因主要有3个:
内部类方法可以访问该类定义所在的作用域中的数据,包括私有的数据;
内部类可以对同一个包中的其他类隐藏以来;
当想要定义一个回调函数且不想编写大量代码时,使用匿名内部类比较便捷。
【举例:《Java核心技术(卷I)》,6.4节——内部类,程序清单6-6】
import?java.awt.*;
import?java.awt.event.*;
import?java.util.*;
import?javax.swing.*;
import?javax.swing.Timer;
/**
?*?This?program?demonstrates?anonymous?inner?classes.
?*?@version?1.10?2004-02-07
?*?@author?Cay?Horstmann
?*/
public?class?InnerClassTest
{
????public?static?void?main(String[]?args)
????{
????????TalkingClock?clock?=?new?TalkingClock(1000,?true);
????????clock.start();
????????//?keep?program?running?until?user?selects?"Ok"
????????JOptionPane.showMessageDialog(null,?"Quit?program?");
????????System.exit(0);
????}
}
/**
?*?A?clock?that?prints?the?time?in?regular?intervals.
?*/
class?TalkingClock
{
????private?int?interval;
????private?boolean?beep;
????/**
?????*?Starts?the?clock.
?????*?@param?interval?the?interval?between?messages?(in?milliseconds)
?????*?@param?beep?true?if?the?clock?should?beep
?????*/
????public?TalkingClock(int?interval,?boolean?beep)
????{
????????this.interval?=?interval;
????????this.beep?=?beep;
????}
????/**
?????*?Starts?the?clock.
?????*/
????public?void?start()
????{
????????ActionListener?listener?=?new?TimePrinter();
????????Timer?t?=?new?Timer(interval,?listener);
????????t.start();
????}
????public?class?TimePrinter?implements?ActionListener
????{
????????public?void?actionPerformed(ActionEvent?event)
????????{
????????????Date?now?=?new?Date();
????????????System.out.println("At?the?tone,?the?time?is?"?+?now);
????????????if?(beep)?Toolkit.getDefaultToolkit().beep();
????????}
????}
}上述代码中,TimePrinter就是在TalkingClock类的内部定义的一个内部类,因此它可以访问外围类的数据域,包括interval和beep这种私有域。
二、局部内部类:
讨论匿名内部类之前,先看看局部内部类,它是在一个方法中定义的类。
代码示例如下,这里将上例中的TimePrinter类放到了start()方法中进行定义:
public?void?start(int?interval,?final?boolean?beep)
{
????class?TimePrinter?implements?ActionListener
????{
????????public?void?actionPerformed(ActionEvent?event)
????????{
????????????Date?now?=?new?Date();
????????????System.out.println("At?the?tone,?the?time?is?"?+?now);
????????????if?(beep)?Toolkit.getDefaultToolkit().beep();
????????}
????}
????ActionListener?listener?=?new?TimePrinter();
????Timer?t?=?new?Timer(interval,?listener);
????t.start();
}局部内部类不能用public或private访问说明符来声明,它的作用域被限定在声明这个局部内部类的块中。
局部内部类可以对外部世界完全地隐藏起来。
局部内部类不仅能访问其外围类,还可以访问局部变量,不过这些局部变量必须被声明为final,如上述代码中start()方法的参数beep所示。
三、匿名内部类
将上面的局部内部类的代码修改一下,就可以定义一个匿名内部类,这种类没有类名。
public?void?start(int?interval,?final?boolean?beep)
????{
????????ActionListener?listener?=?new?ActionListener()
????????????{
????????????????public?void?actionPerformed(ActionEvent?event)
????????????????{
????????????????????Date?now?=?new?Date();
????????????????????System.out.println("At?the?tone,?the?time?is?"?+?now);
????????????????????if?(beep)?Toolkit.getDefaultToolkit().beep();
????????????????}
????????????};
????????Timer?t?=?new?Timer(interval,?listener);
????????t.start();
????}请参照局部内部类的代码,比较不同之处。
TimePrinter这个类名被省略了,定义listener这个局部内部类时,在其后的new ActionListener()后面跟了一个大括号括起的语句块,也就是此匿名内部类的定义语句。
匿名内部类除了具有内部类的优点外,还可以减少代码量。
【内容有些多,但愿能帮到你^_^】java 中的内部类和匿名内部类都是怎么回事 该怎么用
1、内部类分为成员内部类、静态嵌套类、方法内部类、匿名内部类。
几种内部类的共性:
A、内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的.class文件,但是前面冠以外部类的类命和$符号。
B、内部类不能用普通的方式访问。
内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的。
2、成员内部类:形式如下
class Outer {
class Inner{}
}
编译上述代码会产生两个文件:Outer.class和Outer$Inner.class。
3、方法内部类。
顾名思义,把类放在方法内。
class Outer {
public void doSomething(){
class Inner{
public void seeOuter(){
}
}
}
}
A、方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。
B、方法内部类对象不能使用该内部类所在方法的非final局部变量。
因为方法的局部变量位于栈上,只存在于该方法的生命期内。
当一个方法结束,其栈结构被删除,局部变量成为历史。
但是该方法结束之后,在方法内创建的内部类对象可能仍然存在于堆中!例如,如果对它的引用被传递到其他某些代码,并存储在一个成员变量内。
正因为不能保证局部变量的存活期和方法内部类对象的一样长,所以内部类对象不能使用它们。
下面是完整的例子:
class Outer {
public void doSomething(){
final int a =10;
class Inner{
public void seeOuter(){
System.out.println(a);
}
}
Inner in = new Inner();
in.seeOuter();
}
public static void main(String[] args) {
Outer out = new Outer();
out.doSomething();
}
}
4、匿名内部类。
顾名思义,没有名字的内部类。
表面上看起来它们似乎有名字,实际那不是它们的名字。
A、继承式的匿名内部类。
class Car {
public void drive(){
System.out.println("Driving a car!");
}
}
class Test{
public static void main(String[] args) {
Car car = new Car(){
public void drive(){
System.out.println("Driving another car!");
}
};
car.drive();
}
}
结果输出了:Driving another car! Car引用变量不是引用Car对象,而是Car匿名子类的对象。
B、接口式的匿名内部类。
interface Vehicle {
public void drive();
}
class Test{
public static void main(String[] args) {
Vehicle v = new Vehicle(){
public void drive(){
System.out.println("Driving a car!");
}
};
v.drive();
}
}
上面的代码很怪,好像是在实例化一个接口。
事实并非如此,接口式的匿名内部类是实现了一个接口的匿名类。
而且只能实现一个接口。
C、参数式的匿名内部类。
class Bar{
void doStuff(Foo f){}
}
interface Foo{
void foo();
}
class Test{
static void go(){
Bar b = new Bar();
b.doStuff(new Foo(){
public void foo(){
System.out.println("foofy");
}
});
}
}
5、静态嵌套类。
从技术上讲,静态嵌套类不属于内部类。
因为内部类与外部类共享一种特殊关系,更确切地说是对实例的共享关系。
而静态嵌套类则没有上述关系。
它只是位置在另一个类的内部,因此也被称为顶级嵌套类。
详细内容请见:/honglin_bd/blog/item/fa60c4d3866f972933fa1c87.htmlJava中怎样使用匿名内部类
JAVA中匿名内部类使用最常见,用起来最方便的地方是在进行GUI编写时,添加控件响应事件时。
在为控件添加事件时使用内部匿名类是大家常用的方法,我这里举一个列子,相信你看过之后既能理解又会用了。
这是为一个按钮添加一个左键单击事件,点单击后打印 hello!!
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class Press {
/**
* @param args
*/
JFrame jf = new JFrame("内部匿名类演示"); //创建一个JFrame组件
JButton jb = new JButton("Press me"); //创建按钮
JLabel jt = new JLabel(); //创建一个标签用来输出“hello!!”
public Press(){
jf.add(jb,BorderLayout.SOUTH); //添加按钮
jf.add(jt,BorderLayout.CENTER); //添加标签
jf.setSize(200,200); //设置jf大小
jf.setVisible(true); //设置jf为可见
/*接下来是内部匿名类的应用了,为jb添加一个左键单击响应事件*/
jb.addActionListener(new ActionListener(){ /*这里就是内部匿名类了,没有类名,下面是类的方法体*/
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
jt.setText("hello!!");
}});
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Press p =new Press();
}
}
你可以试着给jf添加一个事件响应,让它点×可以关掉,这样你就能理解匿名内部类了,再看看书里对“内部类”、“匿名类”的介绍,一个个理解这样“匿名内部类”就没问题了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内部类
匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数
匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递java中为什么常说匿名内部类为局部内部类????
首先,决定内部类的核心其实就是看其定义的位置,所有在“内部”定义的类,都属于内部类,如类内部,函数内部等等,匿名就是无名了,很好理解,这里有一个无名的在类内部定义的类,所以lz判定了一个匿名内部类。
其次,我觉得所谓“局部”指的应该是一种作用范围,而这个匿名内部类显然只能在这一条赋值语句中起作用
lz查看,采纳
hostkvm本月对香港国际线路的VPS、韩国CN2+bgp线路的VPS正在做7折终身优惠,对日本软银线路、美国CN2 GIA线路、新加坡直连线路的VPS进行8折终身优惠促销。所有VPS从4G内存开始支持Windows系统,当然主流Linux发行版是绝对不会缺席的!官方网站:https://hostkvm.com香港国际线路、韩国,7折优惠码:2021summer日本、美国、新加坡,8折优惠码:2...
快快CDN主营业务为海外服务器无须备案,高防CDN,防劫持CDN,香港服务器,美国服务器,加速CDN,是一家综合性的主机服务商。美国高防服务器,1800DDOS防御,单机1800G DDOS防御,大陆直链 cn2线路,线路友好。快快CDN全球安全防护平台是一款集 DDOS 清洗、CC 指纹识别、WAF 防护为一体的外加全球加速的超强安全加速网络,为您的各类型业务保驾护航加速前进!价格都非常给力,需...
一、麻花云官网点击直达麻花云官方网站二、活动方案优惠码:专属优惠码:F1B07B 享受85折优惠。点击访问活动链接最新活动 :五一狂欢 惠战到底 香港云主机 1.9折起香港特价体验云主机CN2 云服务器最新上线KVM架构,,默认40G SSD,+10G自带一个IPv4,免费10Gbps防御,CPU内存带宽价格购买1核1G1M19元首月链接2核2G 2M92元/3个月链接2核4G3M112元/3个月...
匿名内部类为你推荐
潦草字潦草字的"的"怎么写?宝安网站制作急寻深圳宝安网站制作?健康门户网站中国健康安全网是什么湖北文理学院地址湖北文理学院怎么样啊无线监控方案智能汽车充电桩无线监控方案怎么实现?北方民族大学地址北方民族学校好吗?具体位置在宁夏哪?是几本啊?oa地址请问中粮的OA系统地址是什么?上海长宽上海地铁最小的车宽度有几米?超声波探测超声波检测的原理机柜生产厂中国生产机箱机柜最大的最集中的地方在哪?
免费linux主机 分销主机 Dedicated 外国空间 ssh帐号 网通代理服务器 刀片服务器是什么 nerds phpmyadmin配置 爱奇艺vip免费领取 drupal安装 上海电信测速网站 xuni 阿里云邮箱个人版 七牛云存储 好看的空间 香港ip 免费的加速器 ncp是什么 海外加速 更多