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

置顶霜天晓角.苍穹

于 2015-08-19 14:09:49 发布

阅读量225

点赞数

分类专栏： Java 学习笔记文章标签：多态-内部类

本文链接：https://blog.csdn.net/fantianfei1989/article/details/47779857

版权

Java 学习笔记专栏收录该内容

14 篇文章 0 订阅

订阅专栏

——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培训、期待与您交流！ ——-

霜天晓角.苍穹

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员—多态，内部类

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-1.多态： 1.1多态的表现形式：父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。1.2多态的前提：必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提，存在覆盖。1.3多态的好处和弊端：好处：大大的提高了程序的扩展性。弊端：提高了扩展性，但是只能使用父类的引用
复制链接

扫一扫