形式参数与返回值问题

package org.westos_形式参数和返回值问题研究;
/*如果形式参数是引用类型:
                            具体类类:如果形式参数是一个具体类,那么需要创建该类对象
                            抽象类:如果形式参数是抽象类的情况,那么需要自定义一个抽象类的子类,来进行实例化(创建对象)!,创建对象的实质:抽象类多态!
     *                      接口:
     **/
//声明一个抽象类
abstract class Person{
    public abstract void study() ;

}

//定义一个PersonDemo类
class PersonDemo{
    //成员方法
    public void method(Person p){//Person p = new Perosn();//错误的:抽象类不能实例化---->抽象类的多态:Person p = new Student2() ;
        p.study() ;
    }
}

//自定义一个抽象的子类来进行Person的实例化
class Student2 extends Person{

    @Override
    public void study() {
        System.out.println("good good study ,day day up!");
    }

}

//测试类
public class PersonTest {
    public static void main(String[] args) {
        //需求:调用PersonDemo类中method()方法
        //创建PersonDemo类的对象
//      PersonDemo pd = new PersonDemo() ;
        pd.method(p) ;
//      //需要使用抽象类多态来实例化
//      Person  p = new Student2() ;
//      pd.method(p) ;

        //链式编程:
        new PersonDemo().method(new Student2()) ;
    }
}

package org.westos_形式参数和返回值问题研究;
/**
 * 返回值:
 *              具体类:直接返回该类对象(通常实际开发中使用的是匿名对象)
 *              抽象类:返回值如果是抽象类,需要的返回是该抽象类的子类对象
 *              接口:
 * */
abstract class Person2{
    public abstract void show() ;
}

//定义PersonDemo2类
class PersonDemo2{
    public Person2 method(){ // 如果一个方法的返回值是一个抽象类,需要的返回是该抽象类的子类对象
        /*Person2 p = new Teacher() ;
        return p ;*/
        return new Teacher() ;//Person2 p = new Teacher() ;
    }
}

//抽象类的子类
class Teacher extends Person2{

    @Override
    public void show() {
        System.out.println("老师爱高圆圆,爱生活...");
    }

}

//测试类
public class PersonTest2 {
    public static void main(String[] args) {
        //需求:要调用PersonDemo2这个类中的method()方法
        PersonDemo2 pd = new PersonDemo2() ;
        Person2 p = pd.method() ;//pd.method();return new Teacher() ----->Person2 p = new Teacher() ;
        p.show() ;
        System.out.println("----------------");

        //链式编程
        Person2 p2 = new PersonDemo2().method() ;//链式编程
        p2.show() ;
    }
}

package org.westos_形式参数和返回值问题研究;
/**
 * 形式参数:
 *      基本数据类型,你要什么数据类型,在实际传参的时候就传什么数据类型;形式参数的改变对实际参数没有影响(String是引用类型和基本数据类型的效果一样String s ="abc")
 *      如果形式参数是引用类型:
 *                      具体类类:如果形式参数是一个具体类,那么需要创建该类对象
 *                      抽象类:
 *                      接口:
 * 
 * 返回值:
 *              具体类:直接返回该类对象(通常实际开发中使用的是匿名对象)
 *              抽象类:
 *              接口:
 * */

class Demo{
    //成员方法
    public float sum(float a,float b){
        return  (a + b) ;
    }
}
//定义一个类
class Student{
    public void show(){
        System.out.println("好好学习,天天向上...");
    }
}

//class StudentDemo{
//  public void method(Student s){//形式参数是一个引用类型,那么需要该类对象Student s = new Student() ;
//      s.show() ;
//  }
//}

class StudentDemo{
    public Student method(){//如果方法的返回值是一个具体的类,那么需要该类对象
        /*Student s = new Student() ;
        return s ;*/

        return new Student() ;
    }
}
//测试类
public class StudentTest {
    public static void main(String[] args) {
        //两个实际参数
        /*int a = 10 ;
        int b = 20 ;*/

        float a = 10.0F;
        float b = 12.34F;
        //需求:需要调用sum来进行求和
        Demo d = new Demo() ;
        float result = d.sum(a, b) ;
        System.out.println("result:"+result);
        System.out.println("------------------------");

        //需求:需要调用StudentDemo这个类中method()方法
        //需要创建StudentDemo这个类的对象
//      StudentDemo sd = new StudentDemo() ;
//      //创建Student类的对象
//      Student s = new Student() ;
        sd.method(s) ;//当前s变量不可用
//      sd.method(s) ;//s就代表Student类的对象,把空间地址值作为参数传递

        //返回值是具体的类:
        //创建StudentDemo类对象
        StudentDemo sd = new StudentDemo() ;
        Student s = sd.method() ;
        s.show();
    }
}

package org.westos_形式参数和返回值问题研究;
/*如果形式参数是引用类型:
    具体类类:如果形式参数是一个具体类,那么需要创建该类对象
    抽象类:如果形式参数是抽象类的情况,那么需要自定义一个抽象类的子类,来进行实例化(创建对象)!,创建对象的实质:抽象类多态!
*   接口:如果形式参数是接口情况,那么需要自定义一个接口的子实现类,然后通过接口多态的形式给接口进行实例化!
**/
//定义一个接口
interface Inter{
    public abstract void love() ;
}

//定义一个类
class TeacherDemo{
    public void method(Inter i){//接口不能实例化:  如果一个方法的形式参数是一个接口,那么需要创建该接口的子实现类对象
        i.love() ;
    }
}

//由于接口不能实例化,需要定义接口的子实现类
class Student3 implements Inter{

    @Override
    public void love() {
        System.out.println("学生爱学习,爱java...");
    }

}
//测试类
public class TeacherTest {
    public static void main(String[] args) {
        //需求:需要调用TeacherDemo类中的method()方法
        //创建该类对象
        TeacherDemo td = new TeacherDemo() ;
        //创建该接口对象:通过接口多态
        Inter i = new Student3() ; //接口多态
    /*  Inter i = new Inter() { //匿名内部类 

            @Override
            public void love() {
                System.out.println("学生爱学习,爱java...");
            }
        };*/

        td.method(i) ;
    }
}