黑马程序员----2015.6.16笔记（多态，接口，Object,内部类，匿名类，异常，throws）

来源：互联网发布：电商大数据分析平台编辑：程序博客网时间：2024/06/07 13:26

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

1.多态：可以理解为事物存在的多种体现形态
           a.多态的体现
               父类的引用指向了自己子类对象
               即父类的引用也可以接收自己的子类的对象
           b.多态的前提
               必须是类与类之间有关系，要么是继承，要么是实现
               通常还有一个前提：存在覆盖
           c.多态的好处
               大大的提高了程序的扩展性
           d.多态的应用

           e.多态的弊端
               提高了扩展性，但是只能使用父类的引用访问父类中的成员
2. instanceof 判断所属类型
3.

   class DuoTaiDemo    {            public static void main(String[] args)            {                Fu f = new Zi();                f.method1();                //f.method3();                    /*                    在多态中成员函数的特点：                        在编译时期：参阅引用类型所属的类中是否有调用方法，                                                如果有f.method1();编译通过，没有的话编译失败f.method3();                        在运行时期：参阅对象所属的类型中是否有调用方法                        简单总结：成员函数在多态调用时，编译看左边，运行看右边                                        */                                Fu f = new Zi();                System.out.println(f.num);//结果是fu类中的num :5                /*                    在多态中，成员变量的特点：                    无论编译和运行，都参考左边（引用型变量所属的类）。                                        在多态中，静态成员函数的特点：                    无论编译和运行，都参考左边                */            }    }        class Fu    {        int num = 5;        public void method1()        {            System.out.println("method_fu_1");            }                public void method2()        {            System.out.println("method_fu_2");            }    }        class Zi extends Fu    {        int num = 8;        public void method1()        {            System.out.println("method_zi_1");            }                    public void method3()        {            System.out.println("method_zi_3");            }    }

/*        接口和多态实现了程序的扩展性    */    class DuoTaiDemo1    {        public static void main(String[] args)        {            MainBoarde mb = new MainBoarde();            mb.run();            mb.runPCI(new NetCard());        }    }        interface PCI    {        public abstract void open();        public abstract void close();    }        class MainBoarde    {        public void run()        {            System.out.println("mainboard run")    ;        }                    public void runPCI(PCI p)        {            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");                }    }

/*        object 重写equals方法    */    class MyPerson    {            private int num = 0;                public void setNum(int num)        {            this.num = num;        }                public int getNum()        {            return this.num;            }        //重写equals方法        public boolean equals(Object obj)        {                //判断是否是MyPerson类型                if(!(obj instanceof MyPerson))                    return false;                    //强制转为MyPerson类型                    MyPerson p = (MyPerson)obj;                this.num = p.num;                return true;            }    }class ObjectTest{    public static void main(String[] args)    {        MyPerson p1 = new MyPerson();        p1.setNum(2);        MyPerson p2 = new MyPerson();        p2.setNum(2);        System.out.println(p1.equals(p2));        System.out.println(p1 == p2);    }    }

6.类不能被private修饰，内部类可以被private修饰
7.局部内部类中的成员函数不能被static修饰

/*        内部类定义在局部时        1.不可以被成员修饰符修饰        2.可以直接访问外部类中的成员，因为还持有外部类中的引用            但是不可以访问它所在的局部中的变量，只能访问final修饰的局部变量    */    class Outer    {            int x = 1;            void function(final int a)            {                final int y =5;                class Inner //内部类                {                    void function()                    {                        System.out.println("innner:"+y);//只有将y定义成final类型才能访问                        System.out.println("innner:"+a);//只有将a定义成final类型才能访问                    }                    }                }                            public void method()            {                    Inner in = new Inner();                    in.function();            }    }

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

10.

/*        匿名类使用的一个示例    */        interface Inner        {            public abstract void method();            }                class Test        {            public static Inner function()            {                Inner in = new Inner()                {                    public void method()                    {                        System.out.println("run method");                    }                };                return in;            }            }        class InnerClassTest        {            public static void main(String[] args)            {                Test.function().method();                }        }

11.异常：就是程序在运行时出现不正常情况
   异常由来：问题也是现实生活中的一个具体的事务，也可以通过java的类的形式进行描述。并封装成对象。
                      其实就是java对不正常情况进行描述后的对象体现。
   对问题的划分：一种是严重的问题；一种是非严重的问题

   对严重的问题：java通过error类进行描述
          对于Error一般不编写针对性的代码进行处理
   对于非严重的问题：java通过exception类进行描述
          对于Exception可以使用针对性的处理方式处理
   Throwable
                  ---Error
                  ---Exception
12.捕捉异常的一个例子

    class ExceptionDemo    {        public static void main(String[] args)        {            int a = 4,b = 0;                        try {                int c = a/b;            } catch (Exception e) {                System.out.println("除数不能为0");                System.out.println(e.getMessage());                System.out.println(e);//异常名称：异常信息                e.printStackTrace() ;//异常名称：异常信息：异常位置                            }                System.out.println("over");        }    }

13.   如何为自定义异常？
           因为父类已经把异常信息的操作都完成了
           那么就可以直接通过getMessage方法获取
       自定义异常：必须是自定义类继承Exception

      继承Exception原因：
      异常体系有一个特点：异常类和异常对象都被抛出
      他们都具备可抛性，这个可抛性是Throwable这个体系中独有的特点

      只有这个体系中的类和对象才可以被throws和throw操作

    //自定义一个异常类        class FuShuException extends Exception        {            private int value = 0;                FuShuException()            {                super();                    }                    FuShuException(String message,int value)            {                //父类Exception中构造函数Exception(String message)                super(message);                this.value = value;                    }                        public int getValue()            {                return value;                }        }                        class Div        {                public int div(int a,int b) throws FuShuException            {                if(b<0)                    throw new FuShuException("除数不能为负数",b);    //抛出可能的异常                return a/b;                }        }                class ExceptionDemo        {            public static void main(String[] args)            {                Div d = new Div();                //捕获可能出现的异常                try {                    d.div(5,-1);                } catch (FuShuException e) {                    System.out.println(e.getMessage());                    System.out.println("被除数是"+e.getValue());                }                    System.out.println("over");            }

14.throws:使用在函数上。   后面跟异常类，可以跟多个，用逗号隔开
   throw使用在函数内               后面跟的是异常对象

       }

/*    内部类的访问规则：    1.内部类可以直接访问外部类的成员，包括私有        之所有可以直接访问外部类中的成员，是因为内部类中持有了外部类的引用，格式：外部类名.this    2.外部类要访问内部类，必须建立内部类对象        访问格式：    1.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类的对象。    格式：外部类.内部类 变量名 = new 外部类.new 内部类                Outer.Inner in = new Outer().new Inner();    2.当内部类在成员位置上，就可以被成员修饰符所修饰        比如：private 将内部类在外部类中进行封装                    static 内部类具备static的特性                    当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。                                        在外部其他类中，如何直接访问static内部类中的非静态成员呢？                    new Outer.Inner().function();                                        在外部其他类中，如何直接访问static内部类中的静态成员呢？                                        Outer.Inner.function();                                注意：当内部类中定义了static成员，内部类也必须定义成static                        当外部类的static方法要访问内部类函数时，内部类也必须定义成static                                    */    class Outer    {        int x = 1;        class Inner //内部类        {            int x = 2;            void function()            {                int x = 3;                System.out.println("innner:"+x);//打印结果是3                System.out.println("innner:"+this.x);//打印结果是2                System.out.println("innner:"+Outer.this.x);//打印结果是1            }            }                public 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();        }    }

0 0