: Y5 N0 e r2 W& a/ z: H. F父类使用默认构造器2 {( F0 X" o: r+ N
2 `& b p2 J' L R
package Extends; 2 N/ h5 f# _) [5 @ 9 a' V: b! P8 a" t" ?) ^6 y) y! opublic class Father {/ y n1 h. _& S# L y
Father(){ //默认的看不出区别所以这边设置个无参构造器效果一样的' c" r9 O/ n- P# g+ ? h$ v
//当你不定义的时候就是这个构造器4 Y. W" S# Q& ?* i# s
System.out.println("This is Father Constrctor"); 1 J7 S3 q7 j2 c9 F } 2 }! s5 i5 I/ a6 D! d; h" v} ' n8 e/ j+ o( O. p& T* m8 epackage Extends;- A( n8 U/ b% ?
$ v6 X. l" K6 e) X( r' }- F! z+ ~$ vpublic class Nosuper extends Father{ $ d; W3 Z; n4 q2 s2 N9 u Nosuper(){ //定义子类的构造器/ {- ~$ \1 F5 }( s% e- F
System.out.println("This is Nosuper Constrctor"); 0 t9 Y Q) s' E* G. `7 k( y }; w- L( p) F+ O; q& |. B# h
$ t* k3 L- H' l: h public static void main(String[] args) { * |# |; J$ T+ G // TODO Auto-generated method stub5 @# i& U J) Z
Nosuper no=new Nosuper();/ F! {/ R% i5 O. u3 `
}6 R7 W+ q* _$ n: ~; s
. {6 I. ?& e- L8 X, _% f, C} 9 _6 K. V9 Q/ C+ e) dOUTPUT: 7 ]) `/ W' A. Q( X4 e: B) @This is Father Constrctor2 w) y* ?% C' B) ^+ [4 [
This is Nosuper Constrctor ) W) p! b+ k: t) N. V: D父类不使用默认构造器 # H( f1 Q s. T, I8 [& i( B" ~5 P' `5 X" Q @0 M; m" X
package Extends;6 e/ J* ^# W2 C8 f7 A
6 d& {$ Z$ H! Opublic class Father {' V( O$ F. S1 C- B: J
Father(String name){ ! w! ^! Y u6 B# P& L3 C System.out.println("This is Father Constrctor,name is "+name);( e' _1 S/ F& f+ |0 z: k
} 6 ]+ |9 K9 S+ Z9 n% n6 J4 X} 0 C# O7 d. l% E6 y. _6 ^+ Wpackage Extends; & a1 B1 A& G* h+ x" A8 z5 R 6 F/ c- T6 ~6 W4 Ipublic class Nosuper extends Father{9 y3 k4 x4 {2 w$ Z Q- |. R# k9 n1 N9 S
Nosuper(){ ( [( M8 g+ K1 |, F$ m5 X. a super("YYH"); //必须先调用父类的构造函数否则会报错 2 P9 E7 F4 f' z4 O- S: R. n# y System.out.println("This is Nosuper Constrctor"); : d4 W5 b' b4 X A6 u' O } ; ~& p, | I; @. O" f2 F8 z& d public static void main(String[] args) {1 o0 x2 f0 [, L( N3 D9 r1 ]
// TODO Auto-generated method stub. c- Q# \) L1 |: ?/ N+ T
Nosuper no=new Nosuper(); 2 c n+ I. m4 {- k% r4 H0 ~ }% }! P0 ~' D7 E. u& j
}" v0 S$ n& h7 S5 V. Y3 p0 Y/ J
OUTPUT:! T5 h; |& A" N3 x/ w5 I6 a' ^
This is Father Constrctor,name is YYH$ V; R% @) I1 C! {! j3 m+ R9 H
This is Nosuper Constrctor2 h' ~2 u# [% h. @
总结:对于继承来说,子类会默认调用父类的构造器,但是如果没有默认的父类构造器,子类必须要调用父类的构造器,而且必须是在子类构造器中做的第一件事(第一行代码)。5 ]0 O/ _( `. E8 C1 E* u7 {, W
5 C& {. U" [% Z7 Q5 |. [, ^1 X
2 W; Y* f/ D5 L$ ^. d
7 L; i, d5 ` ^. I/ y: E9 v继承中的向上转型 7 D2 ^ n6 s1 N2 T+ _# N. a! w5 |* B7 X% A% Q B6 D" T
当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法,但是它仍然要根据继承链中方法调用的优先级来确认方法,该优先级为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。 6 v$ S3 ?9 F/ v/ I1 { K$ e1 | P. D7 S8 r' T4 F" J. g1 P0 _ J' \4 k
package _4_8; 5 N% L' ~5 g1 |1 C3 x! ^ 5 c" h% L& T- u0 aclass A { # c+ E- m% ?. o7 X. @1 n& H- J9 v public String show(D obj) { e1 X* l. d3 K4 r* I; n0 p3 {1 @ return ("A and D"); * ?( X% N5 M7 p }1 q/ }2 X9 c- c( @9 F, ]8 n
public String show(A obj) {! _3 Z& e. ?* i& v9 ^$ C
return ("A and A");; F: q2 q% [! X: \6 I5 [4 n
} 0 ^5 Z* t, s9 w9 q
) e, t' }* [% T& p3 o0 u: y} + p$ f2 l; v4 s ! L1 S ?6 v7 m' l A. |4 \+ V" M6 l, C$ A* e6 [2 Tclass B extends A{ 1 C; U/ j; r- @8 R //重载4 b, k) I [2 M
+ }% T- N' s v public String show(B obj){; O/ S. N, x- z, k
return ("B and B"); 7 A! _) t2 ~& y }, f/ T) j; h- L/ U/ U4 h. z
//重写; A) I2 @: @4 `+ u$ \6 A/ w5 D
public String show(A obj){1 k g# Z1 O9 u5 U3 w1 J$ b! _
return ("B and A"); % s2 G9 N7 }, }, ^* @ } 1 R) M' j3 N0 e% y T. i5 O5 X- N" u7 I F* ~0 ]$ f}' T* i5 `0 N- S2 q6 Q5 N6 S, {1 {8 X
+ j1 G$ v t% q# x; U& k6 U& `" V ?- V( O
class C extends B{} 1 d# V3 G9 W8 P5 j& h, [# O% K( Xclass D extends B{} ' r' s9 Z- [/ A2 S) C' ^public class t {9 k& x3 m! c' R/ p! @, L4 P# I. {6 [
public static void main(String[] args) { ; {% F/ U, p5 _$ z A a1 = new A(); - b @, s5 `, a. F+ f& \ A a2 = new B(); //1.只能调用子类中重写父类的方法,不可以 , j) ~% g4 }; C; B! h( O9 C
//调用重载的方法 ( N2 ]' I* B; m B b = new B();- O& ~$ D# C/ e8 G
C c = new C();$ ^1 w9 Y, A8 m. m5 J. [9 C) }: m4 \% @
D d = new D(); @9 c p- r+ V# f
System.out.println("1--" + a1.show(b)); X7 \: q5 t1 r4 K0 R1 M) I
System.out.println("2--" + a1.show(c)); : G, e9 w) u+ |5 l System.out.println("3--" + a1.show(d)); O& S4 M7 A; o1 X
System.out.println("--------"); 7 a6 y% [# J( c, _4 U& V8 i System.out.println("4--" + a2.show(b)); ' |% [2 r; h6 t( a& f C System.out.println("5--" + a2.show(c));) E4 S* z+ z- o* A
System.out.println("6--" + a2.show(d));) m& h: y* C$ i9 F: y1 L2 ]
System.out.println("6--" + a2.show(a1)); & v1 E* h7 o3 m4 I System.out.println("*");9 }* _4 F2 C* R: V
System.out.println("7--" + b.show(b));6 ?$ ~& }/ X& z' ~4 w
System.out.println("8--" + b.show(c));* f- t5 N+ d6 ]& @ Y0 B
System.out.println("9--" + b.show(d)); / t7 p& g( C% H/ d& W
}9 E0 S# k- {3 _ u& }4 a
} 0 ]3 f4 h( L; \ EOUTPUT:8 y6 @5 R% ]0 B6 G' w6 l
1--A and A( f/ \0 e7 F4 E6 s) P8 T3 P% X$ ~
2--A and A: G, F4 X. ?! ^! r6 I# o+ o
3--A and D , N8 G( @1 m6 T; ^3 d$ n* g--------- W. M( B6 f6 v
4--B and A* ~0 N8 t& E& P$ n
5--B and A 1 J" v& L' n- l5 O N" T6--A and D % T6 _% m5 l+ W4 L! p- T' O7 p6--B and A & A- U% d2 Z: c( T6 {7 t* * P; f$ R$ x6 t+ x' A7--B and B' o5 ^' Q3 Y& D. E1 E- H3 _
8--B and B ( w* ?: S% K p9--A and D " |% q1 {! R& E 仔细理解一下其中的代码不难理解其中向上转型在继承中的作用。按照this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)这个顺序一步一步的执行就会得到结果。/ |# K" e2 k* P5 x. d, G
, A. |) Z* a2 x. k+ p' P将子类转换成父类,在继承关系上面是向上移动的,所以一般称之为向上转型。由于向上转型是从一个叫专用类型向较通用类型转换,所以它总是安全的,唯一发生变化的可能就是属性和方法的丢失。5 C" b, F! h; h8 r' t+ _" s
5 u9 S* I' R* e9 ?# G继承慎用 # r" b, J. m U: X' {: s1 t3 W! B% R
你会感觉当你在编写三四个程序的时候用继承解决了他们公共的部分是很方便的,但是如果你程序很大,class很多而且都继承于一个类中,当你想通过改变父类的一些信息来改变一个子类的信息的时候就会发现其他的子类也会随之改变,有时候会对其他的子类产生不必要的结果。* j) J9 W! t- y
! L! t3 W1 e: D% x' S
父类变了其他的子类就会随之全部改变。, _6 q& l J: m! N' [2 L2 w
) `8 h5 a. r E Y* w
继承破坏了封装,对于父类而言,它的实现细节对与子类来说都是透明的。* L( B0 ~ h" V2 Y
* L. B" i4 v- @2 b' Q8 @3 C
继承是一种强耦合关系。 0 x% L x" V8 m% g, O( F2 o* @ z+ ?; Y. |$ F1 L4 x, M
“问一问自己是否需要从子类向父类进行向上转型。如果必须向上转型,则继承是必要的,但是如果不需要,则应当好好考虑自己是否需要继承”——《Think in Java》 : u( C( Z, {7 H2 C" U# D 7 q1 L' `4 e& U& j后言4 e6 i2 i: m9 {: @