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

汪星人

1 面向对象(OO)
1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
2) 面向对象, 面向客观事物之间的关系.
$ t) b1 r: @5 ~2 b 4) OOA面向对象分析/OOD 面向对象设计
! L3 t1 D* }: u( n' E6 S: `   客人来了(来了一个客人类型的某人)

  H- _) E  M. n& L 5) 面向对象概念
  A 类型: 名词概念, 如: 客人, 菜品, 厨师
# r, a- o5 ^2 U7 s  B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
) t+ y9 J" K$ o/ U: G0 M  C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
! U# m9 L8 s# t0 a9 f4 }5 o" U; F  D 行为(方法)
  基本特征:
/ [, ?  F: W: S3 w* w  W+ `: C/ n  A 多态: 行为/引用, 在具体情形下发生了变化的现象
          一盏灯:  多态的
  S* t* R* W9 K: u9 c          打: 根据宾语发生变化
) f# [+ T# m, B% O  B 封装: 任何对象实例都是尽可能封装, 减少暴露
  C 继承: 概念的继承关系

2 java 类型, 引用变量 与 堆对象
1)Java 类, 是用来描述事物类型的. 如: 书
   <图书馆管理系统>中的概念: 书 Book
  书的特征: 书号, 书名, 编号, 作者, 价格...  
: F: a1 `$ L2 \0 @: } 2) 类的声明:
1 x5 h! G9 Y4 o3 T: C6 `    public class Book{
            long id;
6 Y0 K; @- f( \) U            String name;
            String isbn; //书号
            String[] authors; //作者
+ t& y" ]0 R8 A' K            double price;
    }
3) 引用变量与对象的创建过程:
; b. Q& d9 f; ?7 C7 x/ q* N/ @; h  A Java的内存管理与分配:
$ {5 G2 N) H1 w* D    栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
    堆也是一块Java使用内存区域, 使用方式: 无需随机分配
/ Y; L$ y& m* }+ b; ]. Y  B 局部变量 与 堆对象空间分配
% M" T! z4 O( Y. A( _9 a6 C   Java 局部变量在栈中分配, 是按照变量的类型分配
   对象在堆中分配, 按照类的属性(实例变量)分配空间
  C 变量类型与分配
   变量分为: 基本类型和引用类型
   基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
    的值
' m6 d% A5 |8 \5 g$ Y5 D: ^   引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
. W8 G0 ~: \3 o   对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
   由Java系统管理: 变量占用空间以及值的管理, 都是透明的.
# b& Q/ g; k9 I$ ~: H1 t5 F3 R
4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
6 X9 g; n  u/ B# F, K/ t 5) 在null引用上调用属性或方法, 会发生运行时异常

+ [  m! i! T; x! K, a" U+ ~ 案例:
- Y: N/ [+ i' U. W  平面绘图坐标系中的一个点(Point),定义合理的属性
  坐标是int类型.
   O+-----------------------------> X
6 p" ?9 i- u- ]0 ?1 `9 y) z    |
    |
4 ~0 ~  u  R  J0 U; q$ g5 X' E    |
    |
) z3 O5 `# r- t, C' \! A    |          . p(x,y)
8 S" d/ W$ C1 F" d: Y5 r    |
2 ?" L) K4 P4 n, Z4 f: T" `    |
    |
    |
- I& U' l; i4 x4 H+ b: B+ y! P
    Y
% s. a& J4 R, R. k: U& t" E5 u  B
1 ?% z. v) n4 D: e7 J1 i, @* {3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
( F; @- N; J" R# D' @  1)
0 L6 q- Q, H7 v& ]  w% j  如: 月饼实例的创建, 使用面和馅创建.
              制作(构造器)
$ `2 N% X* I0 T; \% |  月饼模子(类)  -----> 月饼(对象)
              原料(构建参数)

, f8 I' I- L! Z+ N  点类型   -------->  原点
           坐标(1,2)

2) Java中的构造器: 声明在类内部, 方法名与类名一致
  的方法叫构造方法, 构造方法不能声明返回值类型.
  c1 J. x* p; s1 A4 b3 h  构造方法可以包含参数, 参数一般是创建对象实例
6 u" k& I5 F3 T/ t  必须依赖的条件(前提条件).
: M9 T& \3 t2 J3 L        public class Point {
4 R7 u; G/ i& X7 A/ \5 c$ I          int x;
. V% x7 ~  q* s% d  q- |          int y;
, p3 @1 \5 d$ f9 u          /** 构造器 */
          public Point(int x, int y){
            this.x = x;
            this.y = y;
          }
        }

3) 对象实例化过程:
  I9 D3 F9 U- y. w4 w new运算: 创建对象实例
( a. ~9 l2 N& J# G  A4 J0 w" J5 N* _5 E  1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
! y1 M0 d1 P3 P" d4 x  2 根据参数类型调用构造器.
  3 new运算返回对象的引用地址.

7 X7 U1 A  x# R 4) this 关键字
# }5 i! Z( R2 `' G4 n7 r/ L& s  this 是对当前对象的引用, 是运行期间当前对象本身.
+ B" G/ G' ~' e# q3 S          可以使用this明确的访问当前对象的属性或者方法
          类似于"我".
0 Q5 E9 v! [+ S; \  this() 是调用本类的其他构造器, 可以使用构造器的重用,
. H% Q7 t3 d# `- S    简化代码的实现.
& C5 m6 s/ A# ^. O3 X/ x  * this() 必须写在构造器的第一行!

5) 构造方法重载: 参数不一样的构造器
        案例: Point.java
   方法签名 = 方法名+参数类型列表
8 ~. ~0 V( J. N' Q2 F   方法重载:a 方法名一样 b 方法参数不一样
- O6 t4 }1 G- S* A     也可以说: 方法名一样, 方法签名不同的方法
5 _" U+ R: a, l
# ^* S0 _" D& O! S- C1 @9 P! v 6) 默认构造器
  1 java 类一定有构造器
  案例: ConstructorDemo.java
0 X6 ~3 [" g& I8 _( c# I+ m$ j  2 如果类没有声明任何构造器,Javac自动提供一个
+ y8 ?! q9 A- v: V  |  默认构造器, 无参数默认构造器
1 I* G0 T& d/ s4 e9 Y& r) b  3 如果提供构造器声明, Javac将不再提供默认构
  造器.   

( K0 d0 l+ t  s0 z8 v4 对象的方法
. ~6 G: g* ?( L0 m 1) 表示对象的功能, 依赖于对象存在.
" X3 [( h8 `) U: x  案例: Point.java
  如: p1.distance() 和 p2.distance()
  方法是动作,是功能,一般用动词声明.  
2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
   功能的多态.重载的方法经常互相重用.
" R9 B' X. r, i% v" o. \
  对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
  引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
4 k0 b( ~- J7 o# W% T) H+ K                实例变量(对象属性)对堆对象中分配(如: 书的名字)
                引用变量的值是地址值(透明管理,不可见), 通过这个地址
                值引用了一个堆对象.
' G. m0 ?9 g; R3 _+ m- m3 h
  不确切说法: 引用的值是对象
. d7 r4 h% ]" ^9 F* z            引用变量在栈中分配
  类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
                对象的样子.

  想着对象写类型: 面向对象, 类是对象的抽象化
, e9 v+ F9 l  `: a6 b- ]/ G3 E* i
  方法的重载: 体现了行为的多态现象
8 I# K. g4 Z5 p0 J- e$ T
2 |9 @/ M) @1 ?) `- L

发光的影子

看了看  学习学习  哈哈哈哈

java宫城大师

学习一下。谢谢

woniu

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

wudizxt

不错不错不错不错