该用户从未签到
|
1 面向对象(OO) / M6 X$ i; x# \0 \1 h6 M% K
1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例# `8 E6 m( M8 ?0 n* W
2) 面向对象, 面向客观事物之间的关系.
, n, F3 n9 Q; Z; G0 b% m6 a! b' E 4) OOA面向对象分析/OOD 面向对象设计
1 e' v, |4 _4 z 客人来了(来了一个客人类型的某人)9 T' k( [5 q o
3 K6 A8 O# s6 C) p8 l: D; w
5) 面向对象概念% S0 E3 S3 b) L
A 类型: 名词概念, 如: 客人, 菜品, 厨师( e: p: V0 C$ c9 h# i- ]! p
B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜2 Y7 S/ N0 j& d- a% |
C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡7 |0 m0 q) H3 R& j/ c/ E! H# P
D 行为(方法)
E' Y' N( f9 `+ [/ _6 N 基本特征:0 F7 W2 R) y9 R4 a4 D" m- w
A 多态: 行为/引用, 在具体情形下发生了变化的现象$ r- U3 B b# Q* l& r
一盏灯: 多态的
* N6 `3 [6 p& m* r+ s" K. I 打: 根据宾语发生变化
# f5 L, f% t9 `) t: D' A0 o2 } B 封装: 任何对象实例都是尽可能封装, 减少暴露7 k/ _; X+ a8 J) `
C 继承: 概念的继承关系
& w4 W K8 u7 y$ \8 o3 H. D7 U, j! {) [5 g
2 java 类型, 引用变量 与 堆对象
* M- D$ k+ ^$ m j/ F 1)Java 类, 是用来描述事物类型的. 如: 书) R, @( _; r- a6 I, I
<图书馆管理系统>中的概念: 书 Book
8 \. ?! u7 z& s0 `) P4 t 书的特征: 书号, 书名, 编号, 作者, 价格... 6 K7 f2 I9 b5 J0 O* d# S
2) 类的声明:- O- m; E& R% |! J$ @# ]6 h1 L
public class Book{& p1 e5 k2 Y8 d* y
long id;
$ m/ O3 t4 }$ K2 n! ?+ z1 ` String name;
8 r# [/ S' W9 k& N! N- l& p* T String isbn; //书号* o6 U8 V/ \* e2 _5 F; J
String[] authors; //作者7 j& C) @: e: l$ z: t, M) @
double price;( `- ~3 j/ z- u% E
}
R4 P% D3 C" ?, L 3) 引用变量与对象的创建过程:! s: y# J) h# T) P( j
A Java的内存管理与分配:: j4 l3 v F& G7 d5 L% Y) K
栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)$ p _$ m p9 E! ]2 Z$ Y
堆也是一块Java使用内存区域, 使用方式: 无需随机分配
) W l; t% m) P- E B 局部变量 与 堆对象空间分配
y K2 A# @4 m" W' ?. p) l R7 r5 k Java 局部变量在栈中分配, 是按照变量的类型分配
0 b% m9 G( K$ d4 U 对象在堆中分配, 按照类的属性(实例变量)分配空间
. R3 ]% z% X3 B+ A! X5 z C 变量类型与分配/ l: H5 n2 k- B$ v3 B
变量分为: 基本类型和引用类型" s7 y- N4 [: v( W' V% X7 ^
基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型- \1 [, p. `4 |9 C) T, W5 w; c
的值
. D5 c4 \$ B/ ^) }6 j2 ^ 引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
2 F" x- s) b5 J) H& Z 对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",5 {9 @5 i$ P& G4 ?# T6 ^
由Java系统管理: 变量占用空间以及值的管理, 都是透明的. 6 W% N& @9 x/ b* n7 _
% ?" U' A% n7 l 4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
9 w; V% h( Q1 X7 G- d' M 5) 在null引用上调用属性或方法, 会发生运行时异常4 w* X) ?: M3 M1 e% v& r/ M& q2 _
% t- g" y; L8 \4 B 案例:
* ^; ? V% Q- D2 T- n- C 平面绘图坐标系中的一个点(Point),定义合理的属性
$ S4 Z7 C* m: R5 A0 Z4 T8 d; J4 E/ N 坐标是int类型.
1 w; X1 b0 I- P2 T O+-----------------------------> X: c5 V% |9 q4 a' Q
|
: i6 Z$ `! m! \ |
0 O# {5 Y% u5 D* S |1 f* s0 l: q! C9 a
|
* m; O; e3 Y+ [( o2 g, n. u- O | . p(x,y)
+ q6 {! }7 x) r: R, B! L |0 D7 h2 d9 `+ c) e7 z
|
5 e ?1 l. B: [% l: x0 l6 d |( N9 Z, Z6 X2 E0 s5 C
|
) d' R. O, }1 R8 X! a" P. [; X5 Z- j* x P6 i* Q7 V
Y3 g* g* I+ E' _, M3 h7 M
, A" C \7 j# O, M2 [( B3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
) i% S( e1 @& e# w, p3 j 1)
/ c/ V7 D+ v" W$ B 如: 月饼实例的创建, 使用面和馅创建.' {/ r, t2 V2 d
制作(构造器)
( V1 P3 D4 p" W2 @5 Z, k4 U u 月饼模子(类) -----> 月饼(对象), @. }3 @( Z5 ?' v
原料(构建参数)
' G5 \5 O5 v7 M! `( G* L
, A% {3 e* ^: F( \ 点类型 --------> 原点 5 _0 G! |/ a* J' x
坐标(1,2)
' T" r1 [3 @ _* {( | s$ }' n& X* Y8 [6 ?9 w7 C2 L
2) Java中的构造器: 声明在类内部, 方法名与类名一致
A7 M) E8 C: \6 @% p: u4 e 的方法叫构造方法, 构造方法不能声明返回值类型.8 d0 Y$ w' `- }3 f# s
构造方法可以包含参数, 参数一般是创建对象实例( n! z" N$ L/ x; Y/ Y
必须依赖的条件(前提条件).& v3 W" R) r" v9 ]1 _
public class Point {
& [8 V8 ^$ x0 k7 E; O int x;
n a% u, d7 Z+ E/ j int y;
# N. B0 ~& w' R' W# y$ X /** 构造器 */8 ~5 [$ K. F8 k4 n0 m Y
public Point(int x, int y){& n* u2 n. |! @
this.x = x;
' P# D9 j$ z5 R' Z this.y = y;
\% L/ m/ U7 |! J9 m. P/ z7 s }( O& A1 u0 p9 G B% U$ n
}
+ `8 k0 @; z$ [3 g% G& I2 `0 J. s8 _" _; G4 I: h
3) 对象实例化过程:
3 O; t$ ~8 V: D! D+ U, d) G new运算: 创建对象实例
+ a6 u) Q3 l, Q: r, U6 K8 T 1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
: L7 @/ w N' i 2 根据参数类型调用构造器. 4 }2 m! c# D1 m/ J* Y8 D
3 new运算返回对象的引用地址.
+ B9 G# `: A% M8 A6 ]
, ], G+ o7 T0 E9 c 4) this 关键字
- { \; z% j3 S) |: w this 是对当前对象的引用, 是运行期间当前对象本身.( z+ X: V! x( q
可以使用this明确的访问当前对象的属性或者方法
$ }/ V) B' p$ K: \* ^9 X+ q# z 类似于"我".1 _3 a' L! c+ E( Q
this() 是调用本类的其他构造器, 可以使用构造器的重用,
4 l; C+ \! P0 d U" S( q. W( w& m 简化代码的实现. % `7 K8 {4 `/ \# C* c4 e
* this() 必须写在构造器的第一行!
2 ]& @1 F+ q4 m2 N9 ^* V, c h" E
+ d$ O% O: u% L& a* N 5) 构造方法重载: 参数不一样的构造器7 D" a; a# s4 A. k
案例: Point.java8 k- S+ `+ G0 f9 J0 k+ t/ K
方法签名 = 方法名+参数类型列表9 M1 {8 n+ a8 u
方法重载:a 方法名一样 b 方法参数不一样0 p2 N# i7 h2 s( G( s, O$ b
也可以说: 方法名一样, 方法签名不同的方法6 z4 }$ f$ w# H% ^/ X: F
4 O8 }. @/ L& o9 } 6) 默认构造器* p' x; r$ a( }& z: _
1 java 类一定有构造器- q1 {0 P8 e* ]* j0 q2 G0 n; k+ P
案例: ConstructorDemo.java
6 \2 ~# D" S" r+ `9 \8 { 2 如果类没有声明任何构造器,Javac自动提供一个
T8 z8 D) h8 |+ D* B! u 默认构造器, 无参数默认构造器0 n# f8 I5 {( ]" z
3 如果提供构造器声明, Javac将不再提供默认构
: T! q( a/ c* b; c 造器. 9 N/ ^/ X9 j2 p6 s# ?. L5 b9 x( c) f# [
5 N: H3 t, ]9 p% B
4 对象的方法
9 n2 E: H: U- |8 i6 | 1) 表示对象的功能, 依赖于对象存在.
( g0 u% R0 \; N+ D: E( d 案例: Point.java
A$ N% ^. m9 ?* U0 I: g+ r 如: p1.distance() 和 p2.distance()( K& @: w: J. n4 K, R6 U
方法是动作,是功能,一般用动词声明.
w1 ^+ F- G7 ^0 L% `% [5 u 2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
5 \2 g6 H( H$ s' Q- S) ^( y! F( x 功能的多态.重载的方法经常互相重用.& [) M. f; A: \7 ^4 W. Q" ~* r2 d( U
3 v9 n1 u8 f- V F' P
对象: java运行期在堆(内存空间)中分配, 大小按照属性分配" u! H2 m3 ^8 Q- Z4 ?0 b7 @6 g
引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
: W- a& H6 j) F: Y8 m) K# }. q0 U0 a0 m 实例变量(对象属性)对堆对象中分配(如: 书的名字)4 i% ?" i$ m! u% t/ C* r
引用变量的值是地址值(透明管理,不可见), 通过这个地址# G% N* C; D1 t1 u0 [& c" r) W9 }
值引用了一个堆对象.
0 ^) w+ c5 k! T4 ]" o# k
( y; s! K7 ^/ k& i 不确切说法: 引用的值是对象( `3 q6 j0 E8 k4 C
引用变量在栈中分配; ^( I4 ^+ j( |) p5 }
类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
* H2 [3 A( Z6 ]8 a; K 对象的样子.4 r' ~# O+ Z" m _- M6 E
7 ^4 y* ]1 ?1 a) { 想着对象写类型: 面向对象, 类是对象的抽象化
- k9 i8 K7 `! c0 {( A0 G: X# ~; t
* N* O6 w" [8 V" Q 方法的重载: 体现了行为的多态现象8 `) h6 f) |0 w3 X6 K4 x3 c
$ H7 x- D# S2 ~* \
|
|