面向对象设计-形参和返回值、内部类（成员、局部、匿名）

形参和返回值

类作为形参和返回值

抽象类作为形参和返回值

接口作为形参和返回值

内部类

内部类概述

引入：

​ 我们现在做一个应用程序，需要描述一台电脑（Computer）中的CPU，对于电脑而言，

​ 1，它有存储设备，IO设备等等很多硬件资源组件

​ 2，CPU是电脑中最重要的组件

​ 思考：怎么用Java描述这台电脑中的CPU？

在Java语言中类可以嵌套定义，内部类（inner class）是定义在另一类当中的类；在内部类课程当中，我们统一规定，像Cpu这种类我们称之为内部类，Computer这种类我们称之为外围类，IntroductionDemo这种类我们称之为外部类。

接下来我们系统的学习一下，内部类

内部类分类（按照内部类在类中定义的位置不同）：

​ 1，定义在成员位置的内部类，成员内部类

​ 2，定义在局部位置的内部类，局部内部类

成员内部类

第一种调用成员内部类方法：
Outer

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

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

}

InnerDemo

/*
    测试类
 */
public class InnerDemo {
    public static void main(String[] args) {
        //创建内部类对象，并调用方法
        //Inner i = new Inner();//不能直接创建内部类对象

        Outer.Inner oi = new Outer().new Inner();
        oi.show();

    /*    Outer o = new Outer();
        o.method();*/

    }
}

第二种调用成员内部类方法：
Outer

public class Outer {

    private int num = 10;

    /*
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    */

    private class Inner {
        public void show() {
            System.out.println(num);
        }
    }

    public void method() {
        Inner i = new Inner();
        i.show();
    }

}

InnerDemo

public class InnerDemo {
    public static void main(String[] args) {
        //创建内部类对象，并调用方法
//        Inner i = new Inner();

//        Outer.Inner oi = new Outer().new Inner();
//        oi.show();

        Outer o = new Outer();
        o.method();

    }
}

局部内部类

Outer

public class Outer {

    private int num = 10;

    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);//可直接访问成员变量（private）
                System.out.println(num2);//可直接访问成员方法中的局部变量
            }
        }

        Inner i = new Inner();//创建内部类对象
        i.show();//通过内部类的对象间接访问局部内部类中的成员方法
    }
}

OuterDemo

/*
    测试类
 */
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

匿名内部类（属于局部内部类）

引入： 匿名类的含义就是这个类没有名字

案例： 回顾一下,当需要一个子类对象的时候，我们需要两步步：

​ 1，定义子类

​ 2，创建子类对象

通过定义匿名内部类对象，我们可以将上面的两步变为一步。

Inter

public interface Inter {
    void show();
}

Outer

public class Outer {

    public void method() {
        /*
        new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        */

//        show();

        /*
        new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();

        new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show(); //此种多次调用不方便
        */

        Inter i = new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };

        i.show();//通过把匿名内部类对象赋值给变量i，通过i来调用
        i.show();
    }
}

OuterDemo

/*
    测试类
 */
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

匿名内部类的使用优缺点：

​ 1，当我们只使用一次某类或者某接口的子类对象时，使用匿名内部类，会稍微方便一点

​ 2，如果需要多次访问子类对象的成员，匿名内部类很麻烦。

​ 3，如果访问匿名子类中的独有方法，必须用匿名对象去访问

开发中的匿名内部类

Jumpping

/*
    跳高接口
 */
public interface Jumpping {
    void jump();
}

Cat

public class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

Dog

public class Dog implements Jumpping {
    @Override
    public void jump() {
        System.out.println("狗可以跳高了");
    }
}

JumppingOperator

/*
    接口操作类，里面有一个方法，方法的参数是接口名
 */
public class JumppingOperator {
    public void method(Jumpping j) { //new Cat();   new Dog();
        j.jump();
    }
}

JumppingDemo

/*
    测试类
 */
public class JumppingDemo {
    public static void main(String[] args) {
        //需求：创建接口操作类的对象，调用method方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();//通过接口多态的方式创建对象
        jo.method(j);

        Jumpping j2 = new Dog();
        jo.method(j2);//
        System.out.println("--------");

        jo.method(new Jumpping() {//通过匿名内部类的方式创建对象
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });

        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("狗可以跳高了");
            }
        });
    }
}

1. 方法的实际参数

   学习多态的时候我们曾经讲过，可以将父类作为形式参数，而将子类作为实际参数在方法调用的时候传入这一规则

而匿名内部类的匿名对象就是一个子类匿名对象，所以，可以使用匿名内部类改进以前的做法。

2. 方法体中，return 返回值只会执行一次，如果方法返回一个接口类型的对象，我们也可以使用匿名内部类

内部类的访问注意事项

​ 1，内部类的成员方法中，去访问外部的成员（普通或静态）

​ 2，内部类没有静态方法，内部类中的静态成员变量必须是final的

​ 2，外围类的普通成员方法，访问内部类的成员（普通成员，静态成员）

​ 3，外围类的静态成员方法，访问内部类的成员（普通成员，静态成员）

​ 4，其他类的普通成员方法，访问内部类的成员（普通成员，静态成员）

​ 5，外部类的静态成员方法，访问内部类的成员（普通成员，静态成员）

成员内部类分静态和非静态两种，成员内部类类比成员

局部内部类类比局部变量

局部内部类中尤其需要关注，局部内部类中的方法去访问局部变量的问题

内部类的访问特征：

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

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

​ 3，其他类要访问内部类的成员，依赖于该内部类的访问权限