java的三大特性之一（继承）

代码的复用：组合和继承

组合的概念：new一个对象，并且引用改对象的属性或方法，复用的是代码的功能。

继承的概念：extends父类，采取现有类的形式对新类进行改造。

以上两种方法都可以很好的对代码进行复用，避免代码冗余。

组合的例子：

public class Test1 {
private String s;
Test1(){
System.out.println("Test1()");
s = new String("Constructed");
}

public String toString(){
return s;
}

public void zuHeFunction(){
System.out.println("组合方法");
}
}

public class TestMain {
private String s1 = new String("Happy New Year");
private String s2 = "Happy New Year";
private String s3, s4;
static Test1 t1;
Test1 t2;
Test1 t3;
int i;
float j;

public TestMain() {
System.out.println("TestMain()");
s3 = new String("Joy");
i = 3;
j = 3.14f;
t1 = new Test1();
}

void print(){
if(s4==null){
s4 = new String("Joy");
}
System.out.println("s1:"+s1);
System.out.println("s2:"+s2);
System.out.println("s3:"+s3);
System.out.println("s4:"+s4);
System.out.println("i:"+i);
System.out.println("j:"+j);
System.out.println("t1:"+t1);
}

public static void main(String[] args) {
TestMain testMain = new TestMain();
testMain.print();
Test1 t3 = new Test1();
t1.zuHeFunction();
t3.zuHeFunction();
}

public void f1(){
t2.zuHeFunction();
}
}

在MainTest类的main方法中，创建了一个Test1对象，然后调用Test1类中定义的zuHeFunction()。这就是代码的组合。

以上代码中需要注意的几点：

1、代码加载的时候最先加载static代码，如果不在main方法中重新定义一个t3，则会报//Cannot make a static reference to the non-static field t3

因为在加载main之前，只加载了static Test1 t1;

2、toString方法：

因为它是Object里面已经有了的方法，而所有类都是继承Object，所以“所有对象都有这个方法”。

它通常只是为了方便输出，比如System.out.println(xx)，括号里面的“xx”如果不是String类型的话，就自动调用xx的toString()方法。

总而言之，它只是sun公司开发java的时候为了方便所有类的字符串操作而特意加入的一个方法

所以打印出的对象，是一组字符串。

输出结果：

TestMain()
Test1()
s1:Happy New Year
s2:Happy New Year
s3:Joy
s4:Joy
i:3
j:3.14
t1:Constructed
Test1()
组合方法
组合方法

继承的例子：

继承关键字：extends

所有的类都继承java.lang.Object

执行程序的时候，先执行父类，再执行子类。（先有爸爸再有儿子）。这里的父类不仅指本身继承的类，而是指其上的所有的父类。

super指的是指向自己超类的指针，这个超类指的是离自己最近的父类。

三大用法：

super.属性 //超类的属性

super.方法() //超类的方法

super(); //超类的构造方法

public class Extends1 {
public int k = 1;

static{
System.out.println("Static Extends1");
}

public Extends1() {
System.out.println("Extends1()");
}



public void f1(){
System.out.println("f1()");
}

public int f11(int i){
++i;
System.out.println(i);
return i;
}

public void fk(){
k=111;
}

}

public class Extends2 extends Extends1{

static{
System.out.println("Static Extend2");
}

public Extends2(){
System.out.println("Extends2()");
}

public Extends2(String i){
System.out.println("Extend2(String)");
}

public Extends2(int i){
System.out.println("Extend2(i)");
}



public void f2(){
System.out.println("f2()");
}
}

public class MainTest extends Extends2 {
private int i=10;
private int k=0;

static{
System.out.println("Static MainTest");
}

public MainTest(){
super(1);//super构造方法(指定调用父类的哪个构造方法，运用于父类有多个构造方法时指定调用，如果没有写则调用父类默认的无参构造方法，如果父类没有定义则编译报错)
System.out.println("MainTest()");
}

public static void main(String[] args) {
MainTest mainTest = new MainTest();
mainTest.test();
}

public void test(){
int j = super.f11(i);//super方法
super.fk();//super方法
System.out.println("i:"+i);
System.out.println("j:"+j);
System.out.println("k:"+super.k);//super属性
System.out.println("k:"+k);//super属性
}
}

输出结果：

Static Extends1
Static Extend2
Static MainTest
Extends1()
Extend2(i)
MainTest()
11
i:10
j:11
k:111
k:0

输出结果分析：

1、子类继承父类，程序执行顺序，先父类再子类；

2、静态方法在程序加载之前完成，所以前三个按照父类到子类的静态方法先打印出来；

3、new MainTest()，从父类到子类执行构造方法，在子类super(1)指定了引用父类带int类型参数的构造方法，所以是Extend2(i)。如果去掉supert(1)则默认调用父类默认的无参构造方法Extend2()。如果去掉super(1)，且父类没有定义默认的无参构造方法Extend2()，则编译报错。

4、super的使用有三种场景，super.属性；super.方法；super()构造方法。

什么时候用继承，什么时候用组合？

详细的涉及设计模式，这里简单解释：
继承：is a 是不是关系强耦合比如女人是人，男人是人，这是继承

组合：has a 有没有高聚合低耦合比如需要用到某个对象的某个方法，则直接new一个对象，引用该方法即可，本身没有很大的关联性，只是你刚好有，我刚好用到的关系。

接口：can do 能不能，接口约束的是行为。

使用优先级考虑，如果继承和组合都可以，则可根据实际情况，优先考虑组合。

详细的涉及模式后面再学。

继承相关的类型转换：

上塑造性：

就是向上转型，按照类继承图的画法，一般父类是在最上面的，所以当子类向父类转型的时候，就是向上转型。向上转型对丢失一些特性的东西，所以不需要强制转换类型。

Person person() = new Women();

向下转型：

向下转型是大类变成的小类，有一些特性的东西没办法明确，所以是不安全的，需要进行强制转型，否则编译器报错。

Women women = (Women)new Person();

public class Person {

}

public class Women extends Person{
public static void main(String[] args) {
Women women = (Women) new Person();//向下转型，需要强制转换类型
Person person = new Women();//向上转型
}
}

程序的执行过程：

加载=》初始化（区分默认初始化和初始化是不同的）=》正式执行程序

更多相关文章

随机推荐