黑马程序员—多态，内部类

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

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

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

1.3多态的好处和弊端：
好处：大大的提高了程序的扩展性。
弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员。

1.4：

1.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  DuoTaiDemo{    public static void main(String[] args)     {        Cat c = new Cat();        function(c);        function(new Dog());        Animal a = new Cat();           //类型提升，向上转型。            a.eat();        //如果想要调用猫的特有方法时，如何操作？        //强制将父类的引用，转成子类类型。向下转型。        Cat c = (Cat) a;            c.CatchMouse();        //千万不要出现这样的操作，就是将父类对象转化成子类类型。        //我们能转化的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转化。        //多态自始至终都是子类对象在做着变化。    }    public static void function(Animal a)    {            a.eat();    }}

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

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 DuoTaiDemo{    public static void main(String[] args)    {        MainBoard mb = new MainBoard();        mb.run();        mb.usePCI(null);        mb.usePCI(new NetCard());        mb.usePCI(new SoundCard());    }}

需求：数据库的操作。
1.连接数据库。(JDBC Hibernat)
2.操作数据库。
c create/a add r read u update d delete
3.关闭数据库

interface UserInfoDao       //创建一个接口    {        public void add(User user);        public void read(User user);        public void update(User user);        public void delete(User user);    }        //通过JDBC方式连接数据库    class   UserInfoByJDBC implements UserInfoDao    {        public void add(User user)        {            1.JDBC连接数据库。;            2.使用sql添加语句添加数据。;            3.关闭连接。        }        public void read(User user)        {            1.JDBC连接数据库。;            2.使用sql读取语句和数据。;            3.关闭连接。        }        public void update(User user)        {            1.JDBC连接数据库。;            2.使用sql更新语句更新数据。;            3.关闭连接。        }        public void delete(User user)        {            1.JDBC连接数据库。;            2.使用sql删除语句删除数据。;            3.关闭连接。        }    }    //几年后，有更好的连接方式，通过Hibernate连接数据库    class   UserInfoByHibernate implements UserInfoDao    {        public void add(User user)        {            1.Hibernate连接数据库。;            2.使用sql添加语句添加数据。;            3.关闭连接。        }        public void read(User user)        {            1.Hibernate连接数据库。;            2.使用sql读取语句和数据。;            3.关闭连接。        }        public void update(User user)        {            1.Hibernate连接数据库。;            2.使用sql更新语句更新数据。;            3.关闭连接。        }        public void delete(User user)        {            1.Hibernate连接数据库。;            2.使用sql删除语句删除数据。;            3.关闭连接。        }    }    class DBOperate    {        public static void main(String[] args)        {            UserInfoDao ui = new UserInfoByJDBC();            ui.add(user);            ui.read(user);            ui.update(user);            ui.delete(user);            UserInfoDao ui = new UserInfoByHibernate();            ui.add(user);            ui.read(user);            ui.update(user);            ui.delete(user);        }    }

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

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

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

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

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

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

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("inner :"+x);        }    }        void method()        {            Inner in = new Inner();            in.function();        }}    class InnerClassDemo{    public static void main(String[] args)     {        //Outer.Inner in = new Outer().new Inner();        //in.function();        Outer.Inner.function();        //new Outer.Inner().function();    }}

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

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

class Outer{    int x = 3;    void method()    {        final int y = 6;        class Inner        {               void function()            {                System.out.println(y);            }        }    new Inner().function();    }}class InnerClassDemo{    public static void main(String[] args)    {        new Outer().method();    }}

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

代码1：

abstract class Demo{    abstract void show();}class Outer{    int x=3;    class Inner extends Demo    {        void show()        {            System.out.println("show:"+x);        }    }    public void function()    {        new Inner().show();    }}class InnerClassDemo{    public static void main(String[] args)    {        new Outer().function();    }}

代码2：

abstract class Demo{    abstract void show();}class Outer{    int x=3;    public void function()    {        //new Inner().show();        Demo d = new Demo()     //匿名内部类。        {            void show()            {                System.out.println("show:"+x);            }            void temptingheart()            {                System.out.println("love you forever");            }        };        d.show();        //d.temptingheart(); 编译失败，匿名内部类有局限性。    }}class InnerClassDemo{    public static void main(String[] args)    {        new Outer().function();    }}

代码3：

interface Inter{    void method();}class Test{    // 补足代码，通过匿名内部类。    //static class Inner implements Inter    //{    //public void method()        //{        //  System.out.println("method run");        //}    static Inter function() //只有Inter对象可以访问method方法。        {            return new Inter()            {                public void method()                {                    System.out.println("method run");                }            };        }}class InnerClassDemo{    public static void main(String[] args)    {        Test.function().method();        //Test.function:Test类中有一个静态的方法function        //.method():function这个方法运算后的结果是一个对象，而且是一个Inter类型的对象。        //因为只有是Inter类型的对象，才可以调用method方法。        Inter in = Test.function();        in.method();    }}class InnerTesst{    public static void main(String[] args)    {        new Object()        {            public void function()            {                }        }.function();    }}

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