20220729学习内容匿名内部类

寒吻

已于 2022-08-08 17:03:29 修改

阅读量86

点赞数

文章标签： eclipse java 学习

于 2022-07-29 20:13:06 首次发布

本文链接：https://blog.csdn.net/weixin_51183285/article/details/126063230

版权

本文探讨了Java编程中的匿名内部类，指出其在必须继承或实现外部类或接口时的应用。匿名内部类没有名称，因此也没有构造函数。当其继承带有参数构造函数的父类时，创建时需提供相应参数。文章还提到了使用匿名内部类的场景和优势，并涉及到多态、重写以及实例初始化等核心概念。

摘要由CSDN通过智能技术生成

匿名内部类就是内部类的简写格式

public class A1{

public void pp(){

class B1 extends C1{}

}

}

// 简化写法

public class A1{

public void pp(){

new C1(){};// 原始命名类的写法 class B1 extends C1{} new B1();

}

}

public class A1 {

public void pp (){

new Object (){

public void ff (){ //ff 方法在父类中没有定义，则只能直接调用

System . out . println ( "anon inner class ... ff" );

}

}. ff ();

}

public static void main ( String [] args ) {

A1 a1 = new A1 ();

a1 . pp ();

}

}

下面写法使用较多

public class A1 {

public void pp (){

Object obj = new Object (){

@Override // 覆盖父类中定义的方法

public String toString () {

return ( "anon inner class ... ff" );

}

public void dd (){} // 无法调用

};

System . out . println ( obj . toString ()); // 调用匿名内部类中覆盖定义的方法

}

}

匿名内部类的前提是必须继承或者实现一个外部类或者接口

new interfacename (){......};

new superclassname (){......};

如果父类中没有无参构造器，则 () 中应该有对应的参数

public class A1 {

public void pp (){

new B1 ( 20 ){ // 因为 B1 类中没有无参构造器，必须直接传入参数

};

}

}

class B1 {

private int age ;

public B1 ( int age ){

this . age = age ;

}

}

匿名内部类由于没有名字，所以它没有构造函数

如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数

不能定义静态成员

匿名内部类的使用场景

当方法参数是接口类型时，而且接口中的方法不超过三个 , 可以用匿名内部类作为实际参数进行传递

匿名内部类的使用限制

匿名内部类不能是抽象的

匿名内部类不能定义构造器，默认和父类相似的构造器

JDK1.8- 要求给局部内部类、匿名内部类访问的局部变量必须使用 final 修饰，从 JDK1.8 开始这个现

实被取消了，但是默认是 final 的（不能修改 )

public void pp () {

final Date birth = new Date ();

class C1 {

public void ff () {

System . out . println ( birth );

birth . setYear ( 2000 ); // 3900

// birth=new Date(); 语法报错

System . out . println ( "modify year:" + birth );

}

}

new C1 (). ff ();

}

int等8种简单类型/Integer8种简单类型的包装类/String的使用中应该注意

内部类的使用场景和好处：

每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个 ( 接口的 ) 实现，

对于内部类都没有影响。内部类使得多继承的解决方案变得完整

方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏

练习题：

第 1 题考核知识点：属性与多态无关

package com.yan.test01; 
public class Test01 {
 public static void main(String[] args) {
 A a = new B(); 
System.out.println(a.num); 
System.out.println(((B)a).num); 
System.out.println(((A)((B)a)).num); 
System.out.println("-------------------");
 B b = new B(); 
System.out.println(b.num);
 System.out.println(((A)b).num);
} 
}
class A{ 
int num = 1; 
}
class B extends A{
 int num = 2; 
}

第 2 题考核知识点：实例初始化方法，属性与多态无关：

package com . yan . test02 ;

public class Test02 {

public static void main ( String [] args ) {

Father f = new Son ();

System . out . println ( f . x );

}

}

class Father {

int x = 10 ;

public Father (){

this . print ();

x = 20 ;

}

public void print (){

System . out . println ( "Father.x = " + x );

}

}

class Son extends Father {

int x = 30 ;

public Son (){

this . print ();

x = 40 ;

}

public void print (){

System . out . println ( "Son.x = " + x );

}

}

第3题考核知识点：多态，重写，实例初始化过程：

package com . yan . test03 ;

public class Test03 {

public static void main ( String [] args ) {

Base b1 = new Base ();

Base b2 = new Sub ();

}

}

class Base {

Base () {

method ( 100 );

}

public void method ( int i ) {

System . out . println ( "base : " + i );

}

}

class Sub extends Base {

Sub () {

super . method ( 70 );

}

public void method ( int j ) {

System . out . println ( "sub : " + j );

}

}

第4题考核知识点：多态、重载、重写：

public class Test04 {

public static void main ( String [] args ) {

A a1 = new A ();

A a2 = new B ();

B b = new B ();

C c = new C ();

D d = new D ();

System . out . println ( "(1)" + a1 . show ( b ));

System . out . println ( "(2)" + a2 . show ( d ));

System . out . println ( "(3)" + b . show ( c ));

System . out . println ( "(4)" + b . show ( d ));

}

}

class A {

public String show ( D obj ){

return ( "A and D" );

}

public String show ( A obj ){

return "A and A" ;

}

}

class B extends A {

public String show ( B obj ){

return "B and B" ;

}

public String show ( A obj ){

return "B and A" ;

}

}

class C extends B {

}

class D extends B {

}