继承2（接口、多态、object）

接口
接口：初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类
interface 用于定义接口。

接口定义时，格式特点：
1，接口中常见定义：常量，抽象方法。
2，接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。

接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。
否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

interface Inter
{
    public static final int NUM = 3;
    public abstract void show();
}

interface InterA
{
    public abstract void show();
}

class Demo
{
    public void function(){}
}

class Test extends Demo implements Inter,InterA
{
    public void show(){}
}


interface A
{
    void methodA();
}
interface B //extends A
{
    void methodB();
}

interface C extends B,A
{
    void methodC();
}

class D implements C
{
    public void methodA(){}
    public void methodC(){}
    public void methodB(){}
}


class InterfaceDemo 
{
    public static void main(String[] args) 
    {
        Test t = new Test();
        System.out.println(t.NUM);
        System.out.println(Test.NUM);
        System.out.println(Inter.NUM);

    }
}

接口的特点：
1、接口是对外暴露的规则。
2、接口是程序的功能扩展。
3、接口可以用来多实现。
4、类与接口之间是实现关系，而且类可以 继承一个类的同时实现多个接口。
5、接口与接口之间可以有继承关系。

---

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

体现：
父类或者接口的引用指向或者接收自己的子类对象。

作用：
多态的存在提高了程序的扩展性和后期可维护性

前提：
需要存在继承或者实现关系
要有覆盖操作

猫，狗。
*/

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("拱地");
    }
}

class DuoTaiDemo2
{
    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.看电影();
        */
        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");
        }
        else 
        */
        if(a instanceof Cat)
        {
            Cat c = (Cat)a;
            c.catchMouse();
        }
        else if(a instanceof Dog)
        {
            Dog c = (Dog)a;
            c.kanJia();
        }


        /*
        instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)  
        */

    }
}

在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。

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

多态的主板示例

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


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

}
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("mainboard 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");
    }
}
*/

class DuoTaiDemo5 
{
    public static void main(String[] args) 
    {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.usePCI(null);
        mb.usePCI(new NetCard());
        mb.usePCI(new SoundCard());

    }
}

object类–equals（）
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 String toString()
    {
        return "demo:"+num;
    }


}
class Person 
{
}


class ObjectDemo 
{
    public static void main(String[] args) 
    {
        Demo d1 = new Demo(4);
        System.out.println(d1);//输出语句打印对象时，会自动调用对象的toString方法。打印对象的字符串表现形式。
        Demo d2 = new Demo(7);
        System.out.println(d2.toString());
        //Demo d2 = new Demo(5);
        //Class c = d1.getClass();
//
//      System.out.println(c.getName());
//      System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));
//      System.out.println(d1.toString());
        //Person p = new Person();
        ///System.out.println(d1.equals(p));

    }
}