一、方法的参数如果是一个类，相当于传递了这个类的对象；
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 {@Overridepublic void eat() {// TODO Auto-generated method stubSystem.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 {@Overridepublic void fly() {// TODO Auto-generated method stubSystem.out.println("我是用翅膀在飞");}
}package Demo03;
//定义AirPlane类实现Fly接口，重写接口中的抽象方法
public class AirPlane implements Fly{@Overridepublic void fly() {// TODO Auto-generated method stubSystem.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 {@Overridepublic void fly() {}
}
package Demo03;
//定义AirPlane类实现Fly接口，重写接口中的抽象方法
public class AirPlane implements Flying{@Overridepublic 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() { @Overridepublic void fly() {// TODO Auto-generated method stubSystem.out.println( "我是用翅膀在飞");}});methodA(new AirPlane() {@Overridepublic void fly() {// TODO Auto-generated method stubSystem.out.println( "我是用燃油在飞");}});}
}输出结果：
我是用燃油在飞
我是用翅膀在飞---匿名内部类
package Demo03;public class NiMin {public static void methodA(Flying f) {f.fly();}public static void main(String[] args) {methodA(new Flying() {@Overridepublic void fly() {// TODO Auto-generated method stubSystem.out.println("匿名内部类" + " " + "我是用翅膀在飞");}});methodA(new Flying() {@Overridepublic void fly() {// TODO Auto-generated method stubSystem.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 {@Overridepublic void run() {// TODO Auto-generated method stubSystem.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 {@Overridepublic void fly() {// TODO Auto-generated method stubSystem.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();}
}执行结果：
我靠翅膀飞