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())