黑马程序员_JAVA基础_多态-Object类

01面向对象(多态-概念)
定义：某一类事物的多种存在形态。
 例：动物中猫，狗。
 猫这个对象对应的类型是猫类型
  猫 x = new 猫();
 同时猫也是动物中的一种，也可以把猫成为动物
  动物 y = new 猫();
  动物是猫和狗具体事物中抽取出来的父类型。
  父类型引用指向了子类对象。

02面向对象(多态-扩展性)
1.多态的体现
  父类引用指向了自己的子类对象。
  父类的引用也可以接收自己的子类对象。

[java]  view plain copy

1.  Animal c = new Cat();  
2.  c.eat();  
3.   
4.   
5. function(new Cat());  
6. function(new Dog());  
7. function(new pig());  
8.   
9. public static void function(Animal a)//Animal a = new Cat();  
10. {  
11.   a.eat();  
12. }  

2.多态的前提
  必须是类与类之间有关系，要么继承，要么实现。
  通常还有一个前提：存在覆盖。
3.多态的好处
  多态的出现大大的提高程序的扩展性。
4.多态的弊端
  提高了扩展性，但是只能使用父类的引用访问父类中的成员

03面向对象(多态-转型)
第二个问题：如何使用子类特有方法。

[java]  view plain copy

1. public static void main(String[] args)   
2.  {  
3.   Animal a = new Cat();//类型提升。 向上转型。把猫提升为了动物  
4.  byte b= 2; int x = b;     //  b会被提升为int类型。  
5.   
6.   a.eat();  
7.         }  

  如果想要调用猫的特有方法时，如何操作？

  强制将父类的引用，转成子类类型。 向下转型
   Cat c = (Cat)a;   强制转换
   c.catchMouse();

千万不要出现这样的操作，就是将父类对象转成子类类型。
我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
  多态自始至终都是子类对象在做着变化。
  Animal a = new Animal();
  Cat c = (Cat)a;
   毕姥爷 x = new 毕老师();

  x.讲课();

  毕老师 y = (毕老师)x;

  y.看电影();

[java]  view plain copy

1. public static void function(Animal a)//Animal a = new Cat();  
2.  {  
3.   a.eat();  
4.   /* 
5.   if(a instanceof Animal)   判断时不要把父类写在上面，否则下面的就不用判断了！ 
6.   { 
7.    System.out.println("haha"); 
8.   } 
9.   else  
10.   */  
11.   if(a instanceof Cat)  
12.   {  
13.    Cat c = (Cat)a;  
14.    c.catchMouse();  
15.   }  
16.   else if(a instanceof Dog)  
17.   {  
18.    Dog c = (Dog)a;  
19.    c.kanJia();  
20.   }  
21.   
22.   
23.   /* 
24.   instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)   
25.   */  
26.    
27.  }  

 

因为在后期如果再有其他子类类型出现(pig)，还要在后面加else if语句进行判断，所以一般情况下不用
什么时候用instanceof：
  子类类型是有限的， 人  要么男人要么女人
  当你传的类型需要进行其他操作，比如说比较，必须得确定它到底是哪种子类型，我要调用它的特有方法来比较，这个时候会用instanceof来判断
  instanceof 用来判断所属类型  判断完后就可以用这个所属类型中的特有方法

04面向对象(多态-示例)
/*
基础班学生：
 学习，睡觉。
高级班学生：
 学习，睡觉。

可以将这两类事物进行抽取。

*/

[java]  view plain copy

1. abstract class Student  
2. {  
3.  public abstract void study();  
4.  public void sleep()  
5.  {  
6.   System.out.println("躺着睡");  
7.  }  
8. }  
9.   
10. class DoStudent  
11. {  
12.    
13.  public void doSome(Student stu)  
14.  {  
15.   stu.study();  
16.   stu.sleep();  
17.  }  
18.    
19. }  
20.   
21. class BaseStudent extends Student  
22. {  
23.  public void study()  
24.  {  
25.   System.out.println("base study");  
26.  }  
27.  public void sleep()  // 将父类中的躺着睡覆写  
28.  {  
29.    System.out.println("坐着睡");  
30.  }  
31. }  
32.   
33. class AdvStudent extends Student  
34. {  
35.  public void study()  
36.  {  
37.   System.out.println(" adv study");  
38.  }  
39. }  
40.   
41.    
42.   
43.   
44. class  DuoTaiDemo3  
45. {  
46.  public static void main(String[] args)   
47.  {  
48.   
49.   DoStudent ds = new DoStudent();  
50.   ds.doSome(new BaseStudent());  
51.   ds.doSome(new AdvStudent());  
52.   
53.     
54. //  BaseStudent bs = new BaseStudent();  //把这些功能进行封装进DoStudent类中  
55. //  bs.study();  
56. //  bs.sleep();  
57. //  AdvStudent as = new AdvStudent();  
58. //  as.study();  
59. //  as.sleep();  
60.  }  

 

多态将对象调用这件事情变简单了，以前是指挥每一个对象做事情，现在是可以指挥一批对象做事情，是因为找到了这些对象的共同所属类型，只要将事物不断的向上抽象，总能找到共同点，找到后就可以统一操作很多对象了。

05面向对象(多态中成员的特点)

[java]  view plain copy

1. class Fu  
2. {  
3.  static int num = 5;  
4.  void method1()  
5.  {  
6.   System.out.println("fu method_1");  
7.  }  
8.  void method2()  
9.  {  
10.   System.out.println("fu method_2");  
11.  }  
12.  static void method4()  
13.  {  
14.   System.out.println("fu method_4");  
15.  }  
16. }  
17.   
18.   
19. class Zi extends Fu  
20. {  
21.  static int num = 8;  
22.  void method1()  
23.  {  
24.   System.out.println("zi method_1");  
25.  }  
26.  void method3()  
27.  {  
28.   System.out.println("zi method_3");  
29.  }  
30.   
31.  static void method4()  
32.  {  
33.   System.out.println("zi method_4");  
34.  }  
35. }  

class  DuoTaiDemo4
{
 public static void main(String[] args) //对上面的代码进行调用
 {
  
//  Fu f = new Zi();
//
//  System.out.println(f.num);  面试   在多态中，成员变量的特点：
                       无论编译和运行，都参考左边(引用型变量所属的类)。
//
//  Zi z = new Zi();
//  System.out.println(z.num);
    结果为  5  8   第二个是子类的    第一个是父类引用指向子类对象为什么 还是运行父类呢
在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。

  
  //f.method1(); 为什么执行子。因为method1()方法存储在方法区的非静态区，在非静态区中有俩个引用：this  super，而静态区中只有类名引用：fu  zi    this.method1()
  当我们调用method1()时，f确实是指向对象，method1()被运行的时候，最终是被对象运行，对象在调用非静态方法时，访问的是对象中的数据，而静态方法它本身不访问对象特有数据，所以都可以只用类名调用，只看这个f引用型变量所属类中的成员：它找的是静态区中的方法，不参考右边的对象，
  //f.method2();
  //f.method3();

  Fu f = new Zi();
  System.out.println(f.num);
  f.method4();

在多态中，静态成员函数的特点：
无论编译和运行，都参考左边

static                  非静态

fu.method4()          f.method1()
静态绑定               动态绑定   对象是谁就运行谁的   若写成Fu f = new Fu();  就会去找fu类中的method1

  当method4()方法一进内存，因为是静态方法，它就已经被绑定了，绑定在方法所属类当中，在调用时就已经存在fu.method4()

  Zi z = new Zi();
  z.method4();

 
  
/*
在多态中（父类有指向对象的时候）成员函数的特点： 非静态   有重写特性(运行时看子类)
在编译时期：参阅引用型变量所属的类中(fu类中)是否有调用的方法。如果有f.method1();，编译通过，如果没有编译失败。f.method3();
子类自己有，执行自己的，没有就执行父类，只有父类没有才会编译失败。
局部有变量，就访问局部的，没有就找成员变量；成员也没有，找父类，父类也没有，编译肯定失败。

在运行时期：参阅对象所属的类中(zi类中)是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

下面的几乎都是面试时才用到
在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：   静态只参考引用所属
无论编译和运行，都参考做左边。
父类引用指向子类对象对于静态方法对象调用时是不一样的：父类走父类，子类走子类
*/

//  Zi z = new Zi();
//  z.method1();
//  z.method2();
//  z.method3();
 }  打印结果   
                    zi method_1 因为  zi_1将fu_1覆盖掉了
                    fu method_2 因为 子类继承过来了
                    zi method_3 因为子类特有
                

[java]  view plain copy

1. }   
2.   
3.   Fu f = new Zi();  
4.     
5.   f.method1();  
6.   f.method2();               
7.   f.method3();   //method3(); 找不到  因为父类中没有这个方法  编译的时候对象还没有产生(new Zi)  所以说编译时只看那个f所属类型中有没有f.method3()，  
8.                 //如果有就编译通过，如果没有就编译失败编译失败  
9.   
10.   
11. Fu f = new Zi();  
12.     
13.   f.method1();  
14.   f.method2();   
15. // 这样结果是 zi_1   fu_2   

 

06面向对象(多态的主板示例)

/*
需求：
电脑运行实例，
电脑运行基于主板。
*/

 

[java]  view plain copy

1. interface PCI  
2. {  
3.  public void open();  
4.  public void close();  
5. }  
6.   
7. class MainBoard  
8. {  
9.  public void run()  
10.  {  
11.   System.out.println("mainboard run ");  
12.  }  
13.  public void usePCI(PCI p)//PCI p = new NetCard()    //接口型引用指向自己的子类对象。  
14.  {  
15.   if(p!=null)  
16.   {  
17.    p.open();  
18.    p.close();  
19.      
20.   }  
21.  }  
22. }  
23.   
24.   
25. class NetCard implements PCI  
26. {  
27.  public void open()  
28.  {  
29.   System.out.println("netcard open");  
30.  }  
31.  public void close()  
32.  {  
33.   System.out.println("netcard close");  
34.   method();  
35.  }  
36.    
37. }  
38. class SoundCard implements PCI  
39. {  
40.  public void open()  
41.  {  
42.   System.out.println("SoundCard open");  
43.  }  
44.  public void close()  
45.  {  
46.   System.out.println("SoundCard close");  
47.  }  
48. }  
49. /* 
50. class MainBoard 
51. { 
52.  public void run() 
53.  { 
54.   System.out.println("mainboard run"); 
55.  } 
56.  public void useNetCard(NetCard c) 
57.  { 
58.   c.open(); 
59.   c.close(); 
60.  } 
61. } 
62.  
63. class NetCard 
64. { 
65.  public void open() 
66.  { 
67.   System.out.println("netcard open"); 
68.  } 
69.  public void close() 
70.  { 
71.   System.out.println("netcard close"); 
72.  } 
73. } 
74. */  
75.   
76. class DuoTaiDemo5   
77. {  
78.  public static void main(String[] args)   
79.  {  
80.   MainBoard mb = new MainBoard();  
81.   mb.run();  
82.   mb.usePCI(null);  
83.   mb.usePCI(new NetCard());  
84.   mb.usePCI(new SoundCard());  
85.     
86.  }  
87. }  

 

接口的出现增加了功能扩展，
多态的应用提高了程序的扩展性(接口型引用)

接口降低了耦合性，提高功能扩展性，提供了规则

07面向对象(多态的扩展示例)
/*
需求：数据库的操作。
数据是：用户信息。
1，连接数据库。JDBC  Hibernate
2，操作数据库。
 c create r read  u update  d delete
3，关闭数据库连接。
*/

[java]  view plain copy

1. interface UserInfoDao  
2. {  
3.  public void add(User user);  
4.   
5.  public void delete(User user);  
6. }  
7.   
8. class UserInfoByJDBC implements UserInofDao  
9. {  
10.   
11.  public void add(User user)  
12.  {  
13.   1,JDBC连接数据库。;  
14.   2，使用sql添加语句添加数据。;  
15.   3，关闭连接。  
16.  }  
17.  public void delete(User user)  
18.  {  
19.   1,JDBC连接数据库。;  
20.   2，使用sql添加语句删除数据。;  
21.   3，关闭连接。  
22.  }  
23. }  
24.   
25. class UserInfoByHibernate implements UserInfoDao  
26. {  
27.  public void add(User user)  
28.  {  
29.   1,Hibernate连接数据库。;  
30.   2，使用sql添加语句添加数据。;  
31.   3，关闭连接。  
32.  }  
33.  public void delete(User user)  
34.  {  
35.   1,Hibernate连接数据库。;  
36.   2，使用sql添加语句删除数据。;  
37.   3，关闭连接。  
38.  }  
39. }  
40.   
41. class  DBOperate  
42. {  
43.  public static void main(String[] args)   
44.  {  
45.   //UserInfoByJDBC ui = new UserInfoByJDBC();  
46. //  UserInfoByHibernate ui = new UserInfoByHibernate();  
47.   UserInfoDao ui = new UserInfoByHibernate();  
48.   ui.add(user);  
49.   ui.delete(user);  
50.  }  
51. }  

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

 

Object类中已经提供了对对象是否相同的比较方法。

如果自定义类中也有比较相同的功能，没有必要重新定义。
只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。
*/

[java]  view plain copy

1. class Demo //extends Object  
2. {  
3.  private int num;  
4.  Demo(int num)  
5.  {  
6.   this.num = num;  
7.  }  
8.   
9.    
10.   
11. }  
12. class Person   
13. {  
14. }  
15.   
16. public boolean equals(Object obj)//Object obj = new Demo();  
17.  {  
18.   
19.   if(!(obj instanceof Demo))  //如果不是demo类型  
20.    return false;  
21.   Demo d = (Demo)obj;   //向下转型  
22.   
23.   return this.num == d.num;  
24.  }  
25.   
26. class ObjectDemo   
27. {  
28.  public static void main(String[] args)   
29.  {  
30.   Demo d1 = new Demo();  
31.     
32.   Demo d2 = new Demo();  
33.                 Demo d2 = d1;  
34.   System.out.println(d1.equals(d3));  
35.          System.out.println(d1==d2);  
36.                 System.out.println(d1==d3);   
37.   
38.   
39.  }  
40. }  

如果用到了对象中的特有数据   覆写时父类是object类型，要做判断和转换的动作，

09面向对象(Object类-toString())

 

 

[java]  view plain copy

1. class ObjectDemo   
2. {  
3.  public static void main(String[] args)   
4.  {  
5.   Demo d1 = new Demo(4);  
6. //一个对象的建立依赖与类文件，进内存时，类文件被封装成对象，类文件里既有构造函数，又有一般方法，还有一个成员变量。要想获取其中一样东西（将其封装成对象，在对象中定义很多功能，这样获取比较方便）。  
7.   System.out.println(d1);             //输出语句打印对象时，会自动调用对象的toString方法。打印对象的字符串表现形式。  
8.   Demo d2 = new Demo(7);  
9.   System.out.println(d2.toString());  
10.   //Demo d2 = new Demo(5);  
11.   //Class c = d1.getClass();  
12. //  
13. //  System.out.println(c.getName());  
14. //  System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));  
15. //  System.out.println(d1.toString());  
16.   //Person p = new Person();  
17.   ///System.out.println(d1.equals(p));  
18.   
19.  }  
20. }  
21. //一个对象有他自己对应的独特的字符串表现形式