JAVA面向对象之多态

在java中，为了实现多态，允许使用一个父类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果
定义接口Animal
interface Animal{
void shout();//定义抽象shout()方法
}
//定义Cat类实现Animal接口
class Cat implements Animal{
//实现shout()方法
public void shout(){
System.out.println("喵喵喵...");
}
}
//定义Dog 类实现Animal接口
class Dog implement Animal{
//实现shout()方法
public void shout(){
System.out.println("汪汪汪...");
}
}
//定义测试类
public static void main(String[] args){
Animal an1=new Cat();//创建Cat对象，使用Animal 类型的变量an1引用
Animal an2=new Cat();//创建Cat对象，使用Animal 类型的变量an2引用
animalShout(an1);//调用animalShout()方法，将an1作为参数传入
animalShout(an2)//调用animalShout()方法，将an2作为参数传入
}
//定义静态的animalShout()方法，接收一个Animal类型的参数
public static void animalShout(Animal an){
an.shout();//调用实际参数的shout()方法
}
多态的优点：不仅解决了方法同名的问题，而且还使程序变得更加灵活，从而有效提高了程序的可扩张性和可维护性

对象类型转换

子类对象当作父类类型使用的情况，此种情况在java的语言环境中称为"向上转型“
  如下：
  Animal an1=new Cat();//将Cat对象当作Animal类型来使用
  Animal an2=new Dog();//将Dog对象当作Animal类型来使用
  注意：此时不能通过父类变量去调用子类中的特有方法
  //定义Animal接口
  interface Animal{
  void shout();//定义抽象方法shout()
  }
  //定义Cat类实现Animal接口
  class Cat implements Animal{
  //实现抽象方法shout()
  public void shout(){
  System.out.println("喵喵...");
  }
  //定义sleep()方法
  void sleep(){
  System.out.println("猫睡觉...");
  }
  }
  //定义测试类
  public class Example14{
  public static void main(String[] args){
	Cat cat=new Cat();//创建Cat类的实例对象
	animalShout(cat);//调用animalShout()方法，将cat作为参数传入
  }
//定义静态方法animalShout(),接收一个Aniaml类型的参数
public static void animalShout(Animal animal){
animal.shout();//调用传入参数animal的shout()方法
animal.shout();//调用传入参数animal的sleep()方法
}
上面的代码会报错，报错原因时Animal类没有定义sleep()方法
修改animalShout()方法就可以
public static void animalShout(Animal animal){
Cat cat=(Cat) animal;//将animal对象强制转换为Cat类型
cat.shout();//调用cat的shout()方法
cat.sleep();//调用cat的sleep()方法
}
上面的这种将父类型当作子类型使用的情况在JAVA中称为”向下转型"
instanceof关键字，它可以判断一个对象是否为某个类(或接口)的实例或者子类实例
对象(或者对象引用变量) instanceof 类(接口)
如下：
public static void animalShout(Animal animal){
if(animal instanceof Cat){//判断animal是否是Cat类的实例对象
Cat cat=(Cat) animal;//将animal对象强制转换为Cat类型
cat.shout();//调用cat的shout()方法
cat.sleep();//调用cat的sleep()方法
}else{
System.out.println("the animal is not a cat")
}

}

Object类

Object类是类层次结构的根类，每个类都直接或间接继承该类
所有对象(包括数组)都实现了这个类的方法

getClass().getName()+"@"+Integer.toHexString(hashCode());
1.getClass().getName()代表返回对象所属类的类名，即Animal
hashCode()代表返回该对象的哈希值
Integer.toHexString(hashCode())代表将对象的哈希值用十六进制表示
其中,hashCode()是Object类中定义的一个方法，这个方法将对象的内存地址进行哈希运算，返回一个int类型的哈希值

匿名内部类

java中内部类可以分为成员内部类，方法内部类和匿名内部类
匿名内部类就是没有名字的内部类
//定义Animal接口
interface Animal{
void shout();//定义抽象方法shout()
}
//定义测试类
public class Example18{
public static void main(String[] args){
//定义一个内部类Cat实现Animal接口
class Cat implements Animal{
//实现shout()方法
public void shout(){
System.out.println("喵喵。。。");

}
}
animalShout(new Cat());//调用aniamlShou()方法并传入Cat对象
}
//定义静态方法animalShout()
public static void animalShout(Animal an){
an.shout();//调用传入对象an的shout()方法
}
匿名内部类的格式：
new 父类(参数列表)或父接口(){
//匿名内部类实现部分
}

//定义Animal接口
interface Animal{
void shout();//定义抽象方法shout()
}
//定义测试类
public class Example19{
public static void main(String[] args){
//定义匿名内部类作为参数传递给animalShout()方法
animalShout(new Animal(){
//实现shout()方法
public void shout(){
System.out.println("喵喵。。。");
}
});
}
//定义静态方法animalShout()
public static void animalShout(Animal an)
an.shout();//调用传入对象an的shout()方法
}
}
匿名内部类的格式：
animalShout(new Animal(){});
如下：
animalShout(new Animal(){
public void shout(){
	System.out.println("喵喵。。。");
}
});