方法的参数传递和返回值

一、方法的参数如果是一个类，相当于传递了这个类的对象；

package Demo01;
//创建一个Person类，具有方法eat()
public class Person {
	public void eat() {
		System.out.println("恰饭");
	}
	
}
 

package Demo01;
//方法参数传递Person类，实则传递的是Person类型的对象 Person p = new Person();
public class Main {
	public void methodA(Person p) {
		p.eat();
	}
	public static void main(String[] args) {
		Main main = new Main();
		main.methodA(new Person());//----> Person p = new Person();
	}
} 

二、方法的参数如果是一个抽象类，相当于传递这个抽象类的子类；

package Demo02;
//创建一个动物的抽象类，具有抽象方法eat();
public abstract class Animal {
	public abstract void eat();
}

package Demo02;
/*
 * 创建一个Dog类继承抽象父类Animal。重写抽象方法eat；
 * 子类方法methodA()参数为抽象类，根据输出结果知道，实际传递的是抽象父类的子类Dog对象
 */
public class Dog extends Animal {
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("恰屎");
	}
	public void methodA(Animal an) {
		an.eat();
	}
	public static void main(String[] args) {
		Dog d = new Dog();
		d.eat();
	}
}

三、方法的参数如果是一个接口，相当于传递接口的实现类对象；

package Demo03;
//定义一个接口Fly，具有fly的抽象方法
public interface Fly {
	public abstract void fly();
}

package Demo03;
//定义Bird类实现Fly接口，重写接口中的抽象方法
public class Bird implements Fly {
	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println("我是用翅膀在飞");
	}
}

package Demo03;
//定义AirPlane类实现Fly接口，重写接口中的抽象方法
public class AirPlane implements Fly{
	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println("我是用燃油在飞");
	}
}

package Demo03;

public class Main {
	public void methodA(Fly f) {//方法参数中传递的是接口类型，看下面的输出结果，就相当于传递的是接口的实现类对象
		f.fly();
	}
	public static void main(String[] args) {	
		Main main = new Main();
		main.methodA(new AirPlane());//---->AirPlane ap = new AirPlane();
		main.methodA(new Bird());//---->Bird b = new Bird();	
	}
}

输出结果：
我是用燃油在飞
我是用翅膀在飞

----内部类
package Demo03;
//定义一个接口Fly，具有fly的抽象方法
public interface Flying {
	public abstract void fly();
}
package Demo03;
//定义Bird类实现Fly接口，重写接口中的抽象方法
public class Bird implements Flying {
	@Override
	public void fly() {

	}
}
package Demo03;
//定义AirPlane类实现Fly接口，重写接口中的抽象方法
public class AirPlane implements Flying{
	@Override
	public void fly() {

	}
}
package Demo03;

public class Main {
	public static void methodA(Flying f) {//方法参数中传递的是接口类型，看下面的输出结果，就相当于传递的是接口的实现类对象
		f.fly();
	}
	public static void main(String[] args) {
		Main main = new Main();
		methodA(new Bird() {	
			@Override
			public void fly() {
				// TODO Auto-generated method stub
				System.out.println( "我是用翅膀在飞");
			}
		});
		methodA(new AirPlane() {
			@Override
			public void fly() {
				// TODO Auto-generated method stub
				System.out.println( "我是用燃油在飞");
			}
		});
	}
}

输出结果：
我是用燃油在飞
我是用翅膀在飞

---匿名内部类
package Demo03;

public class NiMin {
	public static void methodA(Flying f) {
		f.fly();
	}
	public static void main(String[] args) {
		methodA(new Flying() {
			@Override
			public void fly() {
				// TODO Auto-generated method stub
				System.out.println("匿名内部类" + "  " + "我是用翅膀在飞");
			}
		});
		methodA(new Flying() {
			
			@Override
			public void fly() {
				// TODO Auto-generated method stub
				System.out.println("匿名内部类" + "  " + "我是用燃油在飞");
			}
		});
		
	}
}
下一步可以进行lambda表达式了

一、方法的返回值是一个类时，相当于返回一个该类的对象

package Demo04;

public  class Person {
	public void eat() {
		System.out.println("就一普通方法eat");
	}
}

package Demo04;

public class Main {
	public static Person methodA() {
		Person p = new Person();
		return p;
	}
	public static void main(String[] args) {
		Person p = methodA(); //这个就相当于Person p = new Person();  只不过用方法返回了，也就是返回了Person类的对象
		p.eat();
	}
}

二、方法的返回值是一个抽象类时，相当于返回一个该类的子类对象

package Demo05;

public abstract class Animal {
	public static void eat() {
		System.out.println("吃东西");
	}
	public abstract void run();
}

package Demo05;

public class Dog extends Animal {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("我能吃屎");
	}

}

package Demo05;

public class Main {
	public static Animal methodA() {
		//Animal an = new Animal();----这里按照普通类的思想创造对象是错误的，因为是抽象类嘛。那么就去实现他的子类
		Animal an = new Dog();
		return an;
	}
	public static void main(String[] args) {
		Animal an = methodA();
		an.run();
	}
}
输出结果:
我能吃屎

三、方法的返回值是一个接口时，相当于返回一个该接口的实现类对象

package Demo06;

public interface Flying {
	public abstract void fly();
}

package Demo06;

public class Bird implements Flying {

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println("我靠翅膀飞");
	}
	
}

package Demo06;

public class Main {
	public static Flying methodA() {
		Flying ffB = new Bird();
		return ffB;
	}
	public static void main(String[] args) {
		Flying ff = methodA();//同理  调用methodA方法，返回的是实现了Flying接口的实现类对象
		ff.fly();
	}
}

执行结果：
我靠翅膀飞