黑马程序员----继承2（接口、多态、object）

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

接口
接口：初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
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));    }}