Java 学习 day08

01-面向对象(多态-概念)

 package myFirstCode;

 /*
 多态：可以理解为事务存在的多种体现形态。

 人：男人，女人

 动物：猫，狗

 猫 x = new 猫();

 动物 x = new 猫();

 1. 多态的体现
 2. 多态的前提
 3. 多态的好处
 4. 多态的应用

  */

 public class DuoTailDemo {

     public static void main(String[] args) {
         // TODO Auto-generated method stub

     }

 }

02-面向对象(多态-扩展性)

 package myFirstCode;

 /*
 多态：可以理解为事务存在的多种体现形态。

 人：男人，女人

 动物：猫，狗

 猫 x = new 猫();

 动物 x = new 猫();

 1. 多态的体现
     父类的引用指向了自己的子类对象。
     父类的引用也可以接收自己的子类对象。

 2. 多态的前提
     必须是类与类之间有关系。要么继承，要么实现。
     通常还有一个前提：存在覆盖。

 3. 多态的好处
     多态的出现大大的提高了程序的扩展性。

 4. 多态的弊端
     提高了扩展性，但是只能使用父类的引用访问父类中的成员。

 5. 多态的应用

  */

 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("看家");
     }
 }

 class Pig extends Animal
 {
     public void eat()
     {
         System.out.println("饲料");
     }
     public void gongDi()
     {
         System.out.println("拱地");
     }
 }

 public class DuoTailDemo {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         /*
         Cat c = new Cat();
         c.eat();
         Dog d = new Dog();
         d.eat();
         Cat c = new Cat();
         function(c);
         Dog d = new Dog();
         function(d);
          */    

 //        Animal c = new Cat();
 //        c.eat();

         function(new Cat());
         function(new Dog());
         function(new Pig());
     }
     public static void function(Animal a)//Animal a = new Cat();
     {
         a.eat();
     }
     /*
     public static void function(Cat c)
     {
         c.eat();
     }
     public static void function(Dog d)
     {
         d.eat();
     }
     */

 }

03-面向对象(多态-转型)

 package myFirstCode;

 /*
 多态：可以理解为事务存在的多种体现形态。

 人：男人，女人

 动物：猫，狗

 猫 x = new 猫();

 动物 x = new 猫();

 1. 多态的体现
     父类的引用指向了自己的子类对象。
     父类的引用也可以接收自己的子类对象。

 2. 多态的前提
     必须是类与类之间有关系。要么继承，要么实现。
     通常还有一个前提：存在覆盖。

 3. 多态的好处
     多态的出现大大的提高了程序的扩展性。

 4. 多态的弊端
     提高了扩展性，但是只能使用父类的引用访问父类中的成员。

 5. 多态的应用

  */

 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("看家");
     }
 }

 class Pig extends Animal
 {
     public void eat()
     {
         System.out.println("饲料");
     }
     public void gongDi()
     {
         System.out.println("拱地");
     }
 }

 public class DuoTailDemo2 {

     public static void main(String[] args) {
 //        Animal a = new Cat();//类型提升。向上转型、向下转型。
 //        a.eat();

         //如果想要调用猫的特有方法时，如何操作？
         //强制将父类的引用。转换成子类类型。向下转型。
 //        Cat c = (Cat)a;
 //        c.catchMouse();

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

         /*
         毕姥爷 x = new 毕老师();

         x.讲课();

         毕老师 y = (毕老师)x;
         y.看电影();
         //x.看电影(); 没有看电影的方法
         */
         function(new Dog());
         function(new Cat());
     }
     public static void function(Animal a)//Animal a = new Cat();
     {
         a.eat();
         /*
         if(a instanceof Animal)
         {
             System.out.println("haha")
         }
          */
         if(a instanceof Cat)
         {
             Cat c =  (Cat)a;
             c.catchMouse();
         }
         else if(a instanceof Dog)
         {
             Dog c =  (Dog)a;
             c.kanjia();
         }
     }

 }

04-面向对象(多态-示例)

 package myFirstCode;

 /*
 基础班学生：
     学习，睡觉。
 高级班学生：
     学习，睡觉。

 可以将这两类事务进行抽取。
  */

 abstract class Student5
 {
     public abstract void study();
     public void sleep()
     {
         System.out.println("躺着睡");
     }
 }

 class DoStudent
 {
     public void doSome(Student5 stu)
     {
         stu.study();
         stu.sleep();
     }
 }

 //-----以上是工具类

 class BaseStudent2 extends Student5
 {
     public void study()
     {
         System.out.println("base study");
     }
     public void sleep()
     {
         System.out.println("坐着睡");
     }
 }

 class AdvStudent2 extends Student5
 {
     public void study()
     {
         System.out.println("adv study");
     }
     public void sleep()
     {
         System.out.println("坐着睡");
     }
 }

 public class DuoTailDemo3 {

     public static void main(String[] args)
     {
         DoStudent ds = new DoStudent();
         ds.doSome(new BaseStudent2());
         ds.doSome(new AdvStudent2());

 //        BaseStudent2 bs = new BaseStudent2();
 //        bs.sleep();
 //        bs.study();
 //        AdvStudent2 as = new AdvStudent2();
 //        bs.sleep();
 //        bs.study();
     }
 }

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

 package myFirstCode;

 class Fu3
 {
     void method1()
     {
         System.out.println("fu method1");
     }
     void method2()
     {
         System.out.println("fu method2");
     }
 }
 class Zi3 extends Fu3
 {
     void method1()
     {
         System.out.println("zi method1");
     }
     void method3()
     {
         System.out.println("zi method3");
     }
 }

 public class DuoTaiDemo4 {

     public static void main(String[] args) {
         // TODO Auto-generated method stub

         Fu3 f = new Zi3();
         f.method1();
         f.method2();
 //        f.method3();
 /*
  * 在多态中成员函数的特点：
  * 在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
  * 在运行时期：参阅对象所属的类中是否有调用的方法。
  * 简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。
  *
  */

 //        Zi3 z = new Zi3();
 //        z.method1();
 //        z.method2();
 //        z.method3();

     }

 }

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

 package myFirstCode;

 import classOne.IfClause;

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

 interface PCI
 {
     public void open();
     public void close();
 }

 class MainBoard
 {
     public void run()
     {
         System.out.println("mainboard run");
     }
     public void usePCI(PCI p)//PCI p = new NetCard() //接口型引用指向自己的子类对象。
     {
         if (p!=null)
         {
             p.open();
             p.close();
         }
     }
 }

 class NetCard implements PCI
 {
     public void open()
     {
         System.out.println("netcard open");
     }
     public void close()
     {
         System.out.println("netcard close");
     }
 }
 class SoundCard implements PCI
 {
     public void open()
     {
         System.out.println("soundcard open");
     }
     public void close()
     {
         System.out.println("soundcard close");
     }
 }

 /*
 class MainBoard
 {
     public void run()
     {
         System.out.println("manboard run");
     }
     public void useNetCard(NetCard c)
     {
         c.open();
         c.close();
     }
 }

 class NetCard
 {
     public void open()
     {
         System.out.println("netcard open");
     }
     public void close()
     {
         System.out.println("netcard close");
     }
 }
 */

 public class DuoTaiDemo5 {

     public static void main(String[] args)
     {
         // TODO Auto-generated method stub
         MainBoard mb = new MainBoard();
         mb.run();
         mb.usePCI(null);
         mb.usePCI(new NetCard());
         mb.usePCI(new SoundCard());
     }

 }

07-面向对象(多态的扩展示例)

 package myFirstCode;
  /*
   * 需求：数据库的操作。
   *
   * 数据是：用户信息。
   * 1. 连接数据库。JDBC Hibernate
   * 2. 操作数据库。
   *     C create R read U update D delete
   * 3. 关闭数据库连接
   */

 interface UserInfoDao
 {
     public void add(User user);
     public void delete(User user);

 }

 class UserInfoByJDBC implements UserInfoDao
 {
     public void add(User user)
     {
         1. JDBC连接数据库
         2. 使用sql添加语句添加数据
         3. 关闭连接
     }
     public void delete(User user)
     {
         1. JDBC连接数据库
         2. 使用sql添加语句删除数据
         3. 关闭连接
     }
 }

 class UserInfoByHibernate implements UserInfoDao
 {
     public void add(User user)
     {
         1. Hibernate连接数据库
         2. 使用sql添加语句添加数据
         3. 关闭连接
     }
     public void delete(User user)
     {
         1. Hibernate连接数据库
         2. 使用sql添加语句删除数据
         3. 关闭连接
     }
 }

 public class DBOperate {
     public static void main(String[] args) {
         // TODO Auto-generated method stub
 //        UserInfoByJDBC ui = new UserInfoByJDBC();
 //        UserInfoByHibernate ui = new UserInfoByHibernate();

         UserInfoDao ui= new  UserInfoByJDBC();        //此处是多态
         ui.add(user);
         ui.delete(user);

     }

 }

08-面向对象(Object类-equals())

 package myFirstCode;

 /*
  * Object：是所有对象的直接或者间接父类，传说中的上帝。
  * 该类中定义的肯定是所有对象都具备的功能。
  * 任何对象都具备比较相同的功能（地址）
  *
  *
  * Object 类中已经提供了对对象是否相同的比较方法。
  *
  * 如果自定义类中也有比较相同的功能，没有必要重新定义。
  * 只要沿袭父类中的功能，建立自己特有的比较内容即可。这就是覆盖。
  */

 class Demo //extends object
 {
     private int num;
     Demo(int num)
     {
         this.num = num;
     }

     public boolean equals(Object obj)//Object obj = new Demo();
     {
         if (obj instanceof Demo)
             return false;
         Demo d = (Demo)obj;
         return this.num == d.num;

     }
     /*
     public boolean compare(Demo d)
     {
         return this.num == d.num;
     }
     */
 }

 public class ObjectDemo {

     public static void main(String[] args) {
         Demo d1 = new Demo(4);
         Demo d2 = new Demo(5);

         Demo d3  = d1;
         System.out.println(d1.equals(d2));
     }

 }

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