java学习笔记(六)----对象的类型转换, 匿名内置类

对象的类型转换
－－  子类对象可以自动转换成父类
－－  父类转换成子类必须使用强制转换
－－  instanceof操作符可以用它来判一个实例对象是否属于一个类。

class A
{ public void func1()
  {  System.out.println("A func1 is calling") }
  public void func2()
   { func1(); }
}

class B extens A
{ public void func1()
  { System.out.println("B func1 is calling");}
  public void func3()
  { System.out.println("B func3 is calling");}
}
class C
{   public static void main(String[] args)
   { B.b=new B();
     callA(b);  //编译器可以自动将子类转换为父类
     A.a=b;   //可以使父类对象等于子类对象
     callA(new B());// 编译器可以自动将子类转换为父类
   }
   public static void callA(A a) //子类对象可以自动转换成父类
   { a.func1();
     a.func2();
     a.func3(); //如果加这个方法的话，编译就出错了，因为传进来的虽然是类B，但接收数据的是类A，类A中不包含func3的方法
                //如果将以上callA(A a)中的代码改为B b=a; b.func1(); b.func2(); b.func3(),这样的话就出错了，因为，这样的话编译就认为是把A类对象给了B类对象，但是A类中没有func3的方法，所以编译出错了。但可以把 B b=a; 改为B b=(B)a; 用强制类型转换，这样就没错了，
在这个基础上，  B b=(B)a;
             b.func1();
             b.func2();
             b.func3();
            如果把main函数中的callA(new B())改为callA(new A())结果就错了，但在编译时没错，是在运行时错的，因为编译时，B b=(B)a;欺骗了编译器，没有语法错误，而在A类中没有func3()，所以是在运行时错了。    
   
    为了解决上面的所有问题，可以将这个方法中的所有代码，改为以下的代码：
        if(a instanceof B)   //如果对象a确实是一个类B的对象，就执行下面的语句
          ｛ B b=(B)a;       //instanceof 判断一个对象是否是某一个类的实例
             b.func1();
             b.func2();
             b.func3();
           ｝
        else
         {a.func1();  //否则就不进行转换
          a.func2();
         }
                            
     }

 

equals方法，

class Student
{ private String name;
  private int age;
  public Student(String name,int age)
  { this.name=name;
    this.age=age;
  }
  public boolean equals(object obj)  //如果不加这个方法，下面的Student对象即使里面的内容都一样输出的也是not equals, 因为它们不是相同的对象，但是加上这个方法后，就可以判断这两个对象中的内容是否相等。
  {  Student st=null;
     if (obj instanceof Student)
     {  st=(Student)obj;
        if (st.name=name && st.age=age)
          return true;
        else
          return false;
      }
      else
          return false;
  }
  public static void main(String[] args)
  { Student st1=new Student("zhangshan",20);
    Student st2=new Student("wangwu",20);
    if(st1.equals(st2))
        System.out.println("equals");
    else
        System.out.println("not equals");
  }
} 

 

接口的应用    匿名内置类
interface PCI
{ void start();
  void stop();
}
class NetWorkCard implements PCI
{ public void start()
  { System.out.println("Send...");}
  public void stop()
  { System.out.println("Stop...");}
}
class SoundCard implements PCI
{ public void start()
  { System.out.println("du..du");}
  public void stop()
  { System.out.println("sound stop"); }
}
class MainBoard
{ public void usePCIcard(PCI p)
  {  p.start();
     p.stop();
  }
}
class Bb
{ public static void main(String[] args)
  {  MainBoard mb=new MainBoard();
     NetWorkCard nc=new NetWorkCard();
     SoundCard sc=new SoundCard();
     mb.usePCIcard(nc);
     mb.usePCIcard(sc);
    
     mb.usePCIcard(new PCI())         //匿名内置类  （这里的new PIC()是建立一个PCI的子类对象）
        { public void start()
           { System.out.println("text start");}
          public void stop()
           { System.out.println("text stop");}
         });
    }
}
  以上的内置类可以写成下面型式
  class A implements PCI
  { public void start()
    { System.out.println("text start");}
    public void stop()
     { System.out.println("text stop");}
   }
   mb.usePCICard(new A());