该用户从未签到
|
1 面向对象(OO) 4 _% z2 ~1 E6 g% ]$ J6 w' x
1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例' ^5 ] x2 d3 l3 c
2) 面向对象, 面向客观事物之间的关系.2 Y) k8 v) y& O- Z" l5 t) D2 C
4) OOA面向对象分析/OOD 面向对象设计
, R, z, t' P5 g3 E# N. j. @& M: [ 客人来了(来了一个客人类型的某人)
& e* o( O0 I* y' ~( }; b( R: Q$ a8 G O
5) 面向对象概念) r) p8 }+ b+ A
A 类型: 名词概念, 如: 客人, 菜品, 厨师7 X# D! _/ n6 }8 e8 v
B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
6 N U- @1 ?0 H3 `- Q$ C C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
8 l- }& P) Z0 B0 K# N& Q- C8 Q2 \ D 行为(方法)
$ M$ W% L0 I& }. [$ ?7 B 基本特征:$ ?4 ~/ n* D5 D
A 多态: 行为/引用, 在具体情形下发生了变化的现象- j9 K/ A5 w! b, r; M- V
一盏灯: 多态的3 X% n( P4 a; \1 M5 M! D# p
打: 根据宾语发生变化
% z7 G6 W. f( {3 W% C' ~7 W B 封装: 任何对象实例都是尽可能封装, 减少暴露
% P# `, [$ V1 g1 n5 l8 n# @ C 继承: 概念的继承关系
0 `9 F Y. p9 {7 }9 B2 m6 Z: _. e8 h1 v$ h
2 java 类型, 引用变量 与 堆对象0 G, N' l0 q9 k" \1 h1 t2 I2 r% \7 i
1)Java 类, 是用来描述事物类型的. 如: 书
7 W3 `- k/ G j# |$ z' e% r3 ?2 x <图书馆管理系统>中的概念: 书 Book
- t" G: \) c/ N1 `3 j$ R( s, Q( c 书的特征: 书号, 书名, 编号, 作者, 价格... $ I5 v$ J% R5 W( D! d R
2) 类的声明:
" O n2 B+ f2 {; S# R public class Book{1 f9 f, ^ T, J& ?6 f$ m6 t( Q
long id;
0 r& D- y I( V% C# h9 ?8 T- _ String name;
; _( ~! n3 z+ J String isbn; //书号 ?/ g& e# [% P' F9 Q& D( v2 e1 j- i$ r
String[] authors; //作者' g4 Y9 Z" w# ]' u6 N2 F2 b
double price;
) \: K- q3 q7 a4 q& y0 P) H }- [! K' z5 S( P" m9 H
3) 引用变量与对象的创建过程:
9 U4 a* |5 E* m1 j6 z1 V A Java的内存管理与分配:
0 @( ^1 }# x/ N) R2 G0 f 栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)$ `( W. `, X8 K! n3 w
堆也是一块Java使用内存区域, 使用方式: 无需随机分配
8 J8 W N! e! u3 L8 N" { |; b B 局部变量 与 堆对象空间分配
* e1 D, m4 C. a2 E9 m: y# ?5 Y Java 局部变量在栈中分配, 是按照变量的类型分配 ! y# Y9 c+ z0 [8 ~9 v: _: J0 W- }
对象在堆中分配, 按照类的属性(实例变量)分配空间3 w ^8 C' D g; u
C 变量类型与分配
4 C+ m+ h4 \1 A0 @& T" {8 b& U4 i( v 变量分为: 基本类型和引用类型5 j; m$ {7 ]) J; ]2 K/ f
基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
# e* Z. i& }0 [ 的值7 t$ d1 P7 `8 ?8 i* g& ]% M
引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆6 Q$ {7 o0 x9 O. s( m3 d3 W
对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
- `6 ^( u/ k' [4 A' I k 由Java系统管理: 变量占用空间以及值的管理, 都是透明的. 0 i0 K+ v; @1 I" F
+ b/ E: e- o9 l: D: B 4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
( r4 L( c4 [$ K" D 5) 在null引用上调用属性或方法, 会发生运行时异常# {2 x. n- E) D
) o8 R5 B6 I5 x$ ^
案例:
3 Z* ]: Q* ]( s3 k5 J5 w 平面绘图坐标系中的一个点(Point),定义合理的属性! n6 ~. C2 i" r# X. _: R5 i& \
坐标是int类型.+ L* B5 w$ g) _- U
O+-----------------------------> X
: V4 b2 h# F3 x* R B/ q/ @. D |
2 h8 C" u. T3 Q5 V3 u: Z |: @% B2 l- P' x) X/ Q. x
| }2 }. X0 g' h+ S' O
|
Y6 R; q1 ?+ j+ ?6 { | . p(x,y)
1 o) L) K t5 ]" ~7 Z! a, b/ v0 Q) e4 O |
# p! \& |+ L) r" [3 h5 m |
, E/ A7 v2 j; ?" A |
( q2 _9 l: s' k- h |4 w; x: h% U9 T
' G: }; v* j8 _( K2 X' L! a Y
$ C c, O" v5 d' ~9 l) d
; Z1 ^$ G2 B5 b# \" Z0 ]8 v2 l- f" r3 构造器(构造方法) 的作用: 用来描述对象的创建过程的. s/ {8 }# r; j! ]
1)
1 O0 ~. k1 ~9 I! ~7 T& h; L+ T 如: 月饼实例的创建, 使用面和馅创建.$ k7 L ~: k8 E* v
制作(构造器)( o7 @, ]* r9 ^/ U; ]( z
月饼模子(类) -----> 月饼(对象)* f3 a& B5 l+ @1 {+ ~- Z& z
原料(构建参数)# u) R# }+ B* a. `
; x6 _' F2 J$ C1 n; o+ Z! l; C 点类型 --------> 原点 4 f% K# w9 _; F+ B: X
坐标(1,2)
) P: V* s: K5 T
8 c+ f7 z5 l% c 2) Java中的构造器: 声明在类内部, 方法名与类名一致; C# z$ k$ T, p. z3 R
的方法叫构造方法, 构造方法不能声明返回值类型.+ l% R" ]* M/ ^' r9 W6 J% [3 A
构造方法可以包含参数, 参数一般是创建对象实例* M: x" O5 s3 [' K$ u
必须依赖的条件(前提条件).( s" R# _+ O5 ?
public class Point { J+ ]; E: }7 T0 y7 t4 i- ~& {
int x;
8 G) @9 R/ n' B7 Y int y;
5 P# Y8 b) Y& s1 H- u3 z0 M: [( d /** 构造器 */
& ], _ D7 S% q. E( u public Point(int x, int y){6 `2 G( o0 H8 I! x0 ?# Q# [
this.x = x;1 Z1 x- C \8 D5 X3 u, n/ C9 ?
this.y = y;
; {" }% v& U. g* l( O1 y0 c( F }
6 t0 H. N( @2 f }
2 V( j$ C i4 z8 j# K0 Y& F1 w3 e, N
" r9 O* r9 E! [ 3) 对象实例化过程:
x0 R, O& Q# W new运算: 创建对象实例* G( B7 g8 A& t
1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量9 S2 a4 X5 s( Y2 b3 Z& H q5 A
2 根据参数类型调用构造器. 3 x7 ]4 S& a# T
3 new运算返回对象的引用地址.
, d# C. D( o+ m6 Q
5 W! {' r# R) a8 h$ k* c7 i 4) this 关键字
k3 W8 p, E% ~8 ~( A this 是对当前对象的引用, 是运行期间当前对象本身.! L6 ~5 y* S- t7 [% W
可以使用this明确的访问当前对象的属性或者方法/ r' Q, K" K1 Y$ ]. y; n
类似于"我".0 N, _, N) {; J+ w
this() 是调用本类的其他构造器, 可以使用构造器的重用, ' P) h* w3 Q, M9 e( Q1 B
简化代码的实现. ! j0 j1 I* _# s2 V& S; _" @
* this() 必须写在构造器的第一行!
4 B4 A, S% u4 w4 f5 y& O; U/ G; G) b3 Q0 w
5) 构造方法重载: 参数不一样的构造器1 ?% B! N( n; } g3 B
案例: Point.java
+ O% z' C: c; M 方法签名 = 方法名+参数类型列表
/ T' p: ?, O5 x% s 方法重载:a 方法名一样 b 方法参数不一样4 ~0 g/ ]/ i1 W7 G' ?
也可以说: 方法名一样, 方法签名不同的方法
0 {; E/ R/ A q
3 n' b: R7 u! D 6) 默认构造器
) U; D, q! E0 y! M6 g! r 1 java 类一定有构造器
% i4 T) R6 _1 F; | S! [2 i6 t 案例: ConstructorDemo.java) `+ d5 v* |3 f7 x: H+ h& ^* o6 p
2 如果类没有声明任何构造器,Javac自动提供一个
5 Z' ]2 K+ \: B; o) ^1 ^, v+ _9 s 默认构造器, 无参数默认构造器
`3 w& N3 G' p 3 如果提供构造器声明, Javac将不再提供默认构! O: ?8 B' l7 T4 w/ K6 o9 `
造器.
' H3 Y8 l; [- O2 c1 f6 K8 \5 ?1 v
4 @& {9 b3 ~/ y- y8 P8 Q4 对象的方法
, h- r- ~3 L3 M7 f2 `3 K: C 1) 表示对象的功能, 依赖于对象存在.. t# A: E7 A# }: v$ `# L
案例: Point.java
% A; Y1 p% N% o* [ N. M 如: p1.distance() 和 p2.distance()
/ `% B( j, q5 r9 V- Y 方法是动作,是功能,一般用动词声明. * p. g$ r, J( b. k6 z! |. @
2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
0 `) X. A) y! P2 G2 Y8 j 功能的多态.重载的方法经常互相重用.& ]3 _* G, Z- W
) r& E; {0 n; I' E/ {$ T& f
对象: java运行期在堆(内存空间)中分配, 大小按照属性分配6 {/ C- b3 G# G4 [
引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配( _& E- O8 l9 E" ~5 ~
实例变量(对象属性)对堆对象中分配(如: 书的名字). C, @5 T }7 L
引用变量的值是地址值(透明管理,不可见), 通过这个地址1 {, p0 X) ~$ G5 ~6 O
值引用了一个堆对象.; h2 C2 g/ \8 L, W
6 @' g9 `! L1 D% V: ? 不确切说法: 引用的值是对象% p: H% w3 |0 t p `- t$ \8 X' ~
引用变量在栈中分配. x6 S& ^9 z1 {0 C* ?) J1 A
类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了) L1 `2 Q e( F. y m
对象的样子.
( Y5 {9 s' x8 W0 I& G7 {& ~/ `5 }
: @- L7 W: e) R: U0 W% { m 想着对象写类型: 面向对象, 类是对象的抽象化
- M& r5 S) Q# k
- w1 t) x" t+ E) y 方法的重载: 体现了行为的多态现象
" n7 u5 \) {2 J7 A, d/ \. U) i, s9 Y) s" S" m% O
|
|