java12-类抽象类名接口名作形参和返回值-成员内部类-局部内部类-匿名内部类

java12-类/抽象类名/接口名作形参和返回值-成员内部类-局部内部类-匿名内部类 形参和返回值

形参和返回值：
①基本数据类型：比较简单不介绍
②引用数据类型：重点介绍面向对象过程中的抽象类和接口

类名作为形参和返回值

① 方法的形参是类名，说明 需要是该类的对象

    public void useCat(Cat c){
        c.eat();
    }
    
    //创建 *** 作类对象，并调用useCat方法
    CatOperator c = new CatOperator();
    //由于CatOperator类中的方法useCat需要一个Cat类型的对象
    Cat cc = new Cat();
    c.useCat(cc);

② 方法的返回值是类名，说明 返回的是该类的对象

    public Cat getCat(){
        Cat c = new Cat();
        return c;
    }

抽象类名作为参数和返回值

① 方法的形参是抽象类名，说明 需要该抽象类的子类对象

    public void useAnimal(Animal a){
        a.eat();
    }

   AnimalOperator ao = new AnimalOperator();
   //调用useAnimal方法，此时参数是抽象类对象
   //它的实例化必须使用多态的形式
   Animal c = new Cat();
   ao.useAnimal(c);

② 方法的返回值是抽象类名，说明 返回的是该抽象类的子类对象

 public Animal getAnimal() {
     Animal ao = new Cat();
     return ao;
 }

接口名作为形参和返回值

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

public void useJumpping(Jumpping j){
    // 测试类中Jumpping jj = new Cat();
    j.jump();
}

JumppingOperator jo = new JumppingOperator();
//接口不能直接实例化，需要创建接口的实现类，采用多态的形式创建实现类对象
Jumpping jj = new Cat();
//编译看左边，执行看右边； 左侧Jumpping类有jump这个方法；右侧Cat中重写了jump这个方法
jo.useJumpping(jj);

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

public Jumpping getJumpping() {
    Jumpping j = new Cat();
    return j;
}

Jumpping jo2 = jo.getJumpping();
jo2.jump();

内部类 概述

概念： 就是在一个类中定义一个类。
格式：

public class 类名{
	修饰符 class 类名{
	}
}
内部类修饰符 一般是private

特点：
①内部类可以直接访问外部类的成员，包括私有

public class Outer {
    //内部类可以访问外部类的成员
    private int age = 20;
    //内部类 Inter
    public class Inter{
        public void show(){
            System.out.println(age);
        }
    }
}

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

// 外部类 Outer
public class Outer {
    //内部类可以访问外部类的成员
    private int age = 20;
    //内部类 Inter
    public class Inter{
        public void show(){
            System.out.println(age);
        }
    }

    public void method(){
        //外部类访问内部类的成员，必须创建内部类的方法
//        show();//直接访问会报错
        Inter i = new Inter();
        i.show();
    }
}

内部类分类：
根据内部类在类中定义的位置不同：
①在类的成员位置：成员内部类
②在类的局部位置：局部内部类

成员内部类 格式

public class Outer {
    private int num = 20;
    //Inter就是Outer类的成员内部类
    public class Inter{
        public void show(){
            System.out.println(num);
        }
    }
}

访问

成员内部类，外界创建对象访问 格式：
前提是 内部类定义通过public修饰。

外部类名.内部类名 对象名 = 外部类对象.内部类对象；
例子：Outer.Inter oi = new Outer（）.new Inter（）；

理解xhj：
出现内部类的原因是：把内部类的内容隐藏起来，不想让外界直接看到/访问。则内部类定义 修饰符的位置不是public而是private。

内部类修饰符是private时，内部类中的方法访问 方式：

在外部类中 创建成员方法：创建内部类对象，通过对象调用方法实现访问
在测试类中 创建外部类的对象，通过对象调用外部类成员方法的形式实现对内部类方法的访问。

public class Outer {
    private int num = 20;
    //Inter就是Outer类的成员内部类

//    public class Inter{
//        public void show(){
//            System.out.println(num);
//        }
//    }
    private class Inter{
        public void show(){
            System.out.println(num);
        }
    }
    public void method(){
        Inter i = new Inter();
        i.show();
    }
}

public class OuterDemo {
    public static void main(String[] args) {

        //创建内部类对象，并调用方法

        //内部类 采用修饰符public，可以采用上述方式访问内部类中的方法

        //内部类 采用修饰符private，采用下述形式访问内部类方法。
        // 在外部类中写方法，方法中 创建内部类对象，通过对象.方法实现对内部类的访问。
        Outer o = new Outer();
        o.method();//20
    }
}

局部内部类 格式

位置是：位于外部类成员方法中。

public class Outer {
    private int num = 10;
    
    public  void method(){
        class Inter{
            public void show(){
                System.out.println(num);
            }
        }
    }
}

访问

特点① 局部内部类是在方法中定义的类，所以外部是无法直接使用，需要在方法内部创建对象并使用。
特点② 该类可以直接访问外部类的成员变量，也可以访问方法内的局部变量。

public class Outer {
	外部类的成员变量
    private int num = 10;
    public  void method(){
        外部类成员方法内的局部变量
        int num2 = 30;
        class Inter{
            public void show(){
                System.out.println(num);//10
                System.out.println(num2);//20
            }
        }
        Inter i = new Inter();
        i.show();
        创建外部类成员，不在内部类中创建对象、调用show方法，外部类创建的对象将不能访问内部类的show方法
    }
}

public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
①method方法中只有局部内部类 Inter 则外部类Outer对象调用method方法什么也不执行。
②method方法中有局部内部类Inter；Inter类的实例化对象；对象.show方法，此时执行结果是外部类的成员变量num = 10
③method方法中有局部内部内Inter；Inter类的实例化对象；对象.show方法；Inter内部输出外部类的成员变量/外部类成员方法method的局部变量，此时执行结果是外部类的成员变量num = 10、外部类成员方法的局部变量 num2 = 30
    }
}

匿名内部类 概述

匿名内部类 = 是局部内部类的一种。
前提： 存在一个类或者接口，类可以是具体类或抽象类
格式：

new 类名或者接口名（）{
	重写方法；
}；
理解：
①这里的new 类名或者接口名（） 说明整体是一个对象，只不过对象没有名字，也称为匿名对象，即匿名类本质是一个匿名对象。
②重写方法，说明它继承了前面的类 或者 实现了前面的接口。

本质： 是一个继承了该类或者实现了该接口的子类匿名对象。
案例：
公共部分：

// 接口
public interface Inter {
    //接口 = 抽象内容
    // 抽象方法
    public abstract void show();
}
//测试类
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

public class Outer {
    //匿名内部类是局部内部类的一种，所以需要在外部类的方法中书写
    public void method(){
        //匿名内部类的前提是 存在一个类或接口 所以需要先定义类或者接口 本案例中定义一个接口
       new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类的show方法");
            }
        };
        //此时method方法中有 内容了，执行测试类 但是没有输出结果
}

public class Outer {
    //匿名内部类是局部内部类的一种，所以需要在外部类的方法中书写
    public void method(){
        //要想实现匿名内部类方法的调用，匿名内部类的本质是 继承了类或接口的对象，所以可以直接匿名内部类.方法进行方法的调用。
        new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类的show方法");
            }
        }.show();
        如果想多次调用该方法，则重复写即可。
        new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类的show方法");
            }
        }.show();
}

public class Outer {
    //匿名内部类是局部内部类的一种，所以需要在外部类的方法中书写
    public void method(){
        //但如果多次调用，则一直重复会造成代码复用性差，
        //new 是Inter（），并且又重写了show方法，则new Inter(){}整体可以认为是 接口Inter的实现类对象 那么可以按照多态的形式 将其赋值给Inter类接口。
        
        Inter i = new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类的show方法");
            }
        };
        i.show();
    }
}

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

分析：
创建 *** 作类对象，调用method方法
method方法 参数是接口名时，说明需要的是 接口实现类的对象

public class JumppingOperator {
    //接口的 *** 作类
    public  void method(Jumpping j){
        //参数是接口名，说明需要的是 接口的实现类对象
        j.jump();
    }
}

这时 可以采用匿名内部类的形式，new 类名/接口名（）{重写方法；}； 匿名内部类的本质是：继承类或实现接口的对象。

// 创建 JumppingOperator *** 作类 的 对象
JumppingOperator j = new JumppingOperator();
j.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });

完整：

public interface Jumpping {
    //接口是抽象的内容，接口中定义方法修饰符不写 默认是public abstract
    void jump();
}
public class JumppingOperator {
    //接口的 *** 作类
    public  void method(Jumpping j){
        //参数是接口名，说明需要的是 接口的实现类对象
        j.jump();
    }
}
// 测试类
public class JumppingDemo {
    public static void main(String[] args) {
        // 创建 *** 作类对象，调用method方法
        // method方法 参数是接口名时，说明需要的是 接口实现类的对象
        // 这时 可以采用匿名内部类的形式，new 类名/接口名（）{重写方法；}； 匿名内部类的本质是：继承类或实现接口的对象。
        JumppingOperator j = new JumppingOperator();
        Jumpping jj = new Cat();
        j.method(jj);//方法需要的 Jumpping接口的实现类对象

        System.out.println("--------------");
        //如果多次创建 Jumpping接口的 不同实现类 这样会产生多个类文件，只是用一次，会造成文件冗余。采用匿名内部类实现。
        j.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });
        //其本质需要是的Jumpping接口实现类的对象，使用匿名内部类的形式，不用额外创建Jumpping的实现类。
    }
}