java 面向对象知识: 类, 对象, 引用

汪星人

1 面向对象(OO)
; C& T; f- Z7 W) _8 x 1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
& N8 E' |, T# E 2) 面向对象, 面向客观事物之间的关系.
* d/ f# [3 H, |* ^  c 4) OOA面向对象分析/OOD 面向对象设计
   客人来了(来了一个客人类型的某人)
7 z. x0 L" d6 H% M8 f
& M9 L) d8 w4 ]( _& ?8 s1 i 5) 面向对象概念
  A 类型: 名词概念, 如: 客人, 菜品, 厨师
# g( F2 h2 j# u$ m% a' r  B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
  C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
  D 行为(方法)
  基本特征:
( B* ^* v. J5 V% b5 I  A 多态: 行为/引用, 在具体情形下发生了变化的现象
          一盏灯:  多态的
          打: 根据宾语发生变化
8 F. g6 W! v* m" {! q- r! M# _' r  B 封装: 任何对象实例都是尽可能封装, 减少暴露
  C 继承: 概念的继承关系
/ \( N0 ~8 V) I7 p2 e$ q
1 T* d; A/ ]3 F. P0 m2 java 类型, 引用变量 与 堆对象
1)Java 类, 是用来描述事物类型的. 如: 书
   <图书馆管理系统>中的概念: 书 Book
% \3 X* V9 ?; ?% X  书的特征: 书号, 书名, 编号, 作者, 价格...  
/ w9 \* [8 ~6 F( d 2) 类的声明:
    public class Book{
' G8 H, t8 s0 m( L* n$ \) E; P            long id;
9 g4 j: j: L  o- |            String name;
8 d! d; c9 e" N, D; C, c            String isbn; //书号
2 o- F8 o, W/ C  j! D3 A            String[] authors; //作者
. W7 }9 X9 B8 z5 j* Z- o            double price;
  [/ k- {) g7 n: N) `$ r; B4 i    }
8 x' r6 _8 D2 Y" K. ~ 3) 引用变量与对象的创建过程:
+ n0 {( V8 O. l& @3 i- T  A Java的内存管理与分配:
    栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
' ?! [# ?2 U* ]8 S    堆也是一块Java使用内存区域, 使用方式: 无需随机分配
/ k: c  A6 {( G$ o! G# L, I0 E  B 局部变量 与 堆对象空间分配
- f: s8 k: z; U5 T3 l4 v8 n   Java 局部变量在栈中分配, 是按照变量的类型分配
% \! T8 e$ b/ T2 a3 q   对象在堆中分配, 按照类的属性(实例变量)分配空间
, T4 X1 O+ ?+ l9 T. Q" b4 x  C 变量类型与分配
7 M, F1 C8 P/ e5 K5 I   变量分为: 基本类型和引用类型
: Q. L- ^' H+ s, w   基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
' w  F; a( ]: e4 u    的值
   引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
& d3 E$ E' `/ V8 Q6 S   对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
   由Java系统管理: 变量占用空间以及值的管理, 都是透明的.
' O4 O6 L4 J* B% a+ J; U
4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
5) 在null引用上调用属性或方法, 会发生运行时异常
" k0 v  `- E: m) _1 X
案例:
  平面绘图坐标系中的一个点(Point),定义合理的属性
  坐标是int类型.
   O+-----------------------------> X
    |
    |
; P$ ^# n& L6 {    |
    |
    |          . p(x,y)
: m0 o7 e, q" a, p9 C    |
0 l! ~+ y; ~, ~6 y    |
    |
! F' r8 z  P0 @    |
2 d/ E$ r7 `& f" B; A
  m5 v" l: s4 @& G- ]. U/ ?2 v    Y

. a0 t* t7 d. H& `3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
  1)
' \$ y; N$ v; F2 T  如: 月饼实例的创建, 使用面和馅创建.
) c- k: D& z. y/ h              制作(构造器)
. S$ A% h' Q2 i; T) S  p- i; v  月饼模子(类)  -----> 月饼(对象)
" D3 z" R# b% B3 N+ N6 t; B. t              原料(构建参数)

/ ^- G6 f1 S3 _7 M: P7 l$ K1 U; M  点类型   -------->  原点
           坐标(1,2)
# Y: a+ p6 s7 f$ p! I
$ k- |- r  P: r' T 2) Java中的构造器: 声明在类内部, 方法名与类名一致
  的方法叫构造方法, 构造方法不能声明返回值类型.
  构造方法可以包含参数, 参数一般是创建对象实例
0 Z# J. l+ |# E  H8 B: p& h" w- C2 E/ A+ L  必须依赖的条件(前提条件).
  F0 n7 N2 F3 ?2 X  ~        public class Point {
          int x;
; E- a6 O; y9 T' q1 P7 P2 X- e          int y;
& _% A, k$ K  S$ Y          /** 构造器 */
$ I0 K5 q- _6 o          public Point(int x, int y){
* Q# y, T: i. U6 }7 l            this.x = x;
            this.y = y;
          }
        }

3) 对象实例化过程:
7 M: ]# K' z# g$ R$ o( V1 E! X new运算: 创建对象实例
: s. q7 D! Z- y# Q' O  1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
  2 根据参数类型调用构造器.
  3 new运算返回对象的引用地址.
# `7 U! f. Y5 Q1 m" U( ]
' N& b4 y0 g+ U. ? 4) this 关键字
% x3 Z! b+ C# e& \6 g+ s  this 是对当前对象的引用, 是运行期间当前对象本身.
3 v- h6 y. |) [- p4 S5 p          可以使用this明确的访问当前对象的属性或者方法
3 Q) Q1 t% A+ G) L: S0 F) n          类似于"我".
. Z6 v% w) g0 h& }( E  this() 是调用本类的其他构造器, 可以使用构造器的重用,
5 {* q* R9 ?, M% j/ R% N    简化代码的实现.
2 r. j# j; ^8 w% D" k: [1 g  * this() 必须写在构造器的第一行!

5) 构造方法重载: 参数不一样的构造器
        案例: Point.java
) B/ [. O( b: f" q) k   方法签名 = 方法名+参数类型列表
5 ~3 g8 b) j# o# p" m: D5 I   方法重载:a 方法名一样 b 方法参数不一样
$ T+ }1 X+ M7 H* B3 y     也可以说: 方法名一样, 方法签名不同的方法
/ ]( w$ K0 C+ }  Q" ?5 g# Q
6) 默认构造器
  1 java 类一定有构造器
. K; n0 J3 \+ c( Y  案例: ConstructorDemo.java
, D, p* p5 i% x" m7 e5 w9 S  2 如果类没有声明任何构造器,Javac自动提供一个
1 C1 @7 z: K6 R1 c1 y5 r6 {  默认构造器, 无参数默认构造器
1 i0 l7 B1 i9 Z  `/ e  3 如果提供构造器声明, Javac将不再提供默认构
  造器.   
* o" S6 P6 q& Z2 x. _' u& n
4 对象的方法
1) 表示对象的功能, 依赖于对象存在.
! S6 N) N5 X4 \& ?5 ^$ \5 y& s% c  案例: Point.java
: l- e# R* B6 i- Q9 g3 g  如: p1.distance() 和 p2.distance()
  方法是动作,是功能,一般用动词声明.  
2 U' N; d0 p2 r3 W! a- Q/ i 2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
   功能的多态.重载的方法经常互相重用.

  对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
& \* i0 ^) }. o' v! W  引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
# O; G" T4 a9 C7 i# b3 l" ^+ j) z                实例变量(对象属性)对堆对象中分配(如: 书的名字)
                引用变量的值是地址值(透明管理,不可见), 通过这个地址
% b6 u7 V; B" A- T* c% F4 u* a                值引用了一个堆对象.
5 k& j8 {$ n" E! t4 p
  不确切说法: 引用的值是对象
            引用变量在栈中分配
& \6 t* k1 I0 I  类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
                对象的样子.
$ K' E# |2 M" E7 F; k
5 Y8 ~* ]% u9 M5 E3 \; e  想着对象写类型: 面向对象, 类是对象的抽象化

' u# o8 I! c2 a7 F+ \6 R* i  方法的重载: 体现了行为的多态现象
9 @: t2 o3 L0 G  z

发光的影子

看了看  学习学习  哈哈哈哈

java宫城大师

学习一下。谢谢

woniu

这个项目太棒勒！下下来学习下！

wudizxt

不错不错不错不错