组合和继承—-复用类的两种方法

350次阅读
没有评论

共计 2113 个字符,预计需要花费 6 分钟才能阅读完成。

日常开发过程中,我们程序猿更多时候会自嘲CV工具人,这是因为在业务逻辑开发时,重复代码太多了,如果真的要去全盘Copy的话,会显得很Low,这样我们就会想到复用代码,既省时又简洁。
那我们这里就会提及复用类的两种方法:①组合、②继承

语法

将对象引用置于新类成员变量位置;

/**
 * @author plm
 * @create 2021/3/4 23:01
 */
class Pen {
    private String s;

    public Pen() {
        System.out.println("Pen Construct.");
        s = "Construct";        // 在类的构造器中
    }

    @Override
    public String toString() {
        return "Pen{" +
                "s='" + s + '\'' +
                '}';
    }
}

public class Desk {
    private String
            s1 = "World",       // 在定义对象的地方
            s2 = "Peace",
            s3,
            s4;
    private Pen pen;
    private int i;
    private float f;

    public Desk() {
        System.out.println("Desk Construct.");
        s3 = "Hello";
        f = 2.43F;
        pen = new Pen();
    }

    {
        i = 45;                 // 使用实例初始化
    }

    @Override
    public String toString() {
        if (s4 == null) {
            s4 = "Hi";         // 惰性初始化(懒加载)
        }

        return "Desk{" +
                "s1='" + s1 + '\'' +
                ", s2='" + s2 + '\'' +
                ", s3='" + s3 + '\'' +
                ", s4='" + s4 + '\'' +
                ", pen=" + pen +
                ", i=" + i +
                ", f=" + f +
                '}';
    }

    public static void main(String[] args) {
        Desk desk = new Desk();
        System.out.println(desk.toString());
    }
}

/* 输出
Desk Construct.
Pen Construct.
Desk{s1='World', s2='Peace', s3='Hello', s4='Hi', pen=Pen{s='Construct'}, i=45, f=2.43}
 */

初始化时机

如上代码,有以下几处位置:
在定义对象的地方;(总是可以在构造方法被调用之前初始化)
在类的构造方法中
在使用到对象之前才会初始化,称为惰性初始化;(不必每次new对象就初始化,可以减少额外的开销)
使用实例初始化

语法

关键字extends,从现有类获得继承信息(所有的域和方法)构建出新类;

/**
 * @author plm
 * @create 2021/3/4 23:40
 */
class Dword {
    public Dword() {
        System.out.println("Dword Construct.");
    }

    void dp() {
        System.out.println("dp.");
    }
}

class Nword extends Dword {
    public Nword(int i) {
        System.out.println("Nword Construct.");
    }

    void dp_1() {
        System.out.println("dp_1.");
    }
}

public class Sword extends Nword {
    private int i = 7;

    public Sword(int i) {
        super(i);
        System.out.println("Sword Construct.");
    }

    void dp_2() {
        super.dp();
        super.dp_1();
        System.out.println("dp_2.");
    }

    public static void main(String[] args) {
        Sword sword = new Sword(6);
        sword.dp();
        sword.dp_1();
        sword.dp_2();
    }
}

/* 输出
Dword Construct.
Nword Construct.
Sword Construct.
dp.
dp_1.
dp.
dp_1.
dp_2.
*/

tips:supper关键字表示超类,想要调用基类的方法可使用supper.基类方法名()即可;

初始化基类

导出类进行初始化时,会先调用supper调用基类的构造方法进行初始化(此为隐式地调用基类的无参构造);
基类在导出类访问它之前就已经完成了初始化;

带参的构造方法

必须使用关键supper 显示地调用基类构造方法(如上代码),否则编译器就会提醒你:

There is no default constructor available in ‘cn.peiluming.test2.test1.Nword’

方法重写

既然子类拥有了父类的所有方法,那如果需要对父类方法进行自定义实现,这里就会涉及到重写,也是后面多态的前提之一
JDK 1.5 之后引入注解@Override,对你的重写方法进行校验;

组合一般多用于Has-a,在新的类中使用现有类的属性,而并非它的方法;多加上private修饰符!
继承多用于Is-a,常常结合向上转型使用,因为继承可以确保基类中的方法,在导出类中同样生效;

正文完
 0
裴先生
版权声明:本站原创文章,由 裴先生 2021-03-05发表,共计2113字。
转载说明:除特殊说明外本站文章皆由CC-4.0协议发布,转载请注明出处。
评论(没有评论)
本站勉强运行: