形参和返回值

类名作为形参和返回值

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

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

类名作为形参和返回值的练习

x
package ch10;

public class a_1_1Cat {

    public void eat() {
        System.out.println("猫类的eat方法");
    }

}

xxxxxxxxxx
package ch10;

public class a_1_2CatOperator {

    public void useCat(a_1_1Cat c) {  //把a_1_1Cat c作为方法的形参。a_1_1Cat类型的变量c。a_1_1Cat c相当于new a_1_1Cat()
        c.eat(); //使用变量c来调用eat方法
    }

    //上面是'类名作为形参'的代码演示
//--------------------------------------------------------------------------------------------------------
    //下面是'类名作为返回值'的代码演示

    public a_1_1Cat getCat() {  //把返回值类型定义为a_1_1Cat
        a_1_1Cat c = new a_1_1Cat(); //c是a_1_1Cat类型的一个对象。即这行创建了一个对象为c，c相当于new a_1_1Cat()
        return c;
    }
}

xxxxxxxxxx
package ch10;

public class a_1_3测试 {

    public static void main(String[] args) {

        //创建操作类(a_1_2CatOperator)对象,并调用方法
        a_1_2CatOperator co = new a_1_2CatOperator();
        //注意需要创建一个a_1_1Cat对象，为c
        a_1_1Cat c = new a_1_1Cat();
        co.useCat(c); //相当于把new a_1_1Cat()传到useCat()这个方法里面

        //上面是'类名作为形参'的代码演示
//--------------------------------------------------------------------------------------------------------
        //下面是'类名作为返回值'的代码演示

        a_1_1Cat c2 = co.getCat();  //相当于把'new a_1_1Cat()'的内容赋值给这一行。即这一行相当于a_1_1Cat c2 = new a_1_1Cat()
        //上面的c2是a_1_1Cat的对象
        c2.eat();
    }
}

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

抽象类名作为形参: 其实需要的是该抽象类的子类对象 抽象类名作为返回值: 其实返回的是该抽象类的子类对象

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

xxxxxxxxxx
package ch10;

//抽象动物类，关键字abstract
public abstract class a_2_1Animal {
//'a_2_1Animal'类被abstract修饰，变成了抽象类，因为抽象类不能被实例化。所以需要使用多态的形式来创建a_2_1Animal的子类对象
//则需要新建一个a_2_4Cat类继承这个a_2_1Animal，从而使a_2_4Cat为a_2_1Animal的子类

    //抽象的eat方法
    public abstract void eat();

}

xxxxxxxxxx
package ch10;

public class a_2_2AnimalOperator {

    public void useAnimal(a_2_1Animal a) {
    //上面那行，useAnimal方法的参数是a_2_1Animal类型的a。上面那行是探究抽象类名作为参数，其实需要的是该抽象类的子类对象
    //需要创建a_2_4Cat子类，即上面的a_2_1Animal a就相当于new a_2_4Cat()
        a.eat(); //编译看左边，执行看右边
    }

    //上面是'抽象类名作为形参'的代码演示
//--------------------------------------------------------------------------------------------------------
    //下面是'抽象类名作为返回值'的代码演示

    public a_2_1Animal getAnimal() {  //getAnimal()方法的返回值类型是a_2_1Animal类型，即返回a_2_1Animal类型的对象
        //因为a_2_1Animal是抽象类不能直接创建对象，所以返回的是子类的对象，需要创建一个子类对象，如下一行
        a_2_1Animal a = new a_2_4Cat();
        return a; //返回的其实new a_2_4Cat()对象
    }
}

xxxxxxxxxx
package ch10;

public class a_2_3测试 {

    public static void main(String[] args) {

        //创建操作类(a_2_2AnimalOperator)对象，并调用方法
        a_2_2AnimalOperator ao = new a_2_2AnimalOperator();
        //创建动物类的对象，需要提前给创建一个猫类作为动物类的子类
        a_2_1Animal a = new a_2_4Cat();
        ao.useAnimal(a); //按照多态的形式把a传进去。此时的a就是一个对象了
        //上面那行就相当于'a_2_2AnimalOperator'类里面的a_2_1Animal a = new a_2_4Cat()

        //上面是'抽象类名作为形参'的代码演示
//--------------------------------------------------------------------------------------------------------
        //下面是'抽象类名作为返回值'的代码演示

        //a_2_1Animal指的是左边，getAnimal()即a_2_4Cat()指的是右边
        a_2_1Animal a2 = ao.getAnimal(); //ao.getAnimal()相当于new a_2_4Cat()
        //通过a2对象调用eat方法
        a2.eat(); //编译看左边，执行看右边
    }
}

x
package ch10;

public class a_2_4Cat extends a_2_1Animal {

    //继承父类，并且重写父类的eat方法
    @Override
    public void eat() {
        System.out.println("Cat重写Animal的eat方法");
    }
}

接口名作为形参和返回值

抽象类名作为形参: 其实需要的是该接口的实现类对象 抽象类名作为返回值: 其实返回的是该接口的实现类对象

接口名作为形参和返回值的练习

x
package ch10;

public interface a_3_1Jumpping {

    //默认会有abstract修饰符，即接口是抽象的，即下面的jump是抽象的方法
    void jump(); //这行是简写，完整写为public abstract void jump()。因为系统默认会加上public abstract，所以可省略。
    
}

xxxxxxxxxx
package ch10;

public class a_3_2JumppingOperator {

    public void useJumpping(a_3_1Jumpping j) { //useJumpping是方法，里面的形参是接口a_3_1Jumpping，j是接口类型的对象
    //上面那行的a_3_1Jumpping不能直接实例化的，我们需要按照多态的形式创建对象，即需要新建一个a_3_4Cat类，并在创建的这个类里面实现接口
    //然后，上面的形参a_3_1Jumpping j就相当于new a_3_4Cat()。即可以理解为a_3_1Jumpping j = new a_3_4Cat();
    //上面那行注释的a_3_1Jumpping j就是我们说的左边，new a_3_4Cat()就是我们所说的右边
        j.jump(); //编译看左边，执行看右边
    }

    //上面是'接口作为形参'的代码演示
//--------------------------------------------------------------------------------------------------------
    //下面是'接口作为返回值'的代码演示

    public a_3_1Jumpping getJumpping() { //返回值的类型是接口a_3_1Jumpping，真正返回的应该是接口类型的对象
    //因为接口不能实例化，所以返回的应该为'实现类对象'(可以理解为接口的子类)
        a_3_1Jumpping j = new a_3_4Cat(); //a_3_4Cat实现了接口，所以a_3_4Cat是接口的实现类
        return j; //返回的是j，j其实也就是new a_3_4Cat()

    }
}

xxxxxxxxxx
package ch10;

public class a_3_3测试 {

    public static void main(String[] args) {

        //创建操作类(a_3_2JumppingOperator)对象，并调用方法
        a_3_2JumppingOperator jo = new a_3_2JumppingOperator();
        //要先新建一个猫类，在猫类里面实现接口，再输入下面那行
        a_3_1Jumpping j = new a_3_4Cat(); //使用多态的形式创建对象
        jo.useJumpping(j); //这里的j相当于new a_3_4Cat()

        //上面是'接口作为形参'的代码演示
//--------------------------------------------------------------------------------------------------------
        //下面是'接口作为返回值'的代码演示

        //多态的形式创建接口的对象j2
        a_3_1Jumpping j2 = jo.getJumpping();  //jo.getJumpping()相当于new a_3_4Cat()，即a_3_1Jumpping j2 = new a_3_4Cat()
        j2.jump();

    }
}

xxxxxxxxxx
package ch10;

//实现接口，用关键字implements
public class a_3_4Cat implements a_3_1Jumpping {

    //重写接口里的jump方法
    @Override
    public void jump() {
        System.out.println("猫类重写接口类的jump方法");
    }

}