该用户从未签到
|
1 面向对象(OO)
: l% ~8 P ]3 a6 t7 Y 1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例9 @1 b! V% L+ o& r. p$ A
2) 面向对象, 面向客观事物之间的关系.7 D2 @6 R1 F2 a0 k
4) OOA面向对象分析/OOD 面向对象设计# ]6 E2 G, V; ]6 D1 }; d! Q
客人来了(来了一个客人类型的某人)% s& x1 z7 U. M+ M! `
6 S4 e* p U) [+ t f: ] 5) 面向对象概念
, I1 q4 @/ c; V9 v0 E) q A 类型: 名词概念, 如: 客人, 菜品, 厨师7 M- b. O, @3 ?
B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
y, M L }) |4 ], H0 d C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
0 Y% s9 k" m6 \" |+ L D 行为(方法)
' o& D7 F' j% f. o) O+ ~7 R* Q 基本特征:
& j; R& ?% c4 v i A 多态: 行为/引用, 在具体情形下发生了变化的现象
9 o' a% g" Y4 O- Q4 K) D 一盏灯: 多态的
0 Z/ d; m2 k. B0 w. F9 K3 {' t/ r( S 打: 根据宾语发生变化
* ~1 y& u# S% G) W d B 封装: 任何对象实例都是尽可能封装, 减少暴露
+ e1 d: \( |" l6 K7 _ C 继承: 概念的继承关系% w' J3 ~4 i$ C4 ?3 i, I
* X' _6 {1 s2 p& \! L* G1 v5 F4 N
2 java 类型, 引用变量 与 堆对象% q. ^% ~: @( o3 `. j& ?
1)Java 类, 是用来描述事物类型的. 如: 书1 `, t( y+ b7 l( G) C5 s
<图书馆管理系统>中的概念: 书 Book
* D4 R: g! X R6 c& x 书的特征: 书号, 书名, 编号, 作者, 价格...
* _1 L7 b$ O# S. v' ]* n9 e 2) 类的声明:6 q+ N3 n0 g! V
public class Book{8 T! ]6 a6 F+ r4 Y9 k$ w9 i& V
long id;1 i( m" Y' Z d9 a6 ?$ S. I
String name;! O5 z" A& F2 r+ r
String isbn; //书号' z! t' O' V7 g! I. O/ V( m
String[] authors; //作者7 y \3 ?7 t; }/ K5 F
double price;
w1 r) p" v+ q% h$ Z }
% X4 D6 e7 R9 L# N8 `; {- A 3) 引用变量与对象的创建过程:
- i/ D; g% E# b- t# f A Java的内存管理与分配:+ Q) W& g4 h1 l
栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)+ P& l8 t2 e2 p* B- z/ v7 p
堆也是一块Java使用内存区域, 使用方式: 无需随机分配
6 U2 R, \( Q. c- T5 O# L. P B 局部变量 与 堆对象空间分配
$ r: A/ r* P& Y2 h: X Java 局部变量在栈中分配, 是按照变量的类型分配 * K% }3 w4 H1 k
对象在堆中分配, 按照类的属性(实例变量)分配空间
" O; Y, R3 u3 ?! u C 变量类型与分配
. P0 G. }+ @% v 变量分为: 基本类型和引用类型) `8 V3 a3 f1 x4 [0 v8 J! }
基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型 l4 N% x1 ~/ {7 \4 D" h( v
的值
% C% ~0 r1 }5 u8 A# x$ |7 c8 t 引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
. E% }; F: _6 T8 r1 u. L 对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",* K# @: o0 N: A Q2 L
由Java系统管理: 变量占用空间以及值的管理, 都是透明的. 1 B3 O5 j5 J- B/ `8 A: ?: R3 o
( `3 q6 g) W" C7 W" d3 _" u
4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null7 J# i* N5 s, b h" f7 F& B
5) 在null引用上调用属性或方法, 会发生运行时异常
) O; x4 ]- w5 v% e& N
; W5 ]0 D" Y) k1 `8 }" V+ S8 \9 I% V! ? 案例:8 A, t4 ?" Y* `# h0 `! m! E
平面绘图坐标系中的一个点(Point),定义合理的属性
2 F: n$ D! g3 @" Y# n 坐标是int类型.6 e% ?; J9 E6 @4 ~# I/ z! H
O+-----------------------------> X5 s( ]2 f! W7 ~; C4 ]
|
2 A' o8 J% c( H+ s1 S8 Q4 k, p |) o# x; a# M2 V4 g! N
|
}& O6 D# ` S9 H% b" [9 Z |
3 C5 L, w+ Y/ o: a4 b | . p(x,y)& h0 N! O, `; \% M7 b
|, S' c- T. R% @/ J4 r
|
9 G7 O& U# x! u6 v |
2 V6 a2 e- v8 b |+ x, m* T6 y: P3 X! W% N
0 c0 Q5 j; R1 I3 W2 e1 x
Y
! v8 n# i7 y9 P0 m& B: r; U4 q' X
3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
; s' M2 f5 `+ n3 F' [9 B- ` 1) / c. b7 Z; i8 C" Y. j8 z
如: 月饼实例的创建, 使用面和馅创建.5 l: |2 P9 p: i/ w0 A. e
制作(构造器). G5 J$ N, _) F1 }& s C
月饼模子(类) -----> 月饼(对象)
- K: I( F7 Q% ^ 原料(构建参数). c# v+ U2 e; m# U$ G% v
4 f; L! m; [% q5 ]/ |
点类型 --------> 原点 9 K x) C7 r) X/ X
坐标(1,2)! y l4 m; x) O5 C, r
/ z- W# J' }' T4 d 2) Java中的构造器: 声明在类内部, 方法名与类名一致. c: C' ^: Z4 B8 p; } S9 @7 @
的方法叫构造方法, 构造方法不能声明返回值类型.& [/ n- w8 g: `0 ^
构造方法可以包含参数, 参数一般是创建对象实例( t4 C6 [/ f6 `7 }' X
必须依赖的条件(前提条件).' e! [9 l% T4 Q+ l
public class Point {
+ N% ]+ B( H& r% ?6 p4 f7 M int x;
% C- P: [2 M/ @9 t int y;
- r" F! p& j: G* c( Z /** 构造器 */6 H+ t. c4 m9 t: Z% C9 c
public Point(int x, int y){
4 |3 K5 [# C* O- [5 g1 Q3 G this.x = x;
$ q8 E9 q, W- u this.y = y;9 ?8 q0 P* _+ z2 ^, L- G7 Q
}
. I# y( _& ]6 U3 ^, R }0 K1 q+ _, b7 c2 G- \. C
# g v! y$ v% t4 J, ?" d1 E 3) 对象实例化过程:
$ _2 B8 ]6 W: o# A o6 P6 G new运算: 创建对象实例 T* m+ @! a8 K1 i" }) M! ]- V
1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量, m3 v! G3 C" Q
2 根据参数类型调用构造器.
* q, T( E. T% d I8 f 3 new运算返回对象的引用地址.
5 A" s6 [) b; c1 k/ I# T8 Q! V ]9 C! F$ l- N. h
4) this 关键字: B9 a% J. D k/ X
this 是对当前对象的引用, 是运行期间当前对象本身.& l! I% \( W" Y6 V2 I; Z2 a
可以使用this明确的访问当前对象的属性或者方法
: {- a8 d1 v0 q5 I+ w8 P 类似于"我".6 h5 q/ D- @8 d/ T/ {. l: D8 F2 Z
this() 是调用本类的其他构造器, 可以使用构造器的重用,
0 ?0 k5 V. Q. n' j) R2 h) v 简化代码的实现.
4 x! x. Z0 h" b8 I * this() 必须写在构造器的第一行!
M" U8 Q" o0 H7 u. b) j, G
) Z" @7 b4 P5 r1 J$ a 5) 构造方法重载: 参数不一样的构造器
& X3 [; q# c) n, E, B# Z/ V8 i 案例: Point.java
3 ? R0 }# |. K( R2 t 方法签名 = 方法名+参数类型列表
6 @" O) S% R* |4 k1 v 方法重载:a 方法名一样 b 方法参数不一样
% @7 ^) @1 k7 ~+ N- X: r6 Y 也可以说: 方法名一样, 方法签名不同的方法
" b. s& o5 n5 _! R- g! S* G) G( U! g
6) 默认构造器8 m8 A6 j( Y. Q @- E
1 java 类一定有构造器
" Q6 J. |, E! x% D l; F4 t 案例: ConstructorDemo.java
3 n1 W3 T3 L" G3 s& V 2 如果类没有声明任何构造器,Javac自动提供一个7 S9 _6 k8 Q5 ?0 G5 F6 g
默认构造器, 无参数默认构造器
8 j: y' ~: D- D, U 3 如果提供构造器声明, Javac将不再提供默认构* }0 u6 ?2 A2 n1 l& q K
造器. 9 d. y- q+ ]# i" s% \& ]* K
; S1 v! X% A q. l
4 对象的方法
5 c& @/ n& H# t8 _$ _* ~9 ^ 1) 表示对象的功能, 依赖于对象存在.8 ?" Z; ~" }8 G; @/ p" s ^7 W$ F# O
案例: Point.java
8 ^* i. ^, A |! W/ G6 K 如: p1.distance() 和 p2.distance()
- ?% Y' y( D5 g6 q+ S- v- ~+ X 方法是动作,是功能,一般用动词声明. + m2 W8 S2 @$ ~ Z9 b4 c( }
2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
5 ^0 E% I* b. c% Y9 ?. q 功能的多态.重载的方法经常互相重用.
( m& F8 T+ B: i% J
9 g I9 ^9 q; d7 F. L 对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
9 q$ p8 ~* V$ }! Q7 ^; } 引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
6 B& ^+ U- ]: Z) `* @ a- \ 实例变量(对象属性)对堆对象中分配(如: 书的名字)3 m; p& h' g* Q) Y# ^
引用变量的值是地址值(透明管理,不可见), 通过这个地址% S; A1 y' P9 ~6 Z, j5 V
值引用了一个堆对象.
5 r# h: b/ [$ f: z: }$ g# O6 P
: x$ @; [4 ?# E6 d" ^/ s, O. x 不确切说法: 引用的值是对象
9 J+ J' w+ M/ `2 L" g 引用变量在栈中分配1 H) r8 s3 k$ e, D* t
类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了+ P/ [+ W: T% j' U
对象的样子.6 d( W1 ^! j3 \8 [# l7 ~2 g! p: j+ n
, I+ W5 w: Y2 X) P 想着对象写类型: 面向对象, 类是对象的抽象化7 W& M, l4 C( _) ?# Q
1 K: x: _& W) W 方法的重载: 体现了行为的多态现象
! P4 U6 E) x& P# x* U
$ R A( ?9 F7 ?; k* x# q r |
|