java基础--匿名内部类

内部类：

概念：把类定义在其他类的内部，这个类就是内部类。

比如说在类A中定义了一个内部类B，类B就是一个内部类。

内部类的访问特点：

A：内部类可以直接访问外部类的成员，包括私有。

B：外部类要访问内部类，必须创建对象

内部类的位置：

成员内部类(类中方法外)

局部内部类（方法中）

成员内部类：

外部类创建对象格式：外部类名。内部类名 对象名=外部类对象.内部类对象；

成员内部的常见修饰符

。Private为了保证数据的安全性

。Static为了让数据方便访问。

。被静态修饰的成员内部类，只能访问外部类的静态成员

。内部类被静态修饰后的方法

       。静态方法

       。非静态方法

局部内部类：

。可以直接访问外部类的成员

。可以创建内部类对象那个，通过对象调用内部类方法，来使用局部内部类功能。

局部内部类访问局部变量的注意事项：

必须被final修饰：因为局部变量会随着方法的调用而消失，但是局部对象并没有立马从堆内存中消失，还要使用哪个变量，为了让数据还能被继续使用，就用final修饰，这样，在堆内存里边存储的其实是一个常量值。

实例：成员内部类

 

public class Wai {

static int num=20;

int s=0;

static class Nei{

public void print(){

System.out.println("我是内部类的haha方法");

System.out.println(num);

//System.out.println(s);访问s就不可以因为静态的方法只能访问静态变量。

show();

}

}

private static void show(){//不管权限修饰符是private还是public内部类都可以访问。

System.out.println("我是外部类的静态成员方法");

}

}

public class Test {

 

public static void main(String[] args) {

Wai.Nei  sa=new Wai.Nei();//

当内部类被静态修饰后，格式可以简化为

外部类名。内部类名 对象名 new外部类名.内部类名();

sa.print();

}

}

结果：

我是内部类的haha方法

20

我是外部类的静态成员方法

注意事项：如果将内部类改为private修饰那么外部类就不能创建对象。

局部内部类：

实例：

 

public class Outer {

    String name="胡歌" ;

    int age=18;

    public void show(){

    class Inner{

    private String name="薛之谦";

    public int age=18;

    public void Nei(){

    System.out.println(this.name);

    System.out.println(this.age);

    System.out.println(new Outer().name);

    System.out.println(new Outer().age);

    }

    

    }

    //创建内部类对象

Inner aa=new Inner();

aa.Nei();

    }

}

Test:

public class Test {

 

public static void main(String[] args) {

Outer outer = new Outer();

outer.show();

}

}

结果：

薛之谦

18

胡歌

18

 

匿名内部类：

就是内部类的简化写法。

前提：存在一个类或者接口

这里的类可以是具体类也可以是抽象类。

格式：

new 类名或者接口名() {重写方法;}

本质：

是一个继承了类或者实现了接口的子类匿名对象

 

 

1. 请编写程序，通过接口的方式创建匿名内部类

interface Inter {

public abstract void show();

}

//在外部类Outer的method()方法中，创建匿名内部类

 

interface Inter {

void show();

}

 

class Outer {

public static Inter method() {

 

return new Inter() {

 

@Override

public void show() {

System.out.println("helloworld");

}

};

}

}

 

class OuterDemo {

public static void main(String[] args) {

Outer.method().show();

}

}

结果：helloworld

2. 请编写程序，通过抽象类的方式创建匿名内部类

abstract class AbstractClass {

public abstract void show();

}

//在外部类Outer的method()方法中，创建匿名内部类

abstract class Person {

public abstract void show();

}

 

class PersonDemo {

public void method(Person p) {

p.show();

}

}

 

class PersonTest {

public static void main(String[] args) {

new PersonDemo().method(new Person() {

 

@Override

public void show() {

System.out.println("我重写了 show方法");

 

}

});

 

}

}

 

结果：

我重写了 show方法

3. 请编写一个类中定义了一个接口然后在该类中在使用这个接口.

     public class Test {

interface inter{

public abstract void show();

}

public static void main(String[] args) {

new inter(){

 

@Override

public void show() {

System.out.println("我重写了show方法");

}

}.show();

}

}

 

结果：我重写了show方法

总结:我们始终要记得匿名内部类是一个对象。在一个类中可以定义一个内部接口，大多数情况下我们使用内部类的情况是当我们只需要用一次它里边的方法时。就不用重新创建对象。直接采用匿名内部类即可。