方法的形式参数和方法的返回值类型

方法的形式参数和方法的返回值类型：匿名对象、方法的形式参数、方法的返回值类型

1、方法的形式参数类型

        （1）形参是基本类型（太简单，省略）

        （2）形参是引用类型——> 类：需要的是一个该类的对象

[java]  view plain  copy

1. /* 
2.     形式参数： 
3.         基本类型(太简单，不是我今天要讲解的) 
4.         引用类型 
5.             类名:(匿名对象的时候其实我们已经讲过了) 需要的是该类的对象 
6.             抽象类: 
7.             接口 
8. */  
9. class Student {  
10.     public void study() {  
11.         System.out.println("Good Good Study,Day Day Up");  
12.     }  
13. }  
14.   
15. class StudentDemo {  
16.     public void method(Student s) { //ss; ss = new Student();  Student s = new Student();  
17.         s.study();  
18.     }  
19. }  
20.   
21. class StudentTest {  
22.     public static void main(String[] args) {  
23.         //需求：我要测试Student类的study()方法  
24.         Student s = new Student();  
25.         s.study();  
26.         System.out.println("----------------");  
27.           
28.         //需求2：我要测试StudentDemo类中的method()方法  
29.         StudentDemo sd = new StudentDemo();  
30.         Student ss = new Student();  
31.         sd.method(ss);  
32.         System.out.println("----------------");  
33.           
34.         //匿名对象用法  
35.         new StudentDemo().method(new Student());  
36.     }  
37. }  

        （3）形参是引用类型——> 抽象类：需要的是一个该抽象类的子类的对象（这是多态呀）

[java]  view plain  copy

1. /* 
2.     形式参数： 
3.         基本类型(太简单，不是我今天要讲解的) 
4.         引用类型 
5.             类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象 
6.             抽象类:需要的是该抽象的类子类对象 
7.             接口 
8. */  
9. abstract class Person {  
10.     public abstract void study();  
11. }  
12.   
13. class PersonDemo {  
14.     public void method(Person p) {//p; p = new Student();  Person p = new Student();   //多态  
15.         p.study();  
16.     }  
17. }  
18.   
19. //定义一个具体的学生类来实现抽象类  
20. class Student extends Person {  
21.     public void study() {  
22.         System.out.println("Good Good Study,Day Day Up");  
23.     }  
24. }  
25.   
26. class PersonTest {  
27.     public static void main(String[] args) {  
28.         //目前是没有办法的使用的  
29.         //因为抽象类没有对应的具体类  
30.         //那么，我们就应该先定义一个具体类  
31.         //需求：我要使用PersonDemo类中的method()方法  
32.         PersonDemo pd = new PersonDemo();  
33.         Person p = new Student();  
34.         pd.method(p);  
35.     }  
36. }  

        （4）形参是引用类型——> 接口：需要的是一个该接口的实现类的对象（这也是多态呀）

[java]  view plain  copy

1. /* 
2.     形式参数： 
3.         基本类型(太简单，不是我今天要讲解的) 
4.         引用类型 
5.             类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象 
6.             抽象类:需要的是该抽象的类子类对象 
7.             接口:需要的是该接口的实现类对象 
8. */  
9. //定义一个爱好的接口  
10. interface Love {  
11.     public abstract void love();  
12. }  
13.   
14. class LoveDemo {  
15.     public void method(Love l) { //l; l = new Teacher();  Love l = new Teacher(); 多态  
16.         l.love();  
17.     }  
18. }  
19.   
20. //定义具体类实现接口  
21. class Teacher implements Love {  
22.     public void love() {  
23.         System.out.println("老师爱学生,爱Java,爱林青霞");  
24.     }  
25. }  
26.   
27. class TeacherTest {  
28.     public static void main(String[] args) {  
29.         //需求：我要测试LoveDemo类中的love()方法  
30.         LoveDemo ld = new LoveDemo();  
31.         Love l = new Teacher();  
32.         ld.method(l);  
33.     }  
34. }  

2、返回值类型

        （1）返回值是基本类型（太简单，省略）

        （2）返回值是引用类型——> 类：返回的是一个该类的对象

[java]  view plain  copy

1. /* 
2.     返回值类型 
3.         基本类型:(基本类型太简单，我不准备讲解) 
4.         引用类型： 
5.             类:返回的是该类的对象 
6.             抽象类: 
7.             接口: 
8. */  
9. class Student {  
10.     public void study() {  
11.         System.out.println("Good Good Study,Day Day Up");  
12.     }  
13. }  
14.   
15. class StudentDemo {  
16.     public Student getStudent() {  
17.         //Student s = new Student();  
18.         //Student ss = s;  
19.           
20.         //Student s = new Student();  
21.         //return s;  
22.         return new Student();  
23.     }  
24. }  
25.   
26. class StudentTest2 {  
27.     public static void main(String[] args) {  
28.         //需求：我要使用Student类中的study()方法  
29.         //但是，这一次我的要求是，不要直接创建Student的对象  
30.         //让你使用StudentDemo帮你创建对象  
31.         StudentDemo sd = new StudentDemo();  
32.         Student s = sd.getStudent(); //new Student(); Student s = new Student();  
33.         s.study();  
34.     }  
35. }  

        （3）返回值是引用类型——> 抽象类：返回的是一个该抽象类的子类的对象（这是多态呀）

[java]  view plain  copy

1. /* 
2.     返回值类型 
3.         基本类型:(基本类型太简单，我不准备讲解) 
4.         引用类型： 
5.             类:返回的是该类的对象 
6.             抽象类:返回的是该抽象类的子类对象 
7.             接口: 
8. */  
9. abstract class Person {  
10.     public abstract void study();  
11. }  
12.   
13. class PersonDemo {  
14.     public Person getPerson() {  
15.         //Person p = new Student();  
16.         //return p;  
17.           
18.         return new Student();  
19.     }  
20. }  
21.   
22. class Student extends Person {  
23.     public void study() {  
24.         System.out.println("Good Good Study,Day Day Up");  
25.     }  
26. }  
27.   
28. class PersonTest2 {  
29.     public static void main(String[] args) {  
30.         //需求：我要测试Person类中的study()方法  
31.         PersonDemo pd = new PersonDemo();  
32.         Person p = pd.getPerson(); //new Student();  Person p = new Student(); 多态  
33.         p.study();  
34.     }  
35. }  

        （4）返回值是引用类型——> 接口：返回的是一个该接口的实现类的对象（这也是多态呀）

[java]  view plain  copy

1. /* 
2.     返回值类型 
3.         基本类型:(基本类型太简单，我不准备讲解) 
4.         引用类型： 
5.             类:返回的是该类的对象 
6.             抽象类:返回的是该抽象类的子类对象 
7.             接口:返回的是该接口的实现类的对象 
8. */  
9. //定义一个爱好的接口  
10. interface Love {  
11.     public abstract void love();  
12. }  
13.   
14. class LoveDemo {  
15.     public Love getLove() {  
16.         //Love l = new Teacher();  
17.         //return l;  
18.           
19.         return new Teacher();  
20.     }  
21. }  
22.   
23. //定义具体类实现接口  
24. class Teacher implements Love {  
25.     public void love() {  
26.         System.out.println("老师爱学生,爱Java,爱林青霞");  
27.     }  
28. }  
29.   
30. class TeacherTest2 {  
31.     public static void main(String[] args) {  
32.         //如何测试呢?  
33.         LoveDemo ld = new LoveDemo();  
34.         Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态  
35.         l.love();  
36.     }  
37. }  

3、链式编程：每次调用完毕后，返回的是一个对象。

[java]  view plain  copy

1. /* 
2.     链式编程。 
3.         每次调用完毕方法后，返回的是一个对象。 
4. */  
5. class Student {  
6.     public void study() {  
7.         System.out.println("Good Good Study,Day Day Up");  
8.     }  
9. }  
10.   
11. class StudentDemo {  
12.     public Student getStudent() {  
13.         return new Student();  
14.     }  
15. }  
16.   
17. class StudentTest3 {  
18.     public static void main(String[] args) {  
19.         //如何调用的呢?  
20.         StudentDemo sd = new StudentDemo();  
21.         //Student s = sd.getStudent();  
22.         //s.study();  
23.           
24.         //大家注意了  
25.         sd.getStudent().study();  
26.     }  
27. }