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

汪星人

1 面向对象(OO)
- O: W0 @7 M+ ^7 x 1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
7 i. ?  A# W& H* F+ S( k 2) 面向对象, 面向客观事物之间的关系.
4) OOA面向对象分析/OOD 面向对象设计
   客人来了(来了一个客人类型的某人)

5) 面向对象概念
! L% n( y% |$ Y- h  A 类型: 名词概念, 如: 客人, 菜品, 厨师
  B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
  C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
  D 行为(方法)
7 ], i! k2 H* ]2 O. z  基本特征:
  A 多态: 行为/引用, 在具体情形下发生了变化的现象
6 K0 M$ C  F9 k" a2 w" W8 _          一盏灯:  多态的
          打: 根据宾语发生变化
' r$ w- K; Y  T  B 封装: 任何对象实例都是尽可能封装, 减少暴露
  C 继承: 概念的继承关系
; L! N5 ]9 K- w. f) d0 D( X
5 d, M2 h4 D! e/ X2 java 类型, 引用变量 与 堆对象
2 f9 ?) {7 M5 z( S 1)Java 类, 是用来描述事物类型的. 如: 书
   <图书馆管理系统>中的概念: 书 Book
, S; p) D* i+ n7 [# \7 f. _  书的特征: 书号, 书名, 编号, 作者, 价格...  
2) 类的声明:
    public class Book{
            long id;
            String name;
            String isbn; //书号
            String[] authors; //作者
            double price;
    }
) G* p( G# C% s5 W& E( V! h 3) 引用变量与对象的创建过程:
4 |! Y9 K& z% Q: G  A Java的内存管理与分配:
    栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
' d% r, s0 e: N  l! ]    堆也是一块Java使用内存区域, 使用方式: 无需随机分配
  B 局部变量 与 堆对象空间分配
. t$ t* J9 T) Y; o   Java 局部变量在栈中分配, 是按照变量的类型分配
   对象在堆中分配, 按照类的属性(实例变量)分配空间
  C 变量类型与分配
& K/ L( \6 e* }. G) z   变量分为: 基本类型和引用类型
: m' s3 t* k% T$ Y' L1 v. ]   基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
6 b* k3 z/ D7 }/ m/ F* x    的值
   引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
   对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
" Q3 Y$ H) {; M   由Java系统管理: 变量占用空间以及值的管理, 都是透明的.
: i5 p. E. Z( I- I1 E; y- h! Q3 K
$ [3 F. t" }) I8 v 4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
) J7 {6 o4 f! B& x 5) 在null引用上调用属性或方法, 会发生运行时异常

- N- l# o0 W% u 案例:
1 o) U/ E6 O5 u5 q2 f, R/ F  平面绘图坐标系中的一个点(Point),定义合理的属性
  坐标是int类型.
   O+-----------------------------> X
    |
% j/ S- ?" l- @, @" Y* Z# S    |
    |
    |
* c. M, h2 S; s) L: c4 o6 `    |          . p(x,y)
9 @: ?/ Y4 z' P! {5 l/ x: d/ H    |
' q8 ^) l) n* s/ V4 G    |
    |
    |

    Y

3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
+ g' ^5 P3 c3 Q) R  1)
- c; Z( s3 ~) D* H; ^  如: 月饼实例的创建, 使用面和馅创建.
6 q4 ^. {+ X6 J! R              制作(构造器)
  月饼模子(类)  -----> 月饼(对象)
: N8 e2 }+ L6 W# R" k              原料(构建参数)

3 v* v5 H  h/ D+ K( w  点类型   -------->  原点
3 G/ u# v" N$ i9 e4 W: I7 [2 I           坐标(1,2)

: @% @9 v! f3 Q 2) Java中的构造器: 声明在类内部, 方法名与类名一致
( T( b: {* ], h; Z) Q" ]! u  的方法叫构造方法, 构造方法不能声明返回值类型.
& R) T6 I& O- {# U0 f  构造方法可以包含参数, 参数一般是创建对象实例
8 o1 G8 T$ i: |0 O2 \% }! G1 w  必须依赖的条件(前提条件).
        public class Point {
          int x;
+ J3 g, {/ v9 n; r" P          int y;
          /** 构造器 */
' z5 A1 ?" c6 K# Y$ v+ E+ n          public Point(int x, int y){
            this.x = x;
" l2 h# `+ V9 \            this.y = y;
3 V) W" g* s4 |8 h+ _          }
        }

/ Y! \! {$ R" g 3) 对象实例化过程:
' F" S% [$ A: T, }  ~, Y7 P3 ~ new运算: 创建对象实例
  1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
* L7 F  t, X, T9 Y  2 根据参数类型调用构造器.
  b* T7 s4 z2 f# e$ U0 x  3 new运算返回对象的引用地址.

4) this 关键字
7 f: ^1 I) U/ Z1 h2 ~# N$ c  this 是对当前对象的引用, 是运行期间当前对象本身.
          可以使用this明确的访问当前对象的属性或者方法
; c1 d, x' I  E* X+ |) E& O          类似于"我".
0 B1 P2 k  l9 V7 B0 k9 f  this() 是调用本类的其他构造器, 可以使用构造器的重用,
    简化代码的实现.
* n/ N& n% U: S- ~2 W  * this() 必须写在构造器的第一行!
% @3 r3 J* z! M4 Y: k7 V# v0 H6 }$ g
5) 构造方法重载: 参数不一样的构造器
        案例: Point.java
9 K9 a0 s+ {+ H9 U1 M; r0 Y3 f/ j   方法签名 = 方法名+参数类型列表
   方法重载:a 方法名一样 b 方法参数不一样
9 c  [( ~  i) `/ ~( L     也可以说: 方法名一样, 方法签名不同的方法
( s, w$ {$ C' }/ T4 l! u7 V9 e9 @
# N' b, F3 J% ?. s" u 6) 默认构造器
  1 java 类一定有构造器
  案例: ConstructorDemo.java
2 L9 t' z$ t9 R: P; j, S  2 如果类没有声明任何构造器,Javac自动提供一个
& v/ {! t( T& ^( l8 ^8 A% S! {3 V1 s  默认构造器, 无参数默认构造器
6 N: [4 n& [1 G1 f* r2 D  3 如果提供构造器声明, Javac将不再提供默认构
  造器.   
# K. m4 l) A( v5 P" V. L
3 R) g/ g1 V* \! p* B4 对象的方法
1) 表示对象的功能, 依赖于对象存在.
( h! J* }! k0 t' W1 _  案例: Point.java
  如: p1.distance() 和 p2.distance()
7 C. p0 x2 U; S/ v2 p  方法是动作,是功能,一般用动词声明.  
' [& n; ~3 K# o; H1 C- K 2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
& L0 d1 y! S2 `1 d1 K1 `* S   功能的多态.重载的方法经常互相重用.
9 w  J: d7 ]2 X3 M6 B
  对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
4 {5 x, S( ~1 k) s, v% @' j  引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
/ n% t/ \( ?) B9 ?                实例变量(对象属性)对堆对象中分配(如: 书的名字)
                引用变量的值是地址值(透明管理,不可见), 通过这个地址
* k/ f( X2 a' K- z+ `                值引用了一个堆对象.
' Y+ M6 B* A7 f3 P: e
: X( X/ ~/ [0 k/ `3 c" \2 @  不确切说法: 引用的值是对象
            引用变量在栈中分配
  类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
                对象的样子.
- L& q5 i) ]# B1 k* k3 c6 R% J
  想着对象写类型: 面向对象, 类是对象的抽象化

4 b  e  Z( ]% O9 i( U3 Z2 b  方法的重载: 体现了行为的多态现象

" ?. V1 Y( D: x( p  O( ]

发光的影子

看了看  学习学习  哈哈哈哈

java宫城大师

学习一下。谢谢

woniu

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

wudizxt

不错不错不错不错