参数传递

参数传递

类名

类名作为方法参数和返回值
类名作为方法参数: 调用方法时,传递的对象
类名作为方法返回值: 返回的是对象
本质: 类名作为方法参数和返回值,传递的是对象的地址值

如何使用:

1.创建该类对象

2.定义一个方法,参数列表为 类名 ,并在方法中完成对象的创建

3.调用该方法

范例;

//创建Cat 类
public class Cat {
    private String name;
​
    public void eat() {
        System.out.println(name+"...吃鱼...");
    }
​
    public Cat() {
    }
​
    public Cat(String name) {
        this.name = name;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
}
//创建测试类
public static void main(String[] args) {
       // 1.创建Cat类对象
        Cat c = new Cat("波斯"); //假设对象地址值为:0x111
​
        //3.调用方法  useCat
        useCat(c);      //useCat(0x111);
        
        
        //定义一个方法useCat,用于接收Cat对象
        //在方法中调用Cat对象方法的eat()方法
        //方法被调用时:Cat c =0x111 =new Cat("波斯")
        public static void useCat(Cat c){
        //调用Cat对象的eat方法
         c.eat();
​

抽象类

抽象类作为形参和返回值
​
抽象类作为形参: 调用方法时必然传递抽象类的子类对象
抽象类作为返回值: 调用方法时必然返回的是抽象类的子类对象
​
抽象类作为形参和返回值,本质上传递的是地址值

如何使用:

1.多态创建Animal的子类对象

2.定义一个方法,用来接收一个父类对象,并调用父类对象方法

3.调用方法

创建父类
public abstract class Animal {
    private String name;
​
    //抽象方法
    public abstract void eat();
​
    public Animal(String name) {
        this.name = name;
    }
​
    public Animal() {
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
}
​
创建子类
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
​
    public Dog() {
    }
​
    @Override
    public void eat() {
        System.out.println(getName()+"....吃骨头...");
    }
}
​
创建测试类
public static void main(String[] args) {
        //多态创建Animal的子类对象
        Animal dog = new Dog("二哈");//假设地址值:0x111
        
       //调用方法,获取Animal的对象
        //调用结束后: Animal a = 0x222 = new Dog("黑豹"); 多态
        Animal a = getAnimal();
        //调用成员方法
        a.eat();  
        
        
        //定义一个方法useAnimal，用来接收一个Animal对象，在方法中调用Animal对象的eat方法
    //方法被调用时: Animal a = 0x111 = new Dog("二哈");  多态
    public static void useAnimal(Animal a) {
        //在方法中调用Animal对象的eat方法
        a.eat();
    

接口

接口名作为形参和返回值
接口名作为形参: 调用方法时,传递的是接口的实现类对象
接口名作为返回值: 调用方法时,返回的是接口的实现类对象
​
接口名作为形参和返回值: 本质传递的是地址值

如何使用:

1.多态创建子类对象

2.定义方法,用于接收(接口)类型对象,

在方法中调用接口对象的方法

注:方法参数为 接口

3.调用方法传递方法中的参数

范例:

//创建一个接口
/*
    定义接口
 */
public interface TiaoGao {
    public abstract void jump();
}
​
//测试类
public static void main(String[] args) {
        //多态的形式创建对象
        TiaoGao tg = new Pig();//假设: 地址值0x111
        //调用方法,传递接口的实现类对象
        //方法被调用时:useTiaoGao(0x111);
        useTiaoGao(tg);
        System.out.println("------------");
​
        //调用方法,获取对象
        //方法被调用后: TiaoGao p = 0x222 = new Pig(); 多态
        TiaoGao p = getTiaoGao();
        p.jump();
    }
    //定义一个方法useTiaoGao，用来接收一个TiaoGao类型对象，
    // 在方法中调用TiaoGao类型对象的jump方法
    //方法被调用时:TiaoGao tg = 0x111 = new Pig(); 多态
    public static void useTiaoGao(TiaoGao tg) {
        tg.jump();
    }
​
    //定义一个方法getTiaoGao，用来获取一个具备跳高功能的对象，并在方法中完成TiaoGao对象的创建
    public static TiaoGao getTiaoGao() {
        Pig pg = new Pig();//假设地址值:0x222
        //return 0x222
        return pg;
    }