9 p$ E; K+ _3 l( d# ^) z" Y父类使用默认构造器 1 l. l5 A0 H6 l- a$ e* P$ B$ z, \ K' E
父类不使用默认构造器 4 V2 _. \4 d' _' |$ Q+ \: D }% a h2 ^: H
继承中的向上转型( R5 g, w) z/ P, g
8 ?4 S" t7 O5 W2 l
继承慎用; L: N$ K) ?! w% k. b3 [
- L7 \/ |" K* n! q+ J后言 ; m. J6 P' L. u1 L 6 X8 p" s. z1 I$ g6 n7 z6 I 7 E+ C: ^8 u, X( N+ T# s* _/ N i1 h0 @. T
前言1 k1 X9 q( G. J8 K( v, f: t2 t
- F/ V( t! W- X$ D' B+ I
社会中就有继承的概念(百度百科):继承是指一个对象直接使用另一对象的属性和方法。也指按照法律或遵照遗嘱接受死者的财产、职务、头衔、地位等。这个解释中的前一句正说明了我们要今天要讲的对象(继承)的大体特性。8 E% B, M: |: f7 o6 v
# ^4 ?0 N/ y& E1 {( {$ [: v3 o8 N% I; M" D4 y8 T- J$ P. ~
, E3 u1 i! s6 M9 V' k3 \8 U
在写Java时用到继承的情况有?+ n7 v' \+ x- O6 \
. y6 q( M- X6 C8 q) l1 D: G
当我们准备编写一个类时,发现某个类已有我们所需要的成员变量和方法,假如我们想复用这个类的成员变量和方法,即在所编写类中不用声明成员变量就相当于有了这个成员变量,不用定义方法就相当于有了这个方法,那么我们可以将编写的类声明为这个类的子类即继承。0 A3 a9 M a1 n% t' O5 w
, c0 p, R& u* @/ Q% d' H+ y: x" n5 j
小知识: . h' W( }- [0 r: @4 i M: e2 B1 Y" G1 y1 f& u9 M源类,基类,超类或者父类都是一个概念 & u9 r2 R$ A2 m7 g6 k 8 L5 d$ {/ p& u7 B8 Q0 W导出类,继承类,子类也都是同一个概念 8 Z3 W/ A. _, ?( B% `$ s" `0 ^6 r9 _, h. I0 E
继承的语法: F# D' ]5 M7 K, W, M' m
+ n$ @1 e+ J( I& B9 e9 |1 u8 X
在类声明中,使用关键字extends来声明一个类的子类: / W/ U( ~6 ^: j! P u& F9 c+ ~3 o) W! @( i7 n* R! y
class 子类名 extends 父类名 {* Z, f8 ^# D: b: m. n9 U: ?9 n W! L {
, ^2 S& I4 O( q' P# K; C … + p5 \8 v/ ?+ S/ o ( R: r' y: [1 C g! l* r3 `3 K& [$ D}/ e' i8 J- V5 w! ]1 I( Y
% |6 q6 |+ w! w 注意:如类声明语句中没有extends子句,则该类为java.lang包中的Object的子类。这就说明了java中的代码其实都有一个继承的关系,只不过是继承Object这个java中最根本的父类。1 ^ L3 v6 m ~& u
, b/ v9 t) ?' a
继承的特点 . S3 d5 L- L9 q7 [; |9 O 4 N5 ~. d* w- r: p% H子类拥有父类非private的属性和方法,子类继承的父类方法和成员变量可以当作自己的方法和成员变量一样被子类的实例方法使用。 2 @! @2 O) s8 }2 `$ I" F5 n9 t6 L: I子类可以有自己属性和方法,即子类可以在父类的基础上对父类进行扩展。! G$ [; K0 V" f' q. z
子类可以用自己的方式实现父类的方法。(重写或者覆盖) - U6 Y# q1 r6 `- c/ Q访问权限和继承之间的关系5 w7 I9 d" @6 w, Y$ N1 p: l+ i
1 ^" j% ]3 A% l7 g* V访问限制修饰符限制对象对成员变量操作和方法调用,也限制继承性$ \: B) h& H y4 o$ y$ i
; h$ x/ o7 X6 X, P$ Y# [1 [当子类和父类在同一个包:父类private成员变量和方法不会被子类继承8 \ f. D9 h# o O+ p2 d& A% j
当子类和父类不在同一个包:父类private和friend(默认)成员变量和方法不会被子类继承 ( z6 R" c2 m1 d2 `, Z
0 O1 ?% L7 m: u
+ n) i3 U0 ^8 o H
构造器对继承的影响 # ?2 E# z3 Z& H) d8 r 1 s0 E# q/ \% T' p8 X9 H/ |什么是构造器: 3 Z6 Z. d6 P: c/ U/ E
9 x' M( T3 w' B! P! a! [9 r$ N构造器,也称构造方法、构造函数。作用是构造出来一个类的实例,确保对象得到初始化。2 w ~, D! G2 Y' k" }( L
构造器的格式: 权限修饰符 类名(无参/有参){}。% s, K# J) M0 `" i) ]: A
根据有无参数,可分为无参构造 和有参构造。 $ L# l% ^2 W' Q0 M$ [2 v# n! x
构造器的特性: . E* T7 V2 A: e/ h7 \& l& K9 w8 D# i* k
与一般方法名不同的是,构造方法名必须和类名保持一致,并且没有返回值。/ g- m' T9 H: Q# A& P
Java编译器会自动创建无参构造函数,因此在类中,无参构造即使没有,我们也可省略不写。实例化对象时无需赋值。" x/ g! }" ?2 i ^7 U0 k
倘若类中已存在有参构造函数,则编译器不再提供默认无参构造。实例化对象时需赋值,不然报错。 2 G" ]7 z: K& Q3 B0 O; H当类实例化一个对象时会自动调用构造方法。 ?1 Y. M8 w% R; g H构造器在Java的继承中会产生什么影响呢? " j$ \0 r/ q# H) b: p6 g: P9 R2 a7 N7 U: j8 N6 d
我们虽然继承了父类但是父类的构造器是我们子类继承不了的,我们只能去调用父类的构造器。那么在继承并且编写子类的构造方法的时候就要注意两种情况了:1.父类没有重写了构造函数(即构造函数是Java默认给的一个构造函数);2.父类重写了构造函数。 3 ^0 b7 [: C' W! [ a5 R 8 u/ h2 e( t5 J' M. z/ H. q父类使用默认构造器% T3 N7 Y9 G& Z e! a* y' v
4 ?* r& A7 [8 ]5 L. Y! j
package Extends; . M# F( V7 s( j O ' \0 [6 e! r/ B6 x1 kpublic class Father { ( o' D6 B* `' u* Y' r" b5 ]. a3 k6 P Father(){ //默认的看不出区别所以这边设置个无参构造器效果一样的* |' {# J! K0 @, r) k+ U/ t8 I& p
//当你不定义的时候就是这个构造器" l+ I0 s2 O! e) p
System.out.println("This is Father Constrctor"); g1 Y5 e6 {' k+ i3 t8 X4 t4 G
} 9 w X; e( u" H5 r3 e1 }} / t* o4 |; e0 Z& F2 |! D/ Lpackage Extends; / h" x' x3 d0 a [- b# t/ O% a. Y: t( E e2 X
public class Nosuper extends Father{7 \# E1 K( @* r/ k
Nosuper(){ //定义子类的构造器: i* O* M! [7 `7 P7 j
System.out.println("This is Nosuper Constrctor"); - t# j; _" x' w3 `5 V } 1 h) A2 z+ T- c- \# v9 g- P' `1 o% ?) ^5 B" |5 v& y
public static void main(String[] args) {9 U* o6 _( f" N% v
// TODO Auto-generated method stub- P: I0 O J: u# D+ b
Nosuper no=new Nosuper(); 6 h9 Q9 |) `" w. N+ d4 l' F } - C) \" K, p, y- ^6 a, T" N! j# S+ A* B: k! ?
} ( L! r: J" k. n" p; p: \" I* FOUTPUT: , d" R. d, t" A( N1 e% M: k. eThis is Father Constrctor 6 y4 W m3 N1 a# lThis is Nosuper Constrctor 1 h+ V" ~$ _% \; ]父类不使用默认构造器/ n& w/ d7 X* ` V
, |$ v. d; P! s" u0 }/ c
package Extends;: p6 r" ~7 R2 b9 J, ]
, S& ?5 r7 ?- \% b' v7 c% j
public class Father {$ N8 Q- ]$ p1 l- ^6 j7 q
Father(String name){ 7 t+ |: d+ l0 O; w; G& D, D4 t i b System.out.println("This is Father Constrctor,name is "+name);: z5 Y+ N7 ]0 K! c# a. r1 H3 A2 y
}( b2 r v$ X5 ~
}4 R5 W- w% [4 ?( n' u
package Extends;3 ?/ G+ I/ F% {! U2 j$ N8 O
7 m1 [: J' |1 I
public class Nosuper extends Father{' Q! Y/ \ L8 ], ~ l
Nosuper(){ % b/ E4 e: t& m$ o. H super("YYH"); //必须先调用父类的构造函数否则会报错# [* N& |8 A" r
System.out.println("This is Nosuper Constrctor"); % m6 K# B' C3 g n! a3 J" z. i% L } ) o( y7 i7 [0 } public static void main(String[] args) { ; w& i5 B/ l; h8 z: k2 p2 S // TODO Auto-generated method stub 2 J8 W+ c' m2 h+ t+ l) x Nosuper no=new Nosuper();' t( H2 N! `& _
} 3 y7 J. W+ B( w% V) q+ g} 2 r! h. f' q7 m/ @3 ^OUTPUT:1 F: @) d5 }) `' T, k2 G0 i
This is Father Constrctor,name is YYH6 z( [7 Z! L9 l% g! E
This is Nosuper Constrctor 5 w1 E' ^6 L7 D6 w: Z总结:对于继承来说,子类会默认调用父类的构造器,但是如果没有默认的父类构造器,子类必须要调用父类的构造器,而且必须是在子类构造器中做的第一件事(第一行代码)。 # Z5 B" I% n* D1 n) Z# J+ B) @ 2 [5 D1 R0 j" |. Q! S! m, v7 j$ o & J) D, v1 t# x. N! z5 a6 A. l9 d8 q+ z$ w" p, ^' R, ^
继承中的向上转型1 t9 d8 e @2 \2 p4 z( p, y" x
& S. _4 P" V: u( {7 _6 L. u, [
当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法,但是它仍然要根据继承链中方法调用的优先级来确认方法,该优先级为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。 % i. g8 k6 A: m' y8 k# S; ?4 h2 w( O% v
package _4_8; ) u) L( h' f L# S- n( G* z- \' c; m" O' ~! I8 P/ S
class A { 2 O: f- n! s, k+ m public String show(D obj) {. H, v! j/ g# m3 z5 L2 O
return ("A and D"); 8 S% Y; t e; X- [# M; z } [/ ^# h5 n$ J3 q% f6 A f8 k
public String show(A obj) { - _3 L% u3 N6 S* ]' J S0 i1 G% F return ("A and A"); ' O+ Q( D$ g& w' G a3 G0 {- S } ' u2 {& f3 B7 c: r9 U
9 b8 v" p, y6 x& t4 c5 e0 [
}, I; m! B: P' Q. f. V
+ l# Q* f( e4 Z7 {) Q2 |, H' e! b6 J; N) k2 k, K
class B extends A{0 f. X& m& n3 q1 m: D; i( h
//重载) W8 k+ l( C9 d6 z' X- ^
3 S# I$ P+ _, M: ]# d0 w
public String show(B obj){: C' z h1 T+ y @5 t* e
return ("B and B");7 u& v. o; ^9 k4 _; v
}; w) w/ C* X6 z/ s9 I! b' g5 r
//重写9 K4 D) z0 j) t1 A: w7 w
public String show(A obj){0 B; O5 L+ i9 T# w- E( E7 v+ }% q
return ("B and A");+ k8 @. ?& k% ^
} & O& Y, V: U0 v) u* X6 V- D3 }+ x! r6 Z2 A5 K/ k
} 3 A5 n7 e; y3 M n 5 v) Y$ `/ h" t$ x" o7 \9 \4 A, [) o( X- d4 {+ v$ b" }9 D! U" C8 `
class C extends B{} # ?. ?4 H( X, X D. J; Y$ Cclass D extends B{}9 M0 T) O) Y; m1 a/ T @9 T
public class t { 9 W6 f# [( D* a, z( D2 d- w [ public static void main(String[] args) {- P- l+ {+ S, v3 s! Y0 o8 L
A a1 = new A(); ! S! G+ U- U* Z5 z A a2 = new B(); //1.只能调用子类中重写父类的方法,不可以 8 z$ n9 q( H, z7 U0 H
//调用重载的方法 2 u( _. z' d9 U3 Q8 ~4 O9 g7 f B b = new B();' y1 H5 X5 q: K5 C6 T( N3 K" g9 J$ ~
C c = new C();$ g8 c' k9 V+ V: I7 v8 V
D d = new D();- q: Z6 z$ F. N8 w
System.out.println("1--" + a1.show(b)); c% |; ~- w9 k3 U t" G
System.out.println("2--" + a1.show(c));' W( r7 t) \/ ]% d' v& Q% k E
System.out.println("3--" + a1.show(d)); ( R! @ T: D' z System.out.println("--------");/ J6 Z0 D( V F4 \* [6 L
System.out.println("4--" + a2.show(b)); 9 i7 G. V0 v/ v( d System.out.println("5--" + a2.show(c)); ( }4 W- D6 O7 p4 T System.out.println("6--" + a2.show(d));& c7 U/ B& h$ T* k
System.out.println("6--" + a2.show(a1));& `% R; _, @+ n2 g1 v
System.out.println("*");3 t9 i0 n2 [. g1 r6 r$ ]) Q! e' k
System.out.println("7--" + b.show(b));( O6 U) Z( e3 l/ ]8 l
System.out.println("8--" + b.show(c)); 6 n: u& T' A3 `0 | System.out.println("9--" + b.show(d)); 8 T5 ^6 x) v9 _" P5 Z- F9 g
} ; z" H8 J# ], q0 h} P& Z3 d2 P( K2 z, E8 zOUTPUT: 0 P4 V" ?% c; j8 R5 M$ I6 n+ N0 k1--A and A" T; [! U8 y" R
2--A and A. m: a" G2 {% D7 @7 ~
3--A and D' _. ~, ^% o; G# N7 i8 h
--------6 @. s9 P: i" g2 q" n* d$ D
4--B and A9 U: U+ R: A5 ]. u& g4 x
5--B and A& d! |% F5 ?' X$ ~' n
6--A and D + W9 w5 C2 c, u% D. k. r6--B and A 6 y' z5 A4 u) V4 A- N: Y* ) F3 N3 C, w5 W, S7 K7--B and B5 c* O8 Y* A. g6 d% `( P% c
8--B and B" a& o6 H: b; o4 x& _
9--A and D $ `: w, w1 H5 `; [ 仔细理解一下其中的代码不难理解其中向上转型在继承中的作用。按照this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)这个顺序一步一步的执行就会得到结果。4 O+ O( v( L' b% C' ]: h
. @. j, I8 H0 m将子类转换成父类,在继承关系上面是向上移动的,所以一般称之为向上转型。由于向上转型是从一个叫专用类型向较通用类型转换,所以它总是安全的,唯一发生变化的可能就是属性和方法的丢失。 ; S7 U6 Z1 Y$ B* f2 I4 i ) U+ M) ~/ K6 W* E( m9 K继承慎用, c9 ~5 w% ]1 r0 g7 K
& C: V! T% R* H5 e. o' Y; T
你会感觉当你在编写三四个程序的时候用继承解决了他们公共的部分是很方便的,但是如果你程序很大,class很多而且都继承于一个类中,当你想通过改变父类的一些信息来改变一个子类的信息的时候就会发现其他的子类也会随之改变,有时候会对其他的子类产生不必要的结果。' O+ T, Q5 U# x! T c
6 i% J" F& _ U0 x! Y( u
父类变了其他的子类就会随之全部改变。1 y* f4 Z. {# m( ^9 [9 J5 G