return object请教

uneting

以前看到一个实际返回类型为申明类型子类的例子，自己写了一个却存在问题，各位看官请指教

import java.util.*;
public class Ins1 {
        public static void main(String args[]){
                Cab cab =new Cab();
                Object o=cab.action1();
                o.bark();
               
            
        }

}

class Vegetable{
            void grow(){
            System.out.println("a vegetable growing!");
        }
}

class Dog{
        void bark(){
        System.out.println("a barking dog!");
        }
}

class Cab{
                   Object action2(){
           Vegetable veg=new Vegetable();
           return veg;
          }
                    
          Object action1(){
                  Dog dog= new Dog();
                  return dog;
                  }
                    
}

perryhg

Object o=cab.action1();
这个时候o还是Object，不能运行o.bark()，一定要强制转换

Dog o = (Dog)cab.action1();
然后才能
o.bark();

pinecrane

斑竹厉害。嘿嘿
就像容器里的遍历方法：每一个对象都是Object的子类。但是取出来的时候这个Object 不一定就是某个具体的子类。编译器也无法做隐式转换。需要程序员的认为强制转换.

AndyFastow

or

Cab cab =new Cab();
Object o=cab.action1();
   ((Dog)o).bark();

uneting

谢谢各位，只是，
强制转换得时候是否用instanceof更安全一些呢？对什么时候用instanceof还是不够明了
最后祝福大家新年快乐。

perryhg

看看这段代码，再运行一下，再好好思考一下。

1. public class Ins1 {
   
2.         public static void main(String args[]) {
   
3.                 for(int i=0;i<10;i++)
   
4.                 {
   
5.                         runtest();
   
6.                 }
   
7.         }
   
8.        
   
9.         static void runtest()
   
10.         {
    
11.                 Cab cab = new Cab();
    
12.                 Object o = cab.action();
    
13.                 if( o instanceof Dog)
    
14.                 {
    
15.                         ((Dog)o).bark();
    
16.                 }
    
17.                 else
    
18.                 {
    
19.                         ((Vegetable)o).grow();
    
20.                 }
    
21.         }
    
22. }
    
23. 
    
24. class Vegetable {
    
25.         void grow() {
    
26.                 System.out.println("a vegetable growing!");
    
27.         }
    
28. }
    
29. 
    
30. class Dog {
    
31.         void bark() {
    
32.                 System.out.println("a barking dog!");
    
33.         }
    
34. }
    
35. 
    
36. class Cab {
    
37.        
    
38.         Object action() {
    
39.                 if(Math.random() > 0.5)
    
40.                 {
    
41.                         return new Dog();
    
42.                 }
    
43.                 else
    
44.                 {
    
45.                         return new Vegetable();
    
46.                 }
    
47.         }
    
48. }
    

复制代码

instanceof 是java比较原始的解决耦合的办法，现在有了新的方法，叫做依赖注入(Dependency Injection)现在很多Framework都使用了DI，最著名的就是SpringFramework。

[ 本帖最后由 perryhg 于 2006-1-27 16:56 编辑 ]

perryhg

再思考一下这段代码，和上一段有什么区别

1. 
   
2. public class Ins1 {
   
3.         public static void main(String args[]) {
   
4.                 for(int i=0;i<10;i++)
   
5.                 {
   
6.                         runtest1();
   
7.                 }
   
8.         }
   
9.        
   
10.         static void runtest1()
    
11.         {
    
12.                 Cab cab = new Cab();
    
13.                 Doable o = cab.action();
    
14.                 o.doit();
    
15.         }
    
16. }
    
17. 
    
18. interface Doable {
    
19.         public void doit();
    
20. }
    
21. 
    
22. class Vegetable implements Doable{
    
23.         void grow() {
    
24.                 System.out.println("a vegetable growing!");
    
25.         }
    
26. 
    
27.         public void doit() {
    
28.                 grow();
    
29.         }
    
30. }
    
31. 
    
32. class Dog implements Doable {
    
33.         void bark() {
    
34.                 System.out.println("a barking dog!");
    
35.         }
    
36. 
    
37.         public void doit() {
    
38.                 bark();
    
39.         }
    
40. }
    
41. 
    
42. class Cab {
    
43.        
    
44.         Doable action() {
    
45.                 if(Math.random() > 0.5)
    
46.                 {
    
47.                         return new Dog();
    
48.                 }
    
49.                 else
    
50.                 {
    
51.                         return new Vegetable();
    
52.                 }
    
53.         }
    
54. }
    

复制代码

通过Interface实现多态是java的一大亮点（尽管不是java独创），如果不用Interface，会发生什么情况呢？

我们假设：有服务器和客户机2台机器，如果现在只有Dog 和Vegetable两个类，那么可以这样
                if( o instanceof Dog)
                {
                        ((Dog)o).bark();
                }
                else
                {
                        ((Vegetable)o).grow();
                }
思考：如果要增加一个Cat类怎么办呢？
需要修改客户机和服务器两边的代码，两台机器都重新编译，然后才能运行。而且每次增加，服务器都要修改代码，这里就要不断得增加 if else... 尤其是服务器，修改代码，重编译以后还得停止程序重新运行，造成服务中断。如果你现在是服务器管理员，这个功能是给下面的销售代理用的，那么你下面如果发展了100个代理，每个代理都有自己独特的方法实现，那么你就等着加班改程序吧。

现在用了Interface，你只要把Interface文件下发给代理，只要客户端实现doit()，服务器就会自动识别并运行，服务器端无需修改代码，无需重编译，无需停机。你只要在服务器旁看着，喝喝茶就行了。

[ 本帖最后由 perryhg 于 2006-1-27 21:08 编辑 ]

uneting

新年好新年好 ，谢谢版主的细心回答，相信大家对DI也会有更深的了解。
但我一开始给出的例子中为什么
           Cab cab =new Cab();
                Object o=cab.action1();
                ((Dog)o).bark();

而不要用
if( o instanceof Dog)
     {
          ((Dog)o).bark();
      }

perryhg

1. 
   
2.            Object action2(){
   
3.            Vegetable veg=new Vegetable();
   
4.            return veg;
   
5.           }
   
6.                     
   
7.           Object action1(){
   
8.                   Dog dog= new Dog();
   
9.                   return dog;
   
10.           }
    

复制代码

你当然可以用instance of，程序不会报错的，可是既然你的程序已经确定action1()返回Dog，那么再用instance of不是有点多此一举？

艾斯尼勒

请问版主使用interface的代码是否就是DI？
经常这么使用interface可是头一次听说DI的

另外楼主在多态这方面概念有些混淆，基本上说当你的对象被赋予了一个父类的引用的时候，这里为Object，编译器认为这是一个父类对象，所以编译器不认为这个对象有你想调用子类有而父类没有的方法，所以楼主贴的代码会报错，这时如果想使用子类对象的方法，就需要强制转换了。当然通过实现一个接口来解决这个问题要更好，可能就是DI吧，有待回答。谢谢