java学习笔记19-形参和返回值，内部类

类名作为形参和返回值

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

代码

package unit_16xingcanhefanhuizhi.test1;

public class CatOperator {

    public void useCat(Cat c){ //Cat c = new Cat();
        c.eat();
    }

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

package unit_16xingcanhefanhuizhi.test1;

public class Cat {

    public void eat(){
        System.out.println("猫吃鱼");
    }
}

package unit_16xingcanhefanhuizhi.test1;

public class CatDemo {

    public static void main(String[] args) {
        //创建操作类对象，并调用方法
        CatOperator co = new CatOperator();
        Cat c = new Cat();
        co.useCat(c);

        Cat c2 = co.getCat(); // new Cat
        c2.eat();
    }
}

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

• 方法的形参是抽象类名，其实需要的是改抽象类的子类对象
• 方法的返回值是抽象类名，其实返回的是改抽象类的子类对象

代码

package unit_16xingcanhefanhuizhi.test2;

public class AnimalOperator {

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

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

package unit_16xingcanhefanhuizhi.test2;

public abstract class Animal {

    public abstract void eat();
}

package unit_16xingcanhefanhuizhi.test2;

public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package unit_16xingcanhefanhuizhi.test2;

public class AnimalDemo {
    public static void main(String[] args) {
        //创建操作类对象，并调用方法
        AnimalOperator ao = new AnimalOperator();
        Animal a = new Cat();
        ao.useAnimal(a);

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

接口名作为形参和返回值

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

代码

package unit_16xingcanhefanhuizhi.test3;

public class JumppingOperator {

    public void useJumpping(Jumpping j){ //Jumpping j = new Cat();
        j.jump();
    }

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

package unit_16xingcanhefanhuizhi.test3;

public interface Jumpping {

    void jump();
}

package unit_16xingcanhefanhuizhi.test3;

public class Cat implements Jumpping{

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

package unit_16xingcanhefanhuizhi.test3;

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();
    }
}

内部类概述

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

内部类的定义格式

• 格式：

public class 类名{
    修饰符 class 类名{
    }
}

• 范例:

public class Outer {
    public class Inner {

    }
}

内部类的访问特点

• 内部类可以直接访问外部类的成员，包括私有
• 外部类要访问内部类的成员，必须创建对象

范例

package unit_17InnerClass.test1;

public class Outer {

    private int num = 10;

    public class Inner {

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

    public void method(){
//        show();

        Inner i = new Inner();
        i.show();
    }
}

成员内部类

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

• 在类的成员位置：成员内部类
• 在类的局部位置：局部内部类

成员内部类，外界如何创建对象使用呢？

• 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；
• 范例：Outer.Inner oi = new Outer().new Inner();

代码

package unit_17InnerClass.test2;

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();
    }
}

package unit_17InnerClass.test2;

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();

    }
}

局部内部类

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

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

代码

package unit_17InnerClass.test3;

public class Outer {

    private int num = 10;

    public void method(){
        int num2 = 20;
        class  Inner {
            public void show(){
                System.out.println(num);
                System.out.println(num2);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}

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

匿名内部类

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

• 格式：

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

• 范例：

new Inter(){
    public void show(){

    }
}

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

代码

package unit_17InnerClass.test4;

public interface Inter {

    void show();
}

package unit_17InnerClass.test4;

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();
         */

        // 是接口的实现类对象
        Inter i = new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };

        i.show();
    }
}

package unit_17InnerClass.test4;

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

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

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

//接口操作类，里面有一个方法
public class JumppingOperator {
    public void method (Jumpping j) {
        j.jump();
    }
}

//测试类
public class JumppingDemo {
    public static void main (String[] args){
        //需求：创建接口操作类的对象，调用method方法
    }
}

代码

package unit_17InnerClass.test5;
//跳高接口
public interface Jumpping {

    void jump();
}

package unit_17InnerClass.test5;

public class JumppingOperator {

    public void method(Jumpping j){ //new Cat
        j.jump();
    }
}

package unit_17InnerClass.test5;

public class Cat implements Jumpping{

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

package unit_17InnerClass.test5;

public class Dog implements Jumpping{

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

package unit_17InnerClass.test5;
//测试类
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("狗可以跳了");
            }
        });

    }
}