该用户从未签到
|
1 面向对象(OO) + C, e8 l, V1 s+ k
1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例5 H( _: g, K- k/ N- Z j
2) 面向对象, 面向客观事物之间的关系.
( }, R5 q1 U+ z6 O 4) OOA面向对象分析/OOD 面向对象设计' a4 [$ ]' q0 }& v
客人来了(来了一个客人类型的某人): F# e. ?* x* N# U8 y
`1 @9 D' {0 ^6 _( j+ E! W( r- }# b 5) 面向对象概念
/ T( s7 a3 g! n+ \( V A 类型: 名词概念, 如: 客人, 菜品, 厨师
% q9 W7 A# B3 f' I( {7 C2 | B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
! S: M3 o0 A* Z* O& u. w C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡/ j8 x* u( w9 @ \) T
D 行为(方法)6 F/ E9 s3 Y2 v# A+ B. i! Y
基本特征:
. p& i8 b* l$ q- _0 f! U A 多态: 行为/引用, 在具体情形下发生了变化的现象
2 \5 p, z$ n6 G8 q$ @ 一盏灯: 多态的
0 U; ~9 m% s9 S2 L7 A 打: 根据宾语发生变化
/ [$ s7 b' l- d3 R0 h B 封装: 任何对象实例都是尽可能封装, 减少暴露
: l, g. s8 z" A% D' i* F6 s$ I C 继承: 概念的继承关系
; e4 P+ y& ^/ e+ Z9 }
# G" o: T% I: r! p4 A2 java 类型, 引用变量 与 堆对象' N, M5 A! r' w: [8 W
1)Java 类, 是用来描述事物类型的. 如: 书
" m& P( {7 i: F) y3 A <图书馆管理系统>中的概念: 书 Book
' ~) H6 Z7 Z! y! C8 B) Z$ F: e 书的特征: 书号, 书名, 编号, 作者, 价格...
) p m- {* D* k) a 2) 类的声明:
+ H" m+ G$ q1 B7 Z1 d0 e/ V public class Book{
" ]7 z7 T. x" c$ M9 T' ~) F+ Y long id;
3 Z4 b2 f& |/ G String name;8 e2 Z0 J' `5 S0 _! t/ V
String isbn; //书号4 [& N& f1 G/ ` S2 N4 n7 U
String[] authors; //作者3 g7 h) x$ F2 f' o3 d9 F r) y, h) ]
double price;
- P4 n' u1 w' P$ S/ C+ l0 J }
. B, t$ v# }# d; h, `/ C# H 3) 引用变量与对象的创建过程:
/ u: e! q( @4 T- F' N A Java的内存管理与分配:5 K6 C$ F# g% q) x4 W/ r* H- [
栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
& c& Y7 q3 J5 X* n4 M 堆也是一块Java使用内存区域, 使用方式: 无需随机分配+ v4 Z7 A1 e# }
B 局部变量 与 堆对象空间分配
7 ]5 O3 W) W' k0 d% q, p w Java 局部变量在栈中分配, 是按照变量的类型分配 0 V7 W) C K6 }% u8 F% Q
对象在堆中分配, 按照类的属性(实例变量)分配空间
( }- \9 v) {7 n# P C 变量类型与分配/ x4 w& X0 S0 U1 e8 f3 m
变量分为: 基本类型和引用类型
& `3 O# m, B! V+ `0 m% L 基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型; u0 t' s$ q* g# s. f
的值
! ~4 |0 p$ A; y( p5 }5 x 引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆, W0 R6 a+ }' D8 r' |: ^1 Q
对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",2 F" h. t/ ~$ _; K* p
由Java系统管理: 变量占用空间以及值的管理, 都是透明的. . p3 v: _/ k! _6 K2 ]7 N4 E
% U+ L4 l* N) g; s 4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null2 C" M+ D- B6 L2 h$ v
5) 在null引用上调用属性或方法, 会发生运行时异常
# `: c% ?8 I3 H" V
2 _+ R( p0 H/ d5 @ 案例:, C9 M: Z; I& C- ~( y9 b7 @+ T
平面绘图坐标系中的一个点(Point),定义合理的属性
3 e4 s+ G0 s, d) S. k# s7 ~# @ 坐标是int类型.
+ S! `$ a, s9 ~% N5 ^: b5 T O+-----------------------------> X2 p4 V" T, N* E+ i% L
|
, @$ z+ H# G5 q! ~$ n& t/ ?) d. Q |
/ F: z6 t- e; A3 I1 g# o$ M7 B% b |
/ x0 l, y0 ~- V* S |: y) G) v4 ]/ p: c1 R5 g, O
| . p(x,y)
; N* j1 P3 m& c* K: ` |' \! K$ |. v, @1 o& [
|
2 I& w0 F5 b. N: t+ [& } |
0 p8 q2 D2 N) _9 t# F |
0 i& l6 B4 |0 \1 Y6 M4 a L Q3 P& y: l7 }6 ^8 O: `
Y
& S2 E, Q2 a( I0 U) y7 }
) l# t8 D7 n4 v" y$ @7 g3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.8 r" d' Y- B7 @5 _, J" O
1) , O6 o- Q( y( S2 Y1 L- ^
如: 月饼实例的创建, 使用面和馅创建.
2 {' e \% @4 B) l 制作(构造器)# T# Y% D+ S4 @) d R4 i3 G
月饼模子(类) -----> 月饼(对象)
' r/ V6 Q/ N# W! x3 R5 o 原料(构建参数)9 P" }9 Q( C2 a+ J$ p$ a
$ }! M/ s0 ]9 J 点类型 --------> 原点
' E$ ?7 n0 L9 D- v# _ 坐标(1,2)7 d9 T8 S6 O% q6 l
5 a7 N$ i2 p3 @. a
2) Java中的构造器: 声明在类内部, 方法名与类名一致
6 v' w$ m$ a/ m3 [: _+ e" I 的方法叫构造方法, 构造方法不能声明返回值类型.
3 z3 Y: w Q4 U 构造方法可以包含参数, 参数一般是创建对象实例
5 o) ?9 g% N3 w) u% p$ q 必须依赖的条件(前提条件)., v2 d( |6 ]" R) H2 Q
public class Point {/ }* T0 g1 W+ f% D
int x;
& _) [- M5 D, M2 U2 U6 W4 m8 P c, o int y;, P- m- @) ~2 {
/** 构造器 */
! h0 D1 R: B" |/ d- Y public Point(int x, int y){
8 e, Q, K/ w6 j+ f" [ this.x = x;
) V" x0 l0 W# B. S- a9 \ this.y = y;
% a8 V4 ]: r8 b* C, n2 L& I# i* T' H }: F C" f5 u; M# S# B" |) m j
}
! p/ A3 D- V0 @; I) W9 O* }1 I
% H) e: A3 C5 A* r' Z/ z0 a1 }: f 3) 对象实例化过程:
" C1 J0 T, b! z6 _7 W new运算: 创建对象实例0 K6 a: N, B' \* ?- D
1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
1 {+ U" q0 a6 r 2 根据参数类型调用构造器. % r; O, R. z2 | U% H7 |
3 new运算返回对象的引用地址.% A. y4 a X1 y! H
- E. ^/ e+ Q, j6 m6 n4 p 4) this 关键字: O, U% V4 a9 J* V" R
this 是对当前对象的引用, 是运行期间当前对象本身., _( k6 X5 N! D m
可以使用this明确的访问当前对象的属性或者方法
( v9 R$ k0 | D; _ 类似于"我".
$ R( B4 c8 U% T1 h8 E) L. Y" m this() 是调用本类的其他构造器, 可以使用构造器的重用, ) U. a1 z9 {/ x) S0 p
简化代码的实现.
. K7 a* S8 R1 H" x( p- }" P" ^7 ] * this() 必须写在构造器的第一行!( {" [9 d8 w9 X- W2 T. f; v+ d3 u
$ [5 u2 h9 }( n, l' W/ Z 5) 构造方法重载: 参数不一样的构造器
4 E8 x3 f" n! n 案例: Point.java
o, [$ D( C9 H3 D4 k7 h+ z 方法签名 = 方法名+参数类型列表
* l- u1 E; o2 u 方法重载:a 方法名一样 b 方法参数不一样9 h! l$ L# t) v |; K2 S
也可以说: 方法名一样, 方法签名不同的方法4 N& W4 I- R% |" D% T! S6 W
+ D( m0 z6 E4 w
6) 默认构造器# E0 M; G/ k9 V, I/ A
1 java 类一定有构造器
1 q3 x: X" @$ G. n* [ 案例: ConstructorDemo.java+ D2 k6 X+ i8 E2 V+ H
2 如果类没有声明任何构造器,Javac自动提供一个
: n3 s% ?- u T8 { ? 默认构造器, 无参数默认构造器
3 K. E" u7 K* n0 J 3 如果提供构造器声明, Javac将不再提供默认构
& @+ P) J1 ^# B0 d5 P" @ K- }* Q 造器.
1 y+ x1 |; l. H2 D7 c" n& i: t# i+ m
4 对象的方法
, N, R" i2 j1 x8 M 1) 表示对象的功能, 依赖于对象存在.7 J3 a3 X# `% B$ e. p$ A. Z
案例: Point.java% b4 F6 u# s# }8 ?) s
如: p1.distance() 和 p2.distance()7 a/ t$ [) E2 K0 Y6 ^# [
方法是动作,是功能,一般用动词声明. 5 Z& Z4 e. g: J+ E
2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,6 v- s7 J7 j" D4 M: j
功能的多态.重载的方法经常互相重用.
: C6 S7 k; {) J) B4 E% z/ K, z
+ p# ~4 Z3 U6 B- A8 r: ]4 `2 W 对象: java运行期在堆(内存空间)中分配, 大小按照属性分配" D) Y" M8 f1 I
引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配% k4 j0 b6 C4 P, @* }) ^% V
实例变量(对象属性)对堆对象中分配(如: 书的名字)
% F, ?, {( \, J$ T. K 引用变量的值是地址值(透明管理,不可见), 通过这个地址6 c p A0 w8 K( A# g) T3 J
值引用了一个堆对象.& v& o- Q7 U# d
7 A& S0 b" o9 r. O 不确切说法: 引用的值是对象& P) u, l. l( ^( s+ ~
引用变量在栈中分配% @8 Q; j9 \1 H, n) ?
类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
" T, u: k& n% }0 n8 W 对象的样子.
" M$ f5 p4 ], o) U5 `
3 M1 m0 |" }- t% m8 t2 X# f 想着对象写类型: 面向对象, 类是对象的抽象化
; c. W6 u( @2 Z9 [) `5 J
- \& A8 S7 B, A0 n! z+ Q 方法的重载: 体现了行为的多态现象$ |; `' Q: J' V/ ]5 f# B) x
. _1 T3 J W% l I! y+ I( i8 ] |
|