day13 Java 形参返回类型 链式编程 包

• 一、返回类型
• • 1、普通类
  • • 1.1 作为形参
    • 1.2 作为返回值
  • 2、抽象类
  • • 2.1 作为形参
    • 2.2 作为返回值
  • 3、接口
  • • 2.1 作为形参
    • 2.2 作为返回值
• 2、链式编程
• 3、包
• 总结

当普通类作为形式参数或返回值，需要的是该类的实例对象

//普通类
class Student1{
    public void study(){
        System.out.println("fgh");
    }
}

//普通类，方法将普通类作为形参
class StudentDemo1{
    //方法的参数是一个类当作数据类型传参的时候
    //实际上传的是该类的实例对象的地址值
    public void fun(Student1 test){
        test.study();
    }
}

public class StudentTest1 {
    public static void main(String[] args) {
        
        StudentDemo1 address1 = new StudentDemo1();
        Student1 address2 = new Student1();

        address1.fun(address2);
    }
}

class Student2{
    public void study(){
        System.out.println("好好学习，天天向上！");
    }
}

//将普通类作为返回值类型
class StduentDemo2{
    public Student2 getStudent(){
        //Student4 student4 = new Student4();
        //return student4;
        
        //用匿名对象改进
        return new Student2();
    }
}

public class StudentTest2 {
    public static void main(String[] args) {
        StduentDemo2 address1 = new StduentDemo2();
        //利用方法返回的类，创建一个新类
        Student2 address2 = address1.getStudent();
        address2.study();
    }
}

当抽象类作为形式参数或返回值，需要的是该抽象类的子类对象

//抽象类
abstract class Person1{
    public abstract void study();
}

//方法将抽象类对象作为形参
class PersonDemo{
    //一个方法的参数是抽象类作为数据类型参数传进来的时候
    //实际上需要的是该抽象类的子类对象的地址值
    public void fun(Person1 test){
        test.study();
    }
}

//抽象类子类
class Student3 extends Person1{
    @Override
    public void study() {
        System.out.println("fgh");
    }
}

public class PersonTest1 {
    public static void main(String[] args) {
        //普通类对象
        PersonDemo address1 = new PersonDemo();
        //抽象类子类对象
        Person1 address2 = new Student3();
        //将子类对象作为形参，实现普通类方法
        address1.fun(address2);
    }
}

//抽象类
abstract class Person2{
    public abstract void study();
}

//普通类，方法将抽象类作为返回值类型
class PersonDemo2{
    public Person2 fun(){
//        Person5 p = new Programmer();
//        return p;

        //匿名对象改进
        return new Programmer();
    }
}

//抽象类子类
class Programmer extends Person2{
    @Override
    public void study() {
        System.out.println("程序员学习技术");
    }
}

public class PersonTest2 {
    public static void main(String[] args) {
        //普通类对象
        PersonDemo2 address1 = new PersonDemo2();

        //Person2 p = new Programmer();
        //利用普通类的方法返回值，创建一个抽象类子类对象
        Person2 p = address1.fun();

        p.study();
    }
}

当接口作为形式参数或返回值，需要的是该接口具体的实现类的对象

//接口
interface Teacher1{
    public abstract void study();
}

//普通类，方法将接口作为形参
class TeacherDemo{
    public void fun(Teacher1 test){
        test.study();
    }
}

//接口实现类
class Teacher4 implements Teacher1{
    @Override
    public void study() {
        System.out.println("fgh");
    }
}

public class TeacherTest1 {
    public static void main(String[] args) {
        
        TeacherDemo teacherDemo = new TeacherDemo();
        Teacher1 p = new Teacher4();

        teacherDemo.fun(p);
    }
}

//接口
interface PlayGame{
    public abstract void playLol();
}

//普通类，方法将接口作为返回值类型
class PlayGameDemo{
    public PlayGame fun(){
        //PlayGame pg = new Teacher2();
        //return pg;
        
        //返回匿名对象
        return new Teacher2();
    }
}

//接口实现类
class Teacher2 implements PlayGame{
    @Override
    public void playLol() {
        System.out.println("打英雄联盟");
    }
}


public class TeacherTest2 {
    public static void main(String[] args) {
        
        PlayGameDemo address = new PlayGameDemo();
        //利用普通类方法的返回值，创建一个接口实现类对象
        PlayGame pg = address.fun();
        
        pg.playLol();
    }
}

1、对象1.对象2.对象3…方法()
2、对象1.方法1().方法2()…方法n()

interface PlayGame2{
    public abstract void playLol();
}

class PlayGameDemo2{
    //方法返回接口类型
    public PlayGame2 fun(){
        PlayGame2 pg2 = new Student4();
        return pg2;
    }
}

class Student4 implements PlayGame2{
    @Override
    public void playLol() {
        System.out.println("打英雄联盟");
    }
}

public class ChainTest {
    public static void main(String[] args) {

        PlayGameDemo2 address1 = new PlayGameDemo2();
        PlayGame2 pg2 = address1.fun();
        pg2.playLol();


        System.out.println("==========用链式编程改进===========");

        //每次调用完毕方法之后，返回的是一个对象
        //因为对象才能去调用方法
        address1.fun().playLol();
    }
}

package 包名;
多级包用 . 分开即可
表示当前代码文件的相对目录

相对路径：com.shujia.java.day13.BaoDemo
绝对路径：D:IdeaProjectsbigdata13srccomshujiajavaday13BaoDemo.java
注意事项：
package语句必须是程序的第一条可执行的代码
package语句在一个java文件中只能有一个
如果没有package，默认表示无包名

package，import，class
package 在Java文件的第一行，在import和class之前出现

import 在package之后，在class出现之前

class是最后出现的，也就是我们所写的程序代码

当普通类作为形式参数或返回值，需要的是该类的实例对象

当抽象类作为形式参数或返回值，需要的是该抽象类的子类对象

当接口作为形式参数或返回值，需要的是该接口具体的实现类的对象