代码

public class A {
    int a=1;
    double d=2.0;

    void show(){

        System.out.println("Class A: a="+a +"\td="+d);

    }
}

public class B extends A{
    float a=3.0f;

    String d="Java program.";

    String c= "B property";

    @Override
    void show(){

        super.show( );

       System.out.println("Class B: a="+a +"\td="+d+"\tc="+c);

    }

    void show1(){
        super.show( );
        System.out.println("Class B: a="+a +"\td="+d);

    }


    public static void main(String[] args) {
//        A a=new A();
//        a.show();

        A b=new B();

        b.show();
//      b.show2(); error 无法使用B类的方法
    }
}

A a=new B();
先产生了一个父类对象A，再以A为基础产生了一个子类对象B(这个时候如果A类有属性、方法等B类会继承)，然后把B对象的首地址赋值给变量a。但是因为a变量的类型是A，所以a变量只能拥有A里定义的方法和属性，而无法使用B类里定义的新方法和新属性，当然如果B类有override的时候，还是取B类的属性及方法。
如果存在继承，在实例化一个子对象时，会先实例化它的父对象，如果父对象还有继承，又去先实例化父对象的父对象，最后产生拥有所有父对象特性的子对象（有冲突的属性或者方法，按子优先父的方式只保留一个，但是可以通过super.方法名或者super.属性名访问得到）。

内存布局

布局规则

Hotspot中java对象的内存布局：
每个java对象在内存中都由对象头和对象体组成。
对象头是存放对象的元信息，包括该对象所属类对象Class的引用以及hashcode和monitor的一些信息。
对象体主要存放的是java对象自身的实例域以及从父类继承过来的实例域，并且内部布局满足由下规则：
规则1：任何对象都是8个字节为粒度进行对齐的。
规则2：实例域按照如下优先级进行排列：长整型和双精度类型；整型和浮点型；字符和短整型；字节类型和布尔类型，最后是引用类型。这些实例域都按照各自的单位对齐。
规则3：不同类继承关系中的实例域不能混合排列。首先按照规则2处理父类中的实例域，接着才是子类的实例域。
规则4：当父类中最后一个成员和子类第一个成员的间隔如果不够4个字节的话，就必须扩展到4个字节的基本单位。
规则5：如果子类第一个实例域是一个双精度或者长整型，并且父类并没有用完8个字节，JVM会破坏规则2，按照整形（int），短整型（short），字节型（byte），引用类型（reference）的顺序，向未填满的空间填充。

应用

多态性，一个底层entity，多种bean模型。

//使用 帖子
 PostPromoDTO postPromoDTO = (PostPromoDTO)shoppingPromoAdminService.loadShoppingPromo(promoId);
//service
@Override
 public ShoppingPromoDTO loadShoppingPromo(int promoId) {
        if (promoId <= 0) {
            return null;
        }
        ShoppingPromoBean promoBean = shoppingPromoDao.loadById(promoId);
        if (promoBean == null) {
            return null;
        }
        //活动的多种实现形式
        switch (promoBean.getType()) {
            case 1:
                return buildPostPromo(promoBean);//帖子
            case 2:
                return buildH5Promo(promoBean);//h5
            case 3:
                return buildDealPromo(promoBean);//购买单
            case 4:
                return buildBrandNews(promoBean);//品牌简讯
            case 5:
                return buildShortPromo(promoBean);//短促
            default:
                return null;
        }
    }

//构建多种bean
private PostPromoDTO buildPostPromo(ShoppingPromoBean promoBean) {
        PostPromoDTO postPromoDTO = (PostPromoDTO) getBasePromo(new PostPromoDTO(), promoBean);
        PostBean postBean = postDao.loadPost(promoBean.getPromoID());
        if (postBean == null) {
            return null;
        }
        BeanUtils.copyProperties(postBean, postPromoDTO);
        List<PostParagraphBean> postParagraphBeans =     postDao.findParagraphs(promoBean.getPromoID());
        }
        return postPromoDTO;
    }

private H5PromoDTO buildH5Promo(ShoppingPromoBean promoBean) {
        H5PromoDTO h5PromoDTO = (H5PromoDTO) getBasePromo(new H5PromoDTO(), promoBean);
        h5PromoDTO.setUrl(promoBean.getUrl());
        return h5PromoDTO;
    }


private BrandNewsDTO buildBrandNews(ShoppingPromoBean promoBean) {
        BrandNewsDTO brandNewsDTO = (BrandNewsDTO) getBasePromo(new BrandNewsDTO(), promoBean);
        brandNewsDTO.setSubTitle(promoBean.getSubTitle());
        brandNewsDTO.setBrandId(promoBean.getBrandId());
        return brandNewsDTO;
    }

 private ShortPromoDTO buildShortPromo(ShoppingPromoBean promoBean) {
        ShortPromoDTO shortPromoDTO = (ShortPromoDTO) getBasePromo(new ShortPromoDTO(), promoBean);
        shortPromoDTO.setSubTitle(promoBean.getSubTitle());
        if (StringUtils.isNotBlank(promoBean.getContent())) {
            ShortPromoContent shortPromoContent = JsonUtil.fromJson(promoBean.getContent(), ShortPromoContent.class);
            shortPromoDTO.setRule(shortPromoContent.getRule());
        }
        return shortPromoDTO;
    }

//bean 转promoDTO
private ShoppingPromoDTO getBasePromo(ShoppingPromoDTO promoDTO, ShoppingPromoBean promoBean) {
        promoDTO.setPromoID(promoBean.getPromoID());
        promoDTO.setType(promoBean.getType());
        promoDTO.setTitle(promoBean.getTitle());
        promoDTO.setBeginTime(promoBean.getBeginTime());
        promoDTO.setEndTime(promoBean.getEndTime());
        promoDTO.setTags(promoBean.getTags());
        promoDTO.setPromoLocation(promoBean.getPromoLocation());
        promoDTO.setThumb(promoBean.getThumb());
        promoDTO.setAdminUserName(promoBean.getAdminUserName());

     ...
        return promoDTO;
    }

参考：
https://zhidao.baidu.com/question/177768075901671564.html?qbl=relate_question_0&word=java%20%BC%CC%B3%D0%20new%20%B6%D4%CF%F3（java通过子类实例化的对象A a=new B()）
https://www.cnblogs.com/wxw7blog/p/7052757.html（java继承中是否创建父类对象？）

Java 的继承机制是一种复用类的技术，从原理上来说，是更好的使用了组合技术，因此要理解继承，首先需要了解类的组合技术是如何实现类的复用的。

使用组合技术复用类

假设现在的需求是要创建一个具有基本类型，String 类型以及一个其他非基本类型的对象。该如何处理呢？

对于基本类型的变量，在新类中成员变量处直接定义即可，但对于非基本类型变量，不仅需要在类中声明其引用，并且还需要手动初始化这个对象。

这里需要注意的是，编译器并不会默认将所有的引用都创建对象，因为这样的话在很多情况下会增加不必要的负担，因此，在合适的时机初始化合适的对象，可以通过以下几个位置做初始化操作：

1. 在定义对象的地方，先于构造方法执行。
2. 在构造方法中。
3. 在正要使用之前，这个被称为惰性初始化。
4. 使用实例初始化。

class Soap {
    private String s;
    Soap() {
        System.out.println("Soap()");
        s = "Constructed";
    }
    public String tiString(){
        return s;
    }
}

public class Bath {
    // s1 初始化先于构造函数
    private String s1 = "Happy", s2 = "Happy", s3, s4;
    private Soap soap;
    private int i;
    private float f;
    
    public Both() {
        System.out.println("inSide Both");
        s3 = "Joy";
        f = 3.14f;
        soap = new Soap();
    }
    
    {
        i = 88;
    }
    
    public String toString() {
        if(s4 == null){
            s4 = "Joy"
        }
        return "s1 = " + s1 +"\n" +
               "s2 = " + s2 +"\n" +
               "s3 = " + s3 +"\n" +
               "s4 = " + s4 +"\n" +
               "i = " + i +"\n" +
               "f = " + f +"\n" +
               "soap = " + soap;
    }
}

继承

Java 中的继承由 extend 关键字实现，组合的语法比较平实，而继承是一种特殊的语法。当一个类继承自另一个类时，那么这个类就可以拥有另一个类的域和方法。

class Cleanser{
    private String s = "Cleanser";
    
    public void append(String a){
        s += a;
    }
    public void apply(){
        append("apply");
    }
    public void scrub(){
        append("scrub");
    }
    public String toString(){
        return s;
    }
    public static void main(String args){
        Cleanser c = new Cleanser();
        
        c.apply();
        System.out.println(c);
    }
}

public class Deter extends Cleanser{
    public void apply(){
        append("Deter.apply");
        super.scrub();
    }
    public void foam(){
        append("foam");
    }
    public static void main(String args){
        Deter d = new Deter();
        
        d.apply();
        d.scrub();
        d.foam();
        System.out.println(d);
        Cleanser.main(args);
    }
}

上面的代码中，展示了继承语法中的一些特性：

1. 子类可以直接使用父类中公共的方法和成员变量（通常为了保护数据域，成员变量均为私有）
2. 子类中可以覆盖父类中的方法，也就是子类重写了父类的方法，此时若还需要调用被覆盖的父类的方法，则需要用到 super 来指定是调用父类中的方法。
3. 子类中可以自定义父类中没有的方法。
4. 可以发现上面两个类中均有 main 方法，命令行中调用的哪个类就执行哪个类的 main 方法，例如：java Deter。

继承语法的原理

接下来我们将通过创建子类对象来分析继承语法在我们看不到的地方做了什么样的操作。

可以先思考一下，如何理解使用子类创建的对象呢，首先这个对象中包含子类的所有信息，但是也包含父类的所有公共的信息。

下面来看一段代码，观察一下子类在创建对象初始化的时候，会不会用到父类相关的方法。

class Art{
    Art() {
        System.out.println("Art Construct");
    }
}

class Drawing extends Art {
    Drawing() {
        System.out.println("Drawing Construct");
    }
}

public class Cartoon extends Drawing {
    public Cartoon() {
        System.out.println("Cartoon construct");
    }
    public void static main(String args) {
        Cartoon c = new Cartoon();
    }
}
/*output:
Art Construct
Drawing Construct
Cartoon construct
*/

通过观察代码可以发现，在实例化Cartoon时，事实上是从最顶层的父类开始向下逐个实例化，也就是最终实例化了三个对象。编译器会默认在子类的构造方法中增加调用父类默认构造方法的代码。

因此，继承可以理解为编译器帮我们完成了类的特殊组合技术，即在子类中存在一个父类的对象，使得我们可以用子类对象调用父类的方法。而在开发者看来只不过是使用了一个关键字。

注意：虽然继承很接近组合技术，但是继承拥有其他更多的区别于组合的特性，例如父类的对象我们是不可见的，对于父类中的方法也做了相应的权限校验等。

那么，如果类中的构造方法是带参的，该如何操作呢？（使用super关键字显示调用）

见代码：

class Game {
    Game(int i){
        System.out.println("Game Construct");
    }
}

class BoardGame extends Game {
    BoardGame(int j){
        super(j);
        System.out.println("BoardGame Construct");
    }
}
public class Chess extends BoardGame{
    Chess(){
        super(99);
        System.out.println("Chess construct");
    }
    public static void main(String args) {
        Chess c = new Chess();
    }
}
/*output:
Game Construct
BoardGame Construct
Chess construc
*/

1.示例

Animal 动物父类

/**
 * @author 李娜
 * @version 0.0.1
 * @since 0.0.1  2019-09-19
 */
public abstract class Animal{
    protected String firstName;
    protected String lastName;
    protected Integer count=1;
    private String name;

    public void setCount(Integer count) {
        this.count = count;
        if(count<3){
            this.count=3;
        }
        if(count>5){
            this.count=5;
        }
    }

    public Integer getCount() {
        return count;
    }

    public Animal() {

    }

    public Animal(String name) {
        this.name = name;
        System.out.println(this.name);
    }

    public Animal(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public void animalShout(){
        for (Integer i = 0; i < count; i++) {
            System.out.println("我的名字叫："+firstName+lastName+ shout());
        }
    }

    public abstract String shout()；
   
}

Bird子类

package animal;

/**
 * @author 李娜
 * @version 0.0.1
 * @s extends Animalince 0.0.1  2019-09-20
 */
public class Bird extends Animal {
    public Bird() {
        super();
    }

    public Bird(String name) {
        super(name);
    }

    @Override
    public String shout() {
       return "布谷布谷";
    }

    public Bird(String firstName, String lastName) {
        super(firstName, lastName);
    }
}

Test 测试类

/**
 * @author 李娜
 * @version 0.0.1
 * @since 0.0.1  2019-09-18
 */
public class Test {
    public static void main(String[] args) {  
        Animal animal=new Bird();
        animal.animalShout();
        animal.shout();
    }
}

具体想知道类的继承原理，我们需要从类的加载开始。

2.类加载

类加载过程包括：
加载：根据类名称获取二进制字节流，转化成方法区数据结构，并在堆中生成类class对象
验证：验证是否安全
准备：为静态变量在方法区分配内存
解析：把符号引用转化成直接引用
初始化：一般在new对象的时候会触发初始化，并为静态变量附上真实的值。

上面也说明了:类加载后会在方法区存放该类的信息，创建对象时，创建出一个对象存放到方法区，并在栈中有指向该对象的引用，堆中每个对象除了保存类的实例变量之外，还保存着实际类信息的引用，如下图所示：

3.方法调用

我们先来看animal.animalShout();这句代码的执行过程是：

• 查看animal的对象类型，找到Cat类型，在Cat类型中找animalShout方法，发现没有，到父类中寻找
• 在父类Base中找到了方法animalShout，开始执行animalShout方法
• 在animalShout方法中发现调用了shout方法，就从Cat类型开始寻找shout方法
• 在Child类型中找到了shout()方法，执行Cat中的shout()方法，执行完后返回animalShout方法
• 继续执行action方法，输出打印信息

寻找要执行的实例方法的时候，是从对象的实际类型信息开始查找的，找不到的时候，再查找父类类型信息。

如果继承的层次比较深，那么如果调用的存在最底层的父类，则调用的效率是比较低的，所以系统使用一种称为虚方法表的方法来优化调动的效率。
所谓虚方法表，就是在类加载的时候，为每个类创建一个表，这个表包括该类的对象所有动态绑定的方法及其地址，包括父类的方法，但一个方法只有一条记录，子类重写了父类方法后只会保留子类的。

参考：
继承实现的基本原理
java类的加载机制