复用类有两种实现方式。
- 在新的类中产生现有类的对象,由于新的类是由现有类的对象所组成,所以这种方法称之为组合。
- 采用继承实现。
一 组合语法
下面创建两个类WaterSource和SprinklerSystem。其中SprinklerSystem中包含WaterSource的对象引用。
class WaterSource {
//如果定义时没有初始化,则基本类型会被自动初始化为0,对象引用初始化为Null
private String s;
WaterSource(){
System.out.println("WaterSource()");
s = "Constructed";
}
} public class SprinklerSystem {
private String value1,value2,value3,value4;
//定义时初始化
private WaterSource source = new WaterSource();
private int i;
private float f;
public String toString() {
return
"value1 = " + value1 + " " +
"value2 = " + value2 + " " +
"value3 = " + value3 + " " +
"value4 = " + value4 + "\n" +
"i = " + i + " " + "f = " + f + " " +
"source = " + source;
} public static void main(String[] args) {
SprinklerSystem sprinklers = new SprinklerSystem();
System.out.println(sprinklers);
}
}
运行结果如下:
WaterSource()
value1 = null value2 = null value3 = null value4 = null
i = 0 f = 0.0 source = WaterSource@15db9742
注意:如果把一个对象以String类型输出,则默认调用的是该对象的toString()方法。
类中成员变量如果是基本基本类型则默认被初始化为零,如果是对象引用则会被初始化为null。
我们也可以自己去初始化他们:
- 在定义成员变量的时候初始化,比如private String s1 = "happy";这意味着他们能够在构造函数被调用之前初始化。
- 在类的构造函数中初始化;
- 在使用这些成员变量之前初始化,这种方式称之为惰性初始化;
- 使用实例初始化{s1 = "happy";}。
二 继承语法
Java创建一个类时,默认都是继承于Object,除非自己指定从哪个类继承。
class Cleanser{
private String s = "Cleanser";
public void append(String a) { s += a; }
public void dilute(){append(" dilute()");}
public void apply() {append(" apply()");}
public void scrub() {append(" scrub()");}
public String toString() {return s;} public static void main(String[] args) {
Cleanser x = new Cleanser();
x.dilute();
x.apply();
x.scrub(); System.out.println(x);
} } public class Detergent extends Cleanser {
public void scrub() {
append(" Detergent.scrub()");
super.scrub();
} public void foam() {append(" foam()");} public static void main(String[] args) {
Detergent x = new Detergent();
x.dilute();
x.apply();
x.scrub();
x.foam();
System.out.println(x);
System.out.println("Testing base class:"); Cleanser.main(args);
} }
运行结果如下:
Cleanser dilute() apply() Detergent.scrub() scrub() foam()
Testing base class:
Cleanser dilute() apply() scrub()
看以看到继承使用的是关键字extends,如果在子类中想调用父类方法,可以使用super.*。
1、初始化父类
在创建一个子类对象时,父类构造器总会在子类构造器之前被调用。
class Art{
Art(){
System.out.println("Art constructor");
}
} class Drawing extends Art{
Drawing(){
System.out.println("Drawing constructor");
}
} public class Cartoon extends Drawing{
Cartoon(){
System.out.println("Cartoon constructor");
} public static void main(String[] args) {
Cartoon x = new Cartoon();
}
}
运行输出如下:
Art constructor
Drawing constructor
Cartoon constructor
所以很容易发现,子类对象的构建过程是从父类"向外"扩散的,所以父类在子类构造器可以访问它之前,就已经完成了初始化。
上面的父类构造函数是没有参数的,如果父类只有一个带有参数的构造器,就必须在子类构造器中用关键字super显式的编写调用父类构造器的语句,否则编译器将无法找到符合'类名()'形式的构造器。
2、重载
重载是指不同的函数使用相同的函数名,但是函数的参数个数和类型不同。调用的时候根据函数的参数来区别不同的函数。在Java中,子类可以重载父类的方法。
//重载显示
class Homer{
char doh(char c) {
System.out.println("doh(char)");
return 'd';
} float doh(float f) {
System.out.println("doh(float)");
return 1.0f;
}
} class Milhouse{} class Bart extends Homer{
void doh(Milhouse m) {
System.out.println("doh(Milhouse)");
}
} public class Overload {
public static void main(String[] args) {
Bart b = new Bart();
b.doh(1);
b.doh('x');
b.doh(1.0f);
b.doh(new Milhouse());
} }
运行结果如下:
doh(float)
doh(char)
doh(float)
doh(Milhouse)
3、protected
在实际的项目中,经常会想要将某些事物尽可能对整个世界隐藏起来,但仍然允许子类的成员访问它们。关键字protected就起这个作用,它指明"就用户而言,这是private的,但对于任何继承于此类的子类,它是可以访问的“。
//Protected关键字的使用
class Villain{
private String name;
protected void set(String nm) {name = nm;}
public Villain(String name) {this.name = name;}
public String toString() {
return "I'm a Villain and my name is " + name;
}
} public class Orc extends Villain{
private int orcNumber;
public Orc(String name,int orcNumber) {
super(name);
this.orcNumber = orcNumber;
} public void change(String name,int orcNumber) {
set(name);
this.orcNumber = orcNumber;
} public String toString() {
return "Orc " + orcNumber + ": " + super.toString();
} public static void main(String[] args) {
Orc orc = new Orc("Z3",12);
System.out.println(orc);
orc.change("l4", 23);
System.out.println(orc);
}
}
运行结果如下:
Orc 12: I'm a Villain and my name is Z3
Orc 23: I'm a Villain and my name is l4
可以发现子类change()方法可以访问父类的set(),这是因为set()的访问修饰符是protected。
参考文献:
[1]Java编程思想