Java形式参数和返回值的问题

形式参数和返回值的问题

（1）.形式参数：

　　　　A.类名：需要该类的对象。

　　　　B.抽象类名：需要该类的子类对象。

　　　　C.接口名：需要该接口的实现类对象。

A.类名作为形式参数

class Student {
  public void study(){
    System.out.println("Study!");
  }
}

class StudentDemo{
  public void method(Student s){  //ss = new Student();    Student s = new Student();
    s.study();
  }
}
class StudentTest{
  public static void main(String[] args){
    Student s =  new Student();    // 利用Student类进行study函数的使用。
    s.study();
    System.out.println("----------------");
    StudentDemo sd = new StudentDemo();
    Student ss = new Student();    //利用StudentDemo类进行输出study。
    sd.method(ss);
    System.out.println("----------------");
    new StudentDemo().method (new Student());  // 匿名对象用法
  }
}

B.抽象名作为形式参数

abstract class Person{
    public abstract void study();
}

class PersonDemo{
    public void method(Person p) {
        p.study();
    }
}

class Stu extends Person{
    public void study() {
        System.out.println("study!");
    }
}

class Student{
    public static void main(String[] args) {
        Person pp = new Stu(); // 利用Stu类调用study函数进行输出。
        pp.study();
        System.out.println("-----------");
        PersonDemo pd = new PersonDemo();//利用PersonDemo类进行调用函数进行输出。
        Person p = new Stu();
        pd.method(p);
    }
}

C.接口作为形式参数

interface Love{
    public abstract void love();
} 

class LoveDemo{
    public void method(Love l) {
        l.love();
    }
}

class LoveTest implements Love{
    public void love() {
        System.out.println("Love!");
    }
}

class Demo{
    public static void main(String[] args) {
        LoveDemo ld = new LoveDemo();  // 利用LoveDemo类进行调用输出。
        Love l = new LoveTest();
        ld.method(l);
        System.out.println("-------------");
        Love ll = new LoveTest();   // 利用Love类进行调用输出。
        ll.love();
    }
}

（1）.返回值类型：

　　　　A.类名：返回的是该类的对象。

　　　　B.抽象类名：返回的是该类的子类对象。

　　　　C.接口名：返回的是该接口的实现类的对象。

A.类名作为返回值

class Stu{
    public void study() {
        System.out.println("Study!");
    }
}

class StuDemo{
    public Stu getStu() {
        //Stu s = new Stu();     // 这里有两种形式表达，选取自己较能理解的。
        //return s;
        return new Stu();
    }
}

class StudentTset {
    public static void main(String[] args) {
        StuDemo sd = new StuDemo();   // 利用StuDemo类来进行调用函数输出。
        Stu s = sd.getStu();
        s.study();
    }
}

B.抽象类名作为返回值

abstract class Person{
    public abstract void study();
}

class PersonDemo{
    public Person getPerson() {
        //Person p = new Stu();
        //return p;
        return new Stu();
    }
}

class Stu extends Person{
    public void study() {
        System.out.println("Study!");
    }
}
class Student {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo();  // 利用PersonDemo类来进行调用函数输出。
        Person p = pd.getPerson();
        p.study();
        System.out.println("------------");
        Person pp = new Stu();  // 利用多态进行创建对象并输出。
        pp.study();
        System.out.println("------------");
        Stu s = new Stu();  // 利用Stu类来进行函数调用并输出。
        s.study();
    }
}

C.接口作为返回值

interface Jump{
    public abstract void jump();
}

class JumpDemo{
    public Jump getJump() {
        //Jump j = new Dog();
        //return j;
        return new Dog();
    }
}

class Dog  implements Jump{
    public void jump() {
        System.out.println("can jump!");
    }
}
class Student {
    public static void main(String[] args) {
        JumpDemo jd = new JumpDemo();  // 利用JumpDemo类来进行调用函数输出。
        Jump j = jd.getJump();
        j.jump();
    }
}

上面的代码虽然有一些有比较简单的输出形式，但是没有用到专门所创建的形式参数和返回值的类。我们之所以不用简单的形式就是要把这个 形式参数和返回值的问题 给弄清楚。