java（3） 面向对象

1.super关键字
    * 使用super关键字调用父类的成员变量和成员方法。具体格式：
      super.成员变量
      super.成员方法([参数1，参数2...])
    
    * 使用super关键字调用父类的构造方法。具体格式：
      super([参数1，参数2...])
    
    * 通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。
    
    * 子类的构造方法中一定会调用父类的某个构造方法。如果没有指定调用父类的某个构造方法，在实例化子类对象时，会自动调用父类无参的构造方法。
      
2.final关键字
    * final类   使用final来修饰的类叫作final类。final类通常功能是完整的，它们不能被继承。
    
    * final方法 方法不可以被子类的方法重。final方法比非final方法要快，因为在编译的时候已经静态绑定了，不需要在运行时再动态绑定。
    
    * final变量 经常和static关键字一起使用，作为常量。final变量只能赋值一次，是只读的。

    * final 修饰数组或其他对象，则对象地址不可变，但内容还可变      
    
    --注：如想对final深入理解，需参考《Java初学者都必须理解的六大问题》
      
      
3.抽象类
    * 抽象方法 它只有声明而没有具体的实现。声明格式为：abstract void fun();
    * 抽象类   使用 abstract 关键字修饰的类为抽象类
      --抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public
      --抽象类不能用来创建对象
      --抽象类同样可以拥有成员变量和普通的成员方法
      --继承抽象类的子类，必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类
      

4.接口
    *接口中的变量会被隐式地指定为public static final变量，并且只能是public static final变量
    *接口中的方法会被隐式地指定为public abstract方法，并且只能是public abstract方法
    *非抽象类遵循了某个接口，就必须实现该接口中的所有方法。对于遵循某个接口的抽象类，可以不实现该接口中的抽象方法
    

5.抽象类与接口区别
    * http://www.cnblogs.com/felixzh/p/5938544.html
    * http://www.cnblogs.com/beanmoon/archive/2012/12/06/2805221.html
    

6.多态
    * 在同一个方法中，由于参数类型的不同而导致执行效果各异的现象就是多态
    
    * 使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象的不同，得到不同的效果。例如：

        //定义接口 Animal
        interface Animal{
            void shout();        //定义抽象shout()方法
        }

        //定义 Cat 类 实现Animal接口
        class Cat implement Animal{
            //实现shout()方法
            public void shout(){
                System.out.println("喵喵.....");
            }
        }
            
        //定义 Dog 类实现Animal接口
        class Dog implement Animal{
            //实现shout()方法
            public void shout(){
                System.out.println("汪汪.....");
            }

        }    
            
        //定义测试类
        public class ExampleTest(){
            public static void main(String[] args){
                Animal an1 = new Cat();        //创建Cat对象，使用Animal类型变量引用
                Animal an2 = new Dog();        //创建Cat对象，使用Animal类型变量引用
                animalShout(an1);            //调用animalShout(),将an1作为参数传入
                animalShout(an2);            //调用animalShout(),将an2作为参数传入
            }
            
            //定义静态的animalShout()方法，接收一个Animal类型参数
            public static void animalShout(Animal an){
                an.shout();
            }
        }    
    
    * 将子类对象当作父类使用时不需要任何显示地声明，但不能通过父类变量去调用子类中的某些方法（子类中存在，父类中不存在的方法）。    
    
        //定义接口 Animal
        interface Animal{
            void shout();        //定义抽象shout()方法
        }

        //定义 Cat 类 实现Animal接口
        class Cat implement Animal{
            //实现shout()方法
            public void shout(){
                System.out.println("喵喵.....");
            }
            
            //定义sleep()方法
            public void sleep(){
                System.out.println("猫睡觉.....");
            }
            
        }
                
            
        //定义测试类
        public class ExampleTest(){
            public static void main(String[] args){
                Cat cat = new Cat();        //创建Cat对象，使用Animal类型变量引用
                animalShout(cat);            //调用animalShout(),将 cat 作为参数传入
            }
            
            //定义静态的animalShout()方法，接收一个Animal类型参数
            public static void animalShout(Animal an){
                an.shout();
                an.sleep();
            }
        }        
    
        --当编译器检查到代码an.sleep()时，发现Animal类中没有定义sleep()方法而报错。由于传入的对象是Cat类型，在Cat类中定义了sleep()方法，通过Cat类型的对象调用sleep()方法是可行的，
        因此可以在animalShout()方法中将 Animal类型的变量强转为Cat类型。代码具体修改为：
        
            //定义静态的animalShout()方法，接收一个Animal类型参数
            public static void animalShout(Animal an){
                Cat cat = (Cat) animal;     //将 Animal 类型的变量强转为Cat类型
                cat.shout();
                cat.sleep();
            }