黑马程序员：java基础知识（二）

---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------

三、接口
    接口，是一个特殊的抽象类。定义接口的关键字——interface。
    接口中常见的定义：①常量"static final"；②抽象方法 "abstract 方法();"
    接口中不可以创建对象，因为在接口中有抽象方法。当一个子类实现一个接口时，必须实现了该接口的所有方法以后才能创建对象，否则这个子类还是一个抽象类，不可实例化。
    在java中，不支持多继承，但子类可以实现等多个接口。相对于类，接口有一个特殊，就是接口与接口之间可以实现多继承，并且只有接口才可以实现多继承。

    例如：

          class CA{}          class CB{}          class CC extends CA,CB{}  //这种做法是错的，java不支持多继承。                    Interface IA{}          Interface IB{}          Interface IC extends IA,IB{}  //这是正确的，接口可以继承多个接口。

    接口的特点：
    ①接口是对外暴露的规则。比如计算机的主板，它定义了一种规则，只要符合它的规则的产品就可以插到主板上使用。
    ②接口是程序功能的扩展；
    ③接口可以用来多实现；
    ④类与接口之间是实现关系，并且一个类在继承一个类的基础上，可以实现多个接口；
    ⑤接口与接口之间可以有继承关系，并且可以多继承；
    ⑥接口降低了耦合性。
四、多态
    所谓多态，就是事物存在的多种形态。比如，猫就有两种形态，一个是猫，一个是动物。
    1、多态的基本体现：父类的引用指向了子类的对象，父类的引用可以接收子类对象。例：interface IA{}
       class CA implements IA{}
       ....
       IA ia = new CA(); //父类的引用指向子类对象，这就是多态的基本体现。
    2、多态的前提：类与类之间，必须有从属关系，可以是继承，也可以使实现。
    3、多态的好处：使用多态可以大大的提高了程序的扩展性。
    4、多态的弊端：父类的引用只能访问父类中既有的成员。也就是说，在子类中扩展的新成员，使用父类引用是访问不到的。
    5、类型转换：
    类型转换分为向上转型和向下转型。向上转型，也叫做类型提升，就是子类类型转换成父类类型。类似于，char型转换为int型，可以隐式转换。向下转型，就是将父类类型转换为子类类型。类似于，int型转换为char型，需要进行强制类型转换。
    在使用多态时，父类的引用不能访问子类的中特有的成员，所以我们往往需要将父类的引用转换成子类类型。例如：
        Super sp = new Sub();//父类引用指向子类对象
        Sub sb = (Sub)sp;//将父类引用转换成子类类型
    在进行强制类型转换时，切记不能将父类的对象转换成子类类型。多态中，自始至终都是子类对象在做变化。例如：

        Super sp = new Super();        Sub sb = (Sub)sp;//这种做法将会出现类型转换异常:ClassCastException        //在进行类型转换时，下面这种情况也会出现类型转换异常.        class Super{}        class Sub1 extends Super{}        class Sub2 extends Super{}        ……        Super sp = new Sub1();        Sub2 sb2 = (Sub2)sp;//这种类型转换也会出现类型转换异常。    这是什么原因呢？可以这么解释一下，猫和狗都属于动物，想让一只猫强制转换成一条狗，当然是不行的。    那怎样避免出现类型转换异常呢？java中提供了一个关键字——instanceof。该关键字用来判断一个引用变量是否属于某个类型。沿用上面的例子：        Super sp = new Sub1();//父类引用指向了子类Sub1的实例对象        “sp instanceof Sub1” //这个判断将返回true        “sp instanceof Sub2” //这个判断将返回false

    所以在使用强制类型转换时，我们可以利用instanceof来判断引用的类型，避免类型转换异常。即：

         if(sp instanceof Sub1){             Sub1 s1 = (Sub1)sp;         }else if(sp instanceof Sub2){             Sub2 s2 = (Sub2)sp;         }

    6、多态中成员的特点：
    ①非静态成员函数：在编译时期参照引用变量所属类的成员函数，在运行时期参照所创建的对象的成员函数。举例说明：

        class Super{             void print1(){System.out.print("super")}         }        class Sub extends Super{             void print1(){System.out.print("sub1")}              void print2(){System.out.print("sub2")}         }        ……        Super sp = new Sub();        sp.print1();//编译正常通过，因为Super类中有print1这个方法，此处输出的结果是“sub1”，因为print1()方法已经被子类覆盖。        sp.print2();//编译不通过，因为Super类中没有print2这个方法。

    所以，成员函数在多态中，编译时看左边，运行时看右边。
    ②成员变量：无论是在编译时还是运行时，都参照引用变量所属的类（左边）。
    ③静态成员：无论是在编译时还是运行时，都参照引用变量所属的类（左边）。
五、内部类
    1、内部类的访问规则：
    ①内部类可以直接访问外部类的成员，包括私有成员。之所以可以直接访问，是因为内部类中持有了一个外部类的引用：Outer.this
    ②外部类访问内部类，须要创建内部类的对象。
    内部类对象的创建：Outer.Inner io = new Outer().new Inner();
    内部类是外部类的成员，与普通的成员，可以使用成员修饰符修饰。例如，static、final等。
    2、静态内部类：
    静态内部类对象的创建：Outer.Inner io = new Outer.Inner().
    外部类中访问内部类的非静态成员的方式：new Outer.Inner().非静态成员
    外部类中访问内部类的静态成员的方式：Outer.Inner.静态成员
    需要注意的是，①如果内部类中定义了静态成员，则该内部类必须是静态的；②外部类的静态方法不能访问非静态的内部类；③外部类的静态方法可以直接访问静态的内部类。例如：

        class Outer{            static void function(){                Inner.show();//错误的方式                new Inner().show();//这也是错的                new Outer().new Inner().show();//这也是正确的，上面②的说法是错的？但老师是这么说的。            }            class Inner{                void show(){}            }        }

    3、局部内部类：
    类似于局部变量，定义在方法或代码块中。局部内部类不能是静态的；不可以被成员修饰符修饰；他仍然可以直接访问外部类的成员，因为它仍然持有外部类的引用；可以访问该局部中被final修饰的变量，没有被final修饰的变量该内部类不能访问。例：

        class Outer{            void function(){                int x = 1;       //没有final修饰符                final int y = 2; //有final修饰符                class Inner{                    void show(){                        System.out.println(x); //不可以访问                        System.out.println(y); //可以访问                    }                }            }        }

    4、什么时候使用内部类？
    类是对事物的描述，所以当某个事物内部还有事物时，我们就使用内部类来描述。例如，人体是一个事物，也就是一个类，人体内部还有心脏之类的事物，这是人体这一事物的内部事物，所以心脏这一事物就使用内部类来描述。就说，人体是外部类，心脏是内部类。
    5、匿名内部类
    顾名思义，就是没有名字的内部类，是内部类的简写格式。定义一个匿名内部类的前提是，该内部类必须有父类，可以是继承一个类或实现一个接口。
    匿名内部类的定义格式：new 父类或接口(){ 定义子类内容 }; 。其实就是创建了父类或接口的匿名子类对象，而且是一个“带内容”的对象。

    例：

        interface Super{      void show1();      void show2();        }        class Outer{            //方式一：      void function1(){                new Super(){        public void show1(){     System.out.println("show1");        }        public void show2(){     System.out.println("show2");        }         }.show1();//创建了一个匿名内部类，并调用的内部类的方法show1      }            //方式二：      void function2(){                Super sp = new Super(){        public void show1(){     System.out.println("show1");        }        public void show2(){     System.out.println("show2");        }         };//创建了一个匿名内部类，并创建一个接口的引用指向这个匿名内部类。               sp.show1();               sp.show2();      }        }

    上面的两种匿名内部类的创建方式中，方式二更为灵活。从方式二中，我们可以看出，匿名内部类的使用，也是多态的一种体现。但不管哪种方式，内部类必须全部实现父类或接口的抽象方法，因为内部类不能是抽象类。如果父类中的抽象方法太多，那么创建匿名内部类时，就显得很臃肿。所以，当父类或接口中的抽象方法太多时，不建议使用匿名内部类。使用匿名内部类时，内部类中定义的方法最好不要超过3个。

---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------

详细请查看：http://edu.csdn.net