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]+"  ");}}

class Person{public void show(){System.out.println("person的show方法");}
}class Man extends Person{public void function(){System.out.println("Man的function方法");}
}class PersonDemo{//提供一个方法，这个方法的参数是Personpublic 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);}}

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);}}

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);}}

 1 class Person{
 2     public void show(){
 3         System.out.println("perosn的show方法");
 4     }
 5 }
 6
 7 class Student extends Person{
 8     public void function(){
 9         System.out.println("Student的function方法");
10     }
11 }
12
13 class PersonDemo{
14     //有一个方法，方法的返回值就是一个Person类型
15     public Person getPerson(){//Person p = new Person();
16         //返回值类型如果是一个类名：本质上需要的是这个类或者这个类的子类对象
17         //Person p = new Person();
18         Student s = new Student();//Person p = new Student();
19         return s;
20     }
21
22 }
23
24 public class ReturnDemo2 {
25     public static void main(String[] args) {
26         //调用PersonDemo这个类中的getPerson()方法
27         /*PersonDemo pd = new PersonDemo();
28         Person p = pd.getPerson();//Person p = new Person()
29         p.show();*/
30
31         PersonDemo pd = new PersonDemo();
32         Person p = pd.getPerson();//Person p = new Studnet();,多态
33         p.show();
34         //p.function();
35         Student s = (Student)p;
36         s.function();
37     }

 1 abstract class Animal{
 2     public abstract void eat();
 3 }
 4
 5 class Dog extends Animal{
 6     public void eat() {
 7         System.out.println("狗就是爱吃骨头");
 8     }
 9 }
10
11 class AnimalDemo{
12     //提供以一个方法，这个方法的返回值类型就是一个抽象类名
13     public Animal getAnimal(){//Animal a = new Dog();
14         //注意：返回值类型是一个抽象类名的话：本质上需要的是这个抽象类的子类对象
15         //Animal a = new Dog();
16         Dog a = new Dog();
17         return a;
18     }
19
20 }
21
22
23 public class ReturnDemo3 {
24     public static void main(String[] args) {
25         //在这里调用ANimalDemo中的getAnimal的方法
26         AnimalDemo ad = new AnimalDemo();
27         Animal a = ad.getAnimal();//Animal a = new Dog();
28         a.eat();
29     }
30
31 }

interface Person2{public abstract void eat();
}//创建一个类实现上面的接口
class Man implements Person2{@Overridepublic 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();}}