java-内部类与匿名内部类

内部类：

类名、抽象类名、接口 作为形参和返回值

1.类名作为形参和返回值:

方法的形参是类名，其实需要的是该类的对象

方法的返回值是类名，其实返回的是该类的对象

public class Cat {

​    public void eat(){

​        System.out.println("猫吃鱼");

​    }

}

class CatOperator{

​    public void useCat(Cat c){ //Cat c=new Cat();

​        c.eat();

​    }

​    public Cat getCat(){

​        Cat c = new Cat();

​        return c;

​    }

}

//测试类

class test07{

​    public static void main(String[] args) {

​        CatOperator co = new CatOperator();

​        Cat c =new Cat();

//方法的形参是类名，其实需要的是该类的对象

​        co.useCat(c);

//方法的返回值是类名，其实返回的是该类的对象

​        co.getCat().eat();

​    }

}

2.抽象类名作为形参和返回值

方法的形参是抽象 类名，其实需要的是该抽象类的子类对象

方法的返回值是类名，其实返回的是该抽象类的子类对象

public abstract class Animal {

​    public abstract void eat();

}

public class AnimalOperator{

​    public void useAnimal(Animal a){ //Animal a = new Rabbit();

​        a.eat();

​    }

​    public Animal getAnimal(){

​        Animal r = new Rabbit();

​        return r;

​    }

}

//测试类

public class AnimalTest{

​    public static void main(String[] args) {

​        AnimalOperator ao =new AnimalOperator();

​        Animal rabbit = new Rabbit();

//方法的形参是抽象 类名，其实需要的是该抽象类的子类对象

​        ao.useAnimal(rabbit);

//方法的返回值是类名，其实返回的是该抽象类的子类对象

​        ao.getAnimal().eat();

​    }

}

3.接口名作为形参和返回值

方法的形参是接口名，其实需要的是该接口的实现类对象

方法的返回值是接口名，其实返回的是该接口的实现类对象

public interface Jumping {

​    //抽象方法

​    void jump();

}

public class JumpingOperator {

​    public void useJumping(Jumping j){ // Jumping j=new Dog();

​        j.jump();

​    }

​    public Jumping getJumping(){

​        Jumping j = new Dog();

​        return j;

​    }

}

public class Dog implements Jumping{

​    public void jump() {

​        System.out.println("狗可以跳高");

​    }

}

//测试类

public class JumpingTest {

​    public static void main(String[] args) {

​        //创建操作类对象并调用方法

​        JumpingOperator jo = new JumpingOperator();

​        Jumping j =new Dog();

//方法的形参是接口名，其实需要的是该接口的实现类对象

​        jo.useJumping(j);

//方法的返回值是接口名，其实返回的是该接口的实现类对象

​        Jumping j2 = jo.getJumping();

​        j2.jump();      

​    }

}

内部类：

内部类概述：

就是在一个类中定义一个类，举例：在一个类A的内部定义一个类B，类B就称为内部类

格式：

public class 类名{

修饰符 class 类名{

}

}

内部类的访问特点：

1）内部类可以直接访问外部类的成员，包括private

2）外部类要访问内部类的成员，必须创建对象

内部类的分类：

按照内部类在类中定义位置的不同，可以分为如下2种形式

1）在类的成员位置：成员内部类

2）在类的局部位置：局部内部类

成员内部类，创建使用：

//内部类为public

public class Outer {

​    private int number=10;

​    public class Inner{

​       public void show(){

​           System.out.println(number);

​       }

​    }

​    public void method(){

​        Inner i = new Inner();

​        i.show();

​    }

}

class test08{

​    public static void main(String[] args) {

​        //创建内部类对象

​        Outer.Inner inner = new Outer().new Inner();

​        inner.show();

​    }

}

//内部类为private

public class Outer {

​    private int number=10;

​    private class Inner{

​       public void show(){

​           System.out.println(number);

​       }

​    }

​    public void method(){

​        Inner i = new Inner();

​        i.show();

​    }

}

class test08{

​    public static void main(String[] args) {

​        //创建内部类对象

​        Outer o = new Outer();

​        o.method();

​    }

}

局部内部类：

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用

该类可以直接访问外部类的成员，也可以访问内部类的局部变量

public class Outer1 {

​    private int num=20;

​    public void method(){

​        class Inner1{

​            public void show(){

​                int num2 =30;

​                //局部内部类访问外部类的成员

​                System.out.println(num);

​                System.out.println(num2);

​            }

​        }

​        //方法内部创建局部内部类对象，才可使用局部内部类对象

​        Inner1 i =new Inner1();

​        i.show();

​    }

}

class OutTest{

​    public static void main(String[] args) {

​        Outer1 o1 = new Outer1();

​        o1.method();

​    }

}

匿名内部类（为局部内部类的一种特殊形式）

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

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

new 类名或者接口名(){

重写方法;

}

public class Outer2 {

​    public void method(){

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

​        new Inter(){

​            public void show() {

​                System.out.println("匿名内部类");

​            }

​        }.show();

​    }

}

class test10{

​    public static void main(String[] args) {

​        Outer2 o2 = new Outer2();

​        o2.method();

​    }

}

匿名内部类的多次调用

ublic class Outer2 {

​    public void method(){

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

​        Inter i =new Inter(){

​            public void show() {

​                System.out.println("匿名内部类");

​            }

​        };

​        //实现匿名内部类的多次调用

​        i.show();

​        i.show();

​    }

}

class test10{

​    public static void main(String[] args) {

​        Outer2 o2 = new Outer2();

​        o2.method();

​    }

}

匿名内部类在开发中的使用

public interface Jumping {

​    //抽象方法

​    void jump();

}

public class JumpingOperator {

​    public void useJumping(Jumping j){ // Jumping j=new Dog();

​        j.jump();

​    }

}

public class Dog implements Jumping{

​    public void jump() {

​        System.out.println("狗可以跳高");

​    }

}

public class JumpingTest {

​    public static void main(String[] args) {

​        //创建操作类对象并调用方法

​        JumpingOperator jo = new JumpingOperator();

​        Jumping j =new Dog();		//不使用匿名内部类，创建类猫狗兔子实现 Jumping接口的方式

​        jo.useJumping(j);

​        System.out.println("----------");

​        //运用匿名内部类不需要在走 创建类猫狗兔子实现 Jumping接口了，如果有猫 狗 兔子....要实现跳高直接用下面的方式编写

​		//匿名内部类本质：一个继承了该类或者实现了该接口的子类匿名对象

​        jo.useJumping(new Jumping() {

​            public void jump() {

​                System.out.println("猫可以跳高了1111");

​            }

​        });

​        jo.useJumping(new Jumping() {

​            public void jump() {

​                System.out.println("狗可以跳高了1111");

​            }

​        });

​    }

}