java 继承详解

一：父类
[java] public class A { 
     
    final String name="A"; 
 
    void A1(){}; 
} 

子类
[java]
public class AA extends A{ 
 
    String name="AA"; 
     
    void AA1(){}; 
     
    public static void main(String[] args) { 
         
        A a = new AA(); 
        System.out.println(a.name); 
         
        AA aa = new AA(); 
        System.out.println(aa.name); 
         
    } 
} 
输出：
A
AA

父类子类均定义了name属性
同样实例化子类，
a是父类引用
aa是子类引用

定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。

怎么使用子类强大的功能呢？就是子类重写父类定义的方法，然后自己在扩展

所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；

是不是很蛋疼

同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；

public static void main(String[] args) {
       
        A a = new AA();
        System.out.println(a.name);
        a.A1();
       
        AA aa = new AA();
        System.out.println(aa.name);
        aa.A1();
        aa.AA1();
       
    }
A1方法在A中，A的子类AA没有重写A1方法，所以，可以访问a可以访问A1。

对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。

[java]
public class A { 
     
    final String name="A"; 
 
    void A1(){ 
        System.out.println("A A1()"); 
    }; 
} 

[java]
public class AA extends A{ 
 
    String name="AA"; 
     
    void AA1(){ 
        System.out.println("AA AA1()"); 
    }; 
     
    @Override 
    void A1() { 
        // TODO Auto-generated method stub 
        //super.A1(); 
     
        System.out.println("AA A1()"); 
    } 
     
    public static void main(String[] args) { 
         
        A a = new AA(); 
        System.out.println(a.name); 
        a.A1(); 
         
    } 
} 
输出：
A
AA A1()
没有执行父类的A1，如果要执行父类的A1，则需要
[java]
super.A1(); 

这正是我们需要的。

给一个简单DOTA例子

英雄基类
[java]
package com.jc; 
 
abstract public class Hero { 
 
     
    abstract void run(); 
 
    public void stop(){/****/}; 
} 
SS暗影萨满-小Y
[java]
package com.jc; 
 
public class SS extends Hero{ 
 
    @Override 
    void run() { 
 
        System.out.println("ss run()"); 
    } 
     
    @Override 
    public void stop() { 
 
        System.out.println("ss stop()"); 
    } 
 
} 
BR蜘蛛
[java]
package com.jc; 
 
public class BR extends Hero{ 
 
    @Override 
    void run() { 
 
        System.out.println("br run()"); 
    } 
 
    @Override 
    public void stop() { 
        System.out.println("br stop"); 
    } 
 
} 

执行测试
[java]
package com.jc; 
 
public class Test { 
 
    @org.junit.Test 
    public void test1(){ 
         
        Hero br = new BR(); 
         
        br.run(); 
        br.stop(); 
         
        Hero ss = new SS(); 
         
        ss.run(); 
        ss.stop(); 
         
         
    } 
} 
输出：
br run()
br stop
ss run()
ss stop()
注：蜘蛛和小Y都执行了跑和停的方法，方法都是从父类继承的，但是却出现了不同的效果。
这难道不是我们正需要的吗