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

形式参数问题
数据类型：
基本类型：byte,short,int,long,float,double,char,boolean
引用类型：类,接口,数组

形式参数：
基本类型：要的是该基本类型的数据值。
引用类型：要的是该引用类型的对象。
A:数组 要的是该数据类型数组的对象。(地址值)

public static void main(String[] args) {
        //在这里我们调用我们刚刚创建的数组遍历的方法
        //A:数组 要的是该数据类型数组的对象。(地址值)
        //创建一个数组
        int[] arr = {1,2,3};
        printArr(arr);
    }
    
    //A:数组 要的是该数据类型数组的对象。(地址值)
    //写一个方法是一个数组遍历的方法
    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
    }

 

B:类 要的是该类或者其子类的对象。(地址值)

class Person{
    public void show(){
        System.out.println("person的show方法");
    }
}

class Man extends Person{
    public void function(){
        System.out.println("Man的function方法");
    }
}

class PersonDemo{
    //提供一个方法，这个方法的参数是Person
    public void method(Person p){//Person p = new Person();
                                 //当传递子类对象的时候，Person p = new Man();,这个是以多态的方式进行传参
        p.show();//p.show();
    }
}

public class ArgsDemo2 {
    public static void main(String[] args) {
        //想要调用PersonDemo这个类中的method方法
        PersonDemo pd = new PersonDemo();
        //Person p = new Person();
        Man m = new Man();
        pd.method(m);
    }

}

 

C:抽象类 要的是该抽象类的子类对象。(地址值)

abstract class Animal{
    public abstract void eat();
}

//创建一个Animal类的子类
class Dog extends Animal{
    
    public void eat() {
        System.out.println("狗爱啃骨头");
    }
    
}

class AnimalDemo{
    public void method(Animal a){//Aanimal a = new Dog();多态的方式进行传参
        //注意：如果一个形式参数类型是一个抽象类的话，本质上要的是这个抽象类的子类对象
        a.eat();
    }
}


public class ArgsDemo3 {
    public static void main(String[] args) {
        //需要调用AnilaDemo这个类中的method这个方法
        AnimalDemo ad = new AnimalDemo();
        Animal a = new Dog();
        ad.method(a);
    }

}

 

D:接口 要的是该接口的实现类对象。(地址值)

interface Person2{
    public abstract void eat();
}

class Women implements Person2{
    
    public void eat() {
        System.out.println("民以食为天");
    }
}

class Person2Demo{
    public void method(Person2 p){//Perosn2 p = new Women();接口多态的方式进行传参
        //注意：如果一个方法的形式参数是一个接口类型的话，本质上需要的是这个接口的实现类对象，其实就是这个对象的地址值
        p.eat();
    }
}

public class ArgsDemo4 {
    public static void main(String[] args) {
        //调用Peros2Demo中的method方法
        Person2Demo pd = new Person2Demo();
        Person2 p = new Women();
        pd.method(p);
    }

}

 

返回值问题
返回值：
基本类型：byte,short,int,long,float,double,char,boolean
引用类型：类，接口，数组

返回值之基本类型：
基本类型：返回的是该基本类型的数据值。
案例：创建一个加法的方法，返回值就是基本类型的具体的指

返回值之引用类型：
返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)如下

class Person{
    public void show(){
        System.out.println("perosn的show方法");
    }
}

class Student extends Person{
    public void function(){
        System.out.println("Student的function方法");
    }
}

class PersonDemo{
    //有一个方法，方法的返回值就是一个Person类型
    public Person getPerson(){//Person p = new Person();
        //返回值类型如果是一个类名：本质上需要的是这个类或者这个类的子类对象
        //Person p = new Person();
        Student s = new Student();//Person p = new Student();
        return s;
    }
    
}

public class ReturnDemo2 {
    public static void main(String[] args) {
        //调用PersonDemo这个类中的getPerson()方法
        /*PersonDemo pd = new PersonDemo();
        Person p = pd.getPerson();//Person p = new Person()
        p.show();*/
        
        PersonDemo pd = new PersonDemo();
        Person p = pd.getPerson();//Person p = new Studnet();,多态
        p.show();
        //p.function();
        Student s = (Student)p;
        s.function();
    }

 

返回值是抽象类名：要的是该抽象类的子类对象。(地址值)如下

abstract class Animal{
    public abstract void eat();
}

class Dog extends Animal{
    public void eat() {
        System.out.println("狗就是爱吃骨头");
    }
}

class AnimalDemo{
    //提供以一个方法，这个方法的返回值类型就是一个抽象类名
    public Animal getAnimal(){//Animal a = new Dog();
        //注意：返回值类型是一个抽象类名的话：本质上需要的是这个抽象类的子类对象
        //Animal a = new Dog();
        Dog a = new Dog();
        return a;
    }
    
}


public class ReturnDemo3 {
    public static void main(String[] args) {
        //在这里调用ANimalDemo中的getAnimal的方法
        AnimalDemo ad = new AnimalDemo();
        Animal a = ad.getAnimal();//Animal a = new Dog();
        a.eat();
    }

}

 

返回值是接口名：要的是该接口的实现类对象。(地址值)如下

interface Person2{
    public abstract void eat();
}

//创建一个类实现上面的接口
class Man implements Person2{
    @Override
    public void eat() {
        System.out.println("我爱吃泡馍");
    }
}


class Person2Demo{
    //提供一个方法，该方法的返回值是一个接口类型
    //注意：如果一个方法的返回值是接口类型的话，本质上需要的是该接口的实现类对象
    public Person2 getPerson2(){//Person2 p = new Man();
        Person2 p = new Man();
        return p;
    }
}

public class ReturnDemo4 {
    public static void main(String[] args) {
        //调用Person2Demo中的getPersaon2()
        Person2Demo pd = new Person2Demo();
        Person2 p = pd.getPerson2();//Person2 p = new Man();,接口多态
        p.eat();
    }

}