胎教级内部类讲解

内部类

参数传递

⭐ 一、类名作为形参和返回值

1. 类名作为方法的形参
   方法的形参是类名，其实需要的是该类的对象，实际传递的是该对象的地址值。
2. 类名作为方法的返回值
   类名作为 方法的返回值，返回的也是该对象的地址值。

---

⭐二、抽象类作为形参和返回值

1. 方法的形参是抽象类名，其实需要的是该抽象类的子类对象；
2. 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象。
3. 代码

public abstract class Animal {
   public abstract  void eat();
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗看门");
    }
}
public class AnimalOperator {
    //方法的形参是抽象类名
    public void useAnimal(Animal a) {//Animal a =new Dog
        a.eat();
    }

    //方法的形参是返回值
    public Animal getAnimal() {
        Animal a=new Dog();
        return a;

    }}
    //主方法有部分省略
    AnimalOperator ao =new AnimalOperator();
        Dog d =new Dog();
        ao.useAnimal(d);

        Animal a2=ao.getAnimal();//new Dog
        a2.eat();

---

⭐三、接口名作为形参和返回值

1. 方法的形参是接口名，其实需要的是该接口的实现类对象；
2. 方法的返回值是接口名，其实返回的是该接口的实现类对象。
3. 代码

public interface Jumpping {
    void jump();
}
class JumppingOperator {
    public void useJumpping(Jumpping j) { //Jumpping j = new Cat();
        j.jump();
    }
    public Jumpping getJumpping() {
        Jumpping j = new Cat();
        return j;
    }
}
class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
public class JumppingDemo {
    public static void main(String[] args) {
        //创建操作类对象，并调用方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.useJumpping(j);

        Jumpping j2 = jo.getJumpping(); //new Cat()
        j2.jump();
    }
}

---

⭐内部类

⭐一、内部类的基本使用

1. 含义：在一个类内部中定义一个类。
2. 格式：

/*
	格式：
    class 外部类名{
    	修饰符 class 内部类名{
    	
    	}
    }
*/

3. 内部类的访问特点：内部类可以直接访问外部类成员，包括私有；外部类要访问内部类成员，必须创建对象。

public class one {
    private int number = 1;

    public class Inner {
        public void show() {
            System.out.println(number);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
    //主方法
     public static void main(String[] args) {
        one.Inner w=new one().new Inner();
        w.show();
        
//        one a=new one();
//        a.method();
    }

}

---

♥二、成员内部类

1. 外界创建成员内部类的格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
2. 代码（看上一个代码，弄到一起了）

---

♠三、局部内部类

1. 局部内部类是在方法中定义的类；
2. 局部内部类，外界是不能直接使用，需要在方法内部创建对象并使用（该类可以直接访问外部类的成员，也可以访问方法 内部的局部变量）。

3. ---

♣四、匿名内部类⭐⭐

1. 前提：存在一个类或者接口，（抽象类和具体类都可以）；
2. 匿名内部类的格式：（1）new 类名 ( ) { 重写方法 } （2）new 接口名 ( ) { 重写方法 }
3. 本质：是一个继承了该类或者实现了该接口的子类匿名对象；
4. 细节：匿名内部类可以通过多态的形式接受

Inter i = new Inter(){
  @Override
    public void method(){
        
    }
}

5. 匿名内部类的直接调用方法

public interface Inter{
    void method();
}

public class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method();	// 直接调用方法
    }
}

6. 匿名内部类在开发中的应用：当发现某个方法需要接口或者抽象类的子类，我们就可以用匿名内部类

public class test {
    public static void main(String[] args) {
        JumpingOperator jo =new JumpingOperator();
        Dog d = new Dog();
        jo.method(d);
        jo.method(new Jumping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");

            }
        });
        //匿名内部类的使用
        //此方法可以减少类的创建

    }