黑马程序员------继承(三)

黑马程序员------继承(三)

1.1 多态：可以理解为某一类事物存在的多种体现形态

人：男人，女人

动物：猫，狗。

猫 x = new 猫();

动物 x = new 猫();

1，体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
2，前提
必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提：存在覆盖。

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

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

示例1：

/*
动物，
猫，狗。
*/

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


class DuoTaiDemo 
{
    public static void main(String[] args) 
    {
        //Cat c = new Cat();
        //c.eat();

        //Dog d = new Dog();
        //d.eat();
        //Cat c = new Cat();
        /*
        Cat c1 = new Cat();
        function(c1);

        function(new Dog());
        function(new Pig());
        */

        //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();
        //a.catchMouse();
    }
    
}

 

1.2 如何使用子类特有方法呢？

     向上转型或者向下转型（示例2）

示例2：

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;
        

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

    }

}
 

 

PS:

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

1.3 多态在成员变量和成员函数中的特点：

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

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

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

示例3

class Fu
{
    static int num = 5;
    void method1()
    {
        System.out.println("fu method_1");
    }
    void method2()
    {
        System.out.println("fu method_2");
    }
    static void method4()
    {
        System.out.println("fu method_4");
    }
}


class Zi extends Fu
{
    static int num = 8;
    void method1()
    {
        System.out.println("zi method_1");
    }
    void method3()
    {
        System.out.println("zi method_3");
    }

    static void method4()
    {
        System.out.println("zi method_4");
    }
}
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);

        //f.method1();
        //f.method2();
        //f.method3();

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

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

 

 

1.4 上帝之父 Object类

Object:是所有对象的直接后者间接父类，传说中的上帝。
该类中定义的肯定是所有对象都具备的功能。

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

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

 

1.5 内部类（示例4）

定义：将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。

内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2，外部类要访问内部类，必须建立内部类对象。

访问格式：
1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象。
格式
外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();

2,当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？
uter.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。

 

当描述事物时，事物的内部还有事物，该事物用内部类来描述。
因为内部事务在使用外部事物的内容。

示例4：

class Body
{
    private class XinZang
    {

    }

    public void show()
    {
        new XinZang().
    }
    
}


class Outer
{
    private static  int x = 3;

    
    static class Inner//静态内部类
    {
        static void function()
        {
            System.out.println("innner :"+x);
        }
    }

    static class Inner2
    {
        void show()
        {
            System.out.println("inner2 show");
        }
    }

    public static void method()
    {
        //Inner.function();
        new Inner2().show();
    }

}


class  InnerClassDemo2
{
    public static void main(String[] args) 
    {
        Outer.method();
        //Outer.Inner.function();
        //new Outer.Inner().function();
        //直接访问内部类中的成员。
               //Outer.Inner in = new Outer().new Inner();
              //in.function();
    }
}

 

1.5.2内部类注意事项（示例5）：

内部类定义在局部时，
1，不可以被成员修饰符修饰
2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

示例5：

class Outer
{
    int x = 3;

    void method(final int a)
    {
        final int y = 4;
        class Inner
        {
            void function()
            {
                System.out.println(y);
            }
        }
    
        new Inner().function();
        
    }
}


class  InnerClassDemo3
{
    public static void main(String[] args) 
    {
        Outer out = new Outer();
        out.method(7);
        out.method(8);
    }

}

 

 

1.5.3 匿名内部类（示例6）:

1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。

示例6：

abstract class AbsDemo
{
    abstract void show();
    
}


class Outer
{
    int x = 3;

    /*
    class Inner extends AbsDemo
    {
        int num = 90;
        void show()
        {
            System.out.println("show :"+num);
        }
        void abc()
        {
            System.out.println("hehe");
        }
    }
    */

    public void function()
    {
        AbsDemo d = new AbsDemo()
        {
            int num = 9;
            void show()
            {
                System.out.println("num==="+num);
            }
            void abc()
            {
                System.out.println("haha");
            }
        };

        d.show();
        //d.abc();//编译失败;

    }
}



class InnerClassDemo4 
{
    public static void main(String[] args) 
    {
        new Outer().function();
    }
}