面向对象六

1、多态
多态定义：可以理解为事物存在的多种体现形态。
第一、多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
第二、多态的前提
必须是类与类之间有关系。要么继承、要么实现。
通常还有一个前提：存在覆盖。
第三、多态的好处
提高了程序的扩展性。
第四、多态的弊端
只能使用父类的引用访问父类中的成员。
第五、多态的应用
将多态封装到一个工具类中

abstract class Animal{
 abstract void eat(); 
}
class Cat extends Animal{
 public void eat(){
  System.out.println("吃鱼"); 
 } 
 public void catchMouse(){
  System.out.println("抓老鼠"); 
 }
}
class Dog extends Animal{
 public void eat(){
  System.out.println("吃骨头"); 
 } 
}
public class DuotaiDemo1{
 public static  void main(String[] args){
   function(new Cat());
   function(new Dog());
 } 
 public static void function(Animal a){
  a.eat(); 
 }
}

2、多态---转型
向下转型：子类类型提升为父类。
向下转型：子类类型先提升为父类，然后再强制转换成自己类型。如果想要子类特有功能，可以强制将父类的引用转成子类类型。
千万不要将父类对象转成子类类型，我们能转换的是父类引用指向了自己子类对象时，该父类引用可以被提升为父类类型，也可以被强制转换成子类类型。
多态自始自终都是子类对象在做着变化。

abstract class Animal{
 abstract void eat(); 
}
class Cat extends Animal{
 public void eat(){
  System.out.println("吃鱼"); 
 } 
 public void catchMouse(){
  System.out.println("抓老鼠"); 
 }
}
class Dog extends Animal{
 public void eat(){
  System.out.println("吃骨头"); 
 } 
 public void kanJia(){
  System.out.println("看家"); 
 }
}
public class DuotaiDemo1{
 public static  void main(String[] args){
  //向上转型，子类提升为父类 
  Animal animal = new Cat();
  function(animal);
 } 
 public static void function(Animal animal){
  animal.eat(); 
  if(animal instanceof Cat){
   //向下转型，强制将父类的引用转成子类类型，用来调用子类特有的功能。
   Cat cat = (Cat) animal;
   cat.catchMouse(); 
  }else if(animal instanceof Dog){
   Dog dog = (Dog) animal;
   dog.kanJia();
  }
 }
}

3、多态的应用
将多态封装到一个工具类中.

abstract class Student{
 public abstract void study();
 public void sleep(){
  System.out.println("躺着睡"); 
 } 
}
class DoStudent{
  public void doSome(Student stu){
   stu.study();
   stu.sleep(); 
  }
}
class BaseStudent extends Student{
  public void study(){
   System.out.println("base study");
  }
  public void sleep(){
   System.out.println("坐着睡"); 
  }
}
public class DuotaiDemo2{
  public static void main(String[] args){
   DoStudent ds = new DoStudent();
   ds.doSome(new BaseStudent()); 
  }
}

4、多态的主板示例

interface PCI{
  public void open();
  public void close();   
}
class MainBoard{
 public void run(){
  System.out.println("mainboard run");
 }
 public void getPCI(PCI p){
   p.open();
   p.close();
 }
}
class ShengKa implements PCI{
  public void open(){
   System.out.println("声卡运行"); 
  }
  public void close(){
   System.out.println("声卡结束"); 
  }
}
public class DuotaiDemo3{
 public static void main(String[] args){
  MainBoard m = new MainBoard();
  m.run();
  m.getPCI(new ShengKa());
 }
}

5、Object类---equals()
Object:是所有对象的直接或者间接父类，传说中类的上帝。
该类中定义的是所有对象都具备的功能。

class Demo{
 private int num;
 Demo(int num){
  this.num = num;
 }
 public boolean equals(Object obj){
  if(!(obj instanceof Demo)){
   return false; 
  }
  Demo d = (Demo) obj;
  return this.num==d.num;
 }
}
class Person{
 
}
public class ObjectDemo01{
  public static void main(String[] args){
    Demo d1 = new Demo(4);
    Demo d2 = new Demo(4);
    Person p = new Person();
    System.out.println(d1.equals(p));
    System.out.println(d1.equals(d2));    
  }
}

 

总结：
1、多态：向上转型、向下转型。
2、Object:equals(Object obj)、toString().