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 Years2:Happy New Years3:Joys4:Joyi:3j:3.14t1:ConstructedTest1()组合方法组合方法

继承的例子：

继承关键字：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 Extends1Static Extend2Static MainTestExtends1()Extend2(i)MainTest()11i:10j:11k:111k: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();//向上转型}}

程序的执行过程：

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