面向对象9---形式参数和返回值问题

一.形式参数

1. 形式参数:
   　基本类型
   　引用类型:
   　　类:要的是该类对象
   　　抽象类:要的是该抽象类子类对象
   　　接口:要的是该接口的子类对象
   具体类作为形式参数:

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

class StudentDemo{
    //具体类作为形式参数
    public void method(Student s){
        s.show();
    }
}
//测试类
public class Demo1 {
    public static void main(String[] args){
        StudentDemo a = new StudentDemo();
        Student b = new Student();
        a.method(b);

        //链式编程
        new StudentDemo().method(new Student());
    }
}
输出:
study..
study..

抽象类作为形式参数

abstract class Student2{
    public abstract void show();
}

class StudentDemo2{
    // 抽象类作为形式参数
    public void method(Student2 s){
        s.show();
    }
}
class StudentI extends Student2{
    public void show(){
        System.out.println("study..");
    }
}
//测试类
public class Demo2{
    public static void main(String[] args){
        StudentDemo2 a = new StudentDemo2();
        //向上转型
        Student2 b = new StudentI();
        a.method(b);
    }
}
输出:
study..

接口作为形式参数:

interface Student3{
    public abstract void show();
}

class StudentDemo3{
    //接口作为形式参数
    public void method(Student3 s){
        s.show();
    }
}
class StudentImpl implements Student3{
    public void show(){
        System.out.println("study..");
    }
}
//测试类
public class Demo3{
    public static void main(String[] args){
        StudentDemo3 a = new StudentDemo3();
        //接口多态
        Student3 b = new StudentImpl();
        a.method(b);
    }
}
输出:
study..

---

二.返回值

1. 返回值:
   　基本类型
   　引用类型:
   　　　类:返回的是该类的对象
   　　　抽象类:返回的是该类的子类对象
   　　　接口:返回的是该接口的子类对象
   具体类作为返回值:

class Student{
    public void show(){
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo{
    //这个方法返回值类型是:类
    public Student getStudent(){
        //有名字的对象
//      Student2  = new Student2() ;
//      return s ;

        //匿名对象
        return new Student();
    }
}

//测试类
public class Demo{
    public static void main(String[] args) {
        //创建对象
        StudentDemo sd = new StudentDemo() ;
        //使用sd是StudentDemo2 对象名,
        Student s = sd.getStudent() ;
        s.show();

        //链式编程:
        new StudentDemo().getStudent().show();
    }
}
输出:
Good Good Study,Day Day Up
Good Good Study,Day Day Up

抽象类作为返回值:

abstract class Student1{
    public abstract void show();
}

class StudentDemo1{
    //抽象类作为返回值
    public Student1 method(){
        //报错,抽象类的子类才可以创建对象,作为返回值
//      return new Student1();
        return new Student11();
    }
}

class Student11 extends Student1{
    public void show(){
        System.out.println("study..");
    }
}

public class Demo1{
    public static void main(String[] args){
        StudentDemo1 a =new StudentDemo1();
        Student1 b = a.method();
        b.show();

        //链式编程
        new StudentDemo1().method().show();
    }
}
输出:
study..
study..

接口作为返回值:

interface Student3{
    public abstract void show();
}

class StudentDemo3{
    //接口作为返回值
    public Student3 method(){
        //接口的子实现类
//      return new Student33();//匿名的
        Student33 a = new Student33();
        return a;
    }
}
class Student33 implements Student3{
    public void show(){
        System.out.println("study...");
    }
}
public class Demo2 {
    public static void main(String[] args){
        StudentDemo3 a =new StudentDemo3();
        Student3 b = a.method();
        b.show();

        //链式编程
        new StudentDemo3().method().show();
    }
}
输出:
study...
study...