Java中的返回值问题,父子类的问题

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java中的返回值问题,父子类的问题相关的知识,希望对你有一定的参考价值。

在java中定义如下类:
public class Father

public class Son extends Father

public class oper
public List<Father> demo()

List<Son> sons=new ArrayList();
Son son=new Son();
sons.add(son);
return sons;


为什么会报错?就返回那里错了

参考技术A 说明:Son 与 Father 是继承关系,并不代表List<Son> 和 List<Father> 就有继承关系,同样 Vector<Son> 和 Vector<Father> 也不存在继承关系,诸如此类:【泛型类】是不存在继承关系的。

代码如下:
/**
* @author T.F 2008-11-19
*
* Son 与 Father 是继承关系,
* 而List<Son> 和 List<Father> 并没有继承关系
* */
package com.work20081119.main;

import java.util.ArrayList;
import java.util.List;

public class TestExtends
public List<Father> demo()
List<Father> sons = new ArrayList<Father>();
Father father = new Father(); // 父类对象
Son son = new Son(); // 子类对象
Father s_f = new Son(); // 上传型对象
sons.add(father);
sons.add(son);
sons.add(s_f);
return sons;


private class Father


private class Son extends Father

参考技术B List<Son>和List<Father>是泛型的,泛型的东西不存在继承,
也就是说在泛型的情况下,List<Son>和List<Father>并不是子类和父类的关系。

所以,返回List<Son>是错误的,只能返回List<Father>
参考技术C 改成下面的就不会报错了!
public class Father

public class Son extends Father

public class oper
public List<Father> demo()

List<Father> sons=new ArrayList<Father>();
Son son=new Son();
sons.add(son);
return sons;

10-02 Java 形式参数和返回值的问题深入研究,链式编程

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

1:形式参数和返回值的问题(理解)
    (1)形式参数:
        类名:需要该类的对象
        抽象类名:需要该类的子类对象
        接口名:需要该接口的实现类对象
    (2)返回值类型:
        类名:返回的是该类的对象
        抽象类名:返回的是该类的子类对象
        接口名:返回的是该接口的实现类的对象
    (3)链式编程
        对象.方法1().方法2().......方法n();
        
        这种用法:其实在方法1()调用完毕后,应该一个对象;
                  方法2()调用完毕后,应该返回一个对象。
                  方法n()调用完毕后,可能是对象,也可以不是对象。

类名作为形式参数

/*
    形式参数:
        基本类型(太简单,不是我今天要讲解的)
        引用类型
            类名:(匿名对象的时候其实我们已经讲过了) 需要的是该类的对象
            抽象类:
            接口
*/
class Student {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo {
    public void method(Student s) { //ss; ss = new Student(); 需要的是该类的对象
        s.study();
    }
}

class StudentTest {
    public static void main(String[] args) {
        //需求:我要测试Student类的study()方法
        Student s = new Student();
        s.study();
        System.out.println("----------------");
        
        //需求2:我要测试StudentDemo类中的method()方法
        StudentDemo sd = new StudentDemo();
        Student ss = new Student();
        sd.method(ss);
        System.out.println("----------------");
        
        //匿名对象用法
        new StudentDemo().method(new Student());
    }
}

抽象类名作为形式参数

/*
    形式参数:
        基本类型(太简单,不是我今天要讲解的)
        引用类型
            类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
            抽象类:需要的是该抽象的子类对象
            接口
*/
abstract class Person {
    public abstract void study();
}

class PersonDemo {
    public void method(Person p) {//p; p = new Student();  Person p = new Student(); //多态
        p.study();
    }
}

//定义一个具体的学生类
class Student extends Person {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class PersonTest {
    public static void main(String[] args) {
        //目前是没有办法的使用的
        //因为抽象类没有对应的具体类
        //那么,我们就应该先定义一个具体类
        //需求:我要使用PersonDemo类中的method()方法
        PersonDemo pd = new PersonDemo();
        Person p = new Student();
        pd.method(p);
    }
}

接口名作为形式参数

/*
    形式参数:
        基本类型(太简单,不是我今天要讲解的)
        引用类型
            类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
            抽象类:需要的是该抽象的子类对象
            接口:需要的是该接口的实现类对象
*/
//定义一个爱好的接口
interface Love {
    public abstract void love();
}

class LoveDemo {
    public void method(Love l) { //l; l = new Teacher();  Love l = new Teacher(); 多态
        l.love();
    }
}

//定义具体类实现接口
class Teacher implements Love {
    public void love() {
        System.out.println("老师爱学生,爱Java,爱林青霞");
    }
}

class TeacherTest {
    public static void main(String[] args) {
        //需求:我要测试LoveDemo类中的love()方法
        LoveDemo ld = new LoveDemo();
        Love l = new Teacher();
        ld.method(l);
    }
}

 

类名作为返回值类

/*
    返回值类型
        基本类型:(基本类型太简单,我不准备讲解)
        引用类型:
            类:返回的是该类的对象
            抽象类:
            接口:
*/
class Student {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo {
    public Student getStudent() {
        //Student s = new Student();
        //Student ss = s;
        
        //Student s = new Student();
        //return s;
        return new Student();
    }
}

class StudentTest2 {
    public static void main(String[] args) {
        //需求:我要使用Student类中的study()方法
        //但是,这一次我的要求是,不要直接创建Student的对象
        //让你使用StudentDemo帮你创建对象
        StudentDemo sd = new StudentDemo();
        Student s = sd.getStudent(); //new Student(); Student s = new Student();
        s.study();
    }
}

 

抽象类作为返回值类型

/*
    返回值类型
        基本类型:(基本类型太简单,我不准备讲解)
        引用类型:
            类:返回的是该类的对象
            抽象类:返回的是该抽象类的子类对象
            接口:
*/
abstract class Person {
    public abstract void study();
}

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

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

class PersonTest2 {
    public static void main(String[] args) {
        //需求:我要测试Person类中的study()方法
        PersonDemo pd = new PersonDemo();
        Person p = pd.getPerson(); //new Student();  Person p = new Student(); 多态
        p.study();
    }
}

 

接口作为返回值类型

/*
    返回值类型
        基本类型:(基本类型太简单,我不准备讲解)
        引用类型:
            类:返回的是该类的对象
            抽象类:返回的是该抽象类的子类对象
            接口:返回的是该接口的实现类的对象
*/
//定义一个爱好的接口
interface Love {
    public abstract void love();
}

class LoveDemo {
    public Love getLove() {
        //Love l = new Teacher();
        //return l;
        
        return new Teacher();
    }
}

//定义具体类实现接口
class Teacher implements Love {
    public void love() {
        System.out.println("老师爱学生,爱Java,爱林青霞");
    }
}

class TeacherTest2 {
    public static void main(String[] args) {
        //如何测试呢?
        LoveDemo ld = new LoveDemo();
        Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态
        l.love();
    }
}

 

链式编程

/*
    链式编程。
        每次调用完毕方法后,返回的是一个对象。
*/
class Student {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo {
    public Student getStudent() {
        return new Student();
    }
}

class StudentTest3 {
    public static void main(String[] args) {
        //如何调用的呢?
        StudentDemo sd = new StudentDemo();
        //Student s = sd.getStudent();
        //s.study();
        
        //大家注意了,这里采用链式编程
        sd.getStudent().study();
    }
}

以上是关于Java中的返回值问题,父子类的问题的主要内容,如果未能解决你的问题,请参考以下文章

Java中方法类里面有返回值和没有返回值问题!

父子窗体返回值与互操作

Java中子类重写父类的方法为啥返回值类型要小于等于父类方法的返回值类型?

JS中的方法可不可以有返回值

类的无参方法

java第五章:面向对象(oop)