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

汪星人

1 面向对象(OO)
6 E. \% v, Q$ M6 V7 ~ 1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
& h+ R) s1 ?7 x0 O 2) 面向对象, 面向客观事物之间的关系.
( ]/ P4 N8 Z1 J) R2 t4 H& q7 C  R 4) OOA面向对象分析/OOD 面向对象设计
   客人来了(来了一个客人类型的某人)
* h7 U0 F. O7 C/ i! O0 c. X
5) 面向对象概念
  A 类型: 名词概念, 如: 客人, 菜品, 厨师
, {8 a' g5 d# k0 C  B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
  C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
  D 行为(方法)
0 Q( E$ m+ x" ]) i) \  基本特征:
7 b8 [: C- v$ r  A 多态: 行为/引用, 在具体情形下发生了变化的现象
4 h" B# v4 N9 o; b% l0 ^( u, L          一盏灯:  多态的
# y8 X6 E6 S' g3 a2 I          打: 根据宾语发生变化
4 j! Z9 i( E& Q8 M/ G  B 封装: 任何对象实例都是尽可能封装, 减少暴露
  C 继承: 概念的继承关系
+ t% S$ @2 I2 `) ]8 m
2 java 类型, 引用变量 与 堆对象
1)Java 类, 是用来描述事物类型的. 如: 书
   <图书馆管理系统>中的概念: 书 Book
: n/ E7 z5 @& E1 G  书的特征: 书号, 书名, 编号, 作者, 价格...  
2) 类的声明:
  Z; M# ]8 `! W; ]% c5 Q7 \    public class Book{
            long id;
            String name;
            String isbn; //书号
            String[] authors; //作者
" d% g" m) i. j3 N& V, [4 G9 t            double price;
    }
) o% m) r: [7 z0 I4 @. }+ f 3) 引用变量与对象的创建过程:
  A Java的内存管理与分配:
0 z+ V$ E. d. G5 E1 ?    栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
    堆也是一块Java使用内存区域, 使用方式: 无需随机分配
  B 局部变量 与 堆对象空间分配
   Java 局部变量在栈中分配, 是按照变量的类型分配
2 t9 s+ Z2 p) U+ d) ^' ^   对象在堆中分配, 按照类的属性(实例变量)分配空间
  C 变量类型与分配
/ z* g1 y9 K1 n; N/ s% w: k   变量分为: 基本类型和引用类型
% W8 B! u1 Q. S$ W* ]+ \/ `7 s  k   基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
    的值
   引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
6 [( I" G  q, ?   对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
# F7 H# _% `, T! A; d   由Java系统管理: 变量占用空间以及值的管理, 都是透明的.

# _; @* {9 p7 U- _& M 4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
5) 在null引用上调用属性或方法, 会发生运行时异常
4 ]( F9 t# N2 Q6 z  R
案例:
( O2 I& T( y2 q  平面绘图坐标系中的一个点(Point),定义合理的属性
  坐标是int类型.
% U# Q- q0 \0 b3 L" Z, r  s0 T/ n$ A  m   O+-----------------------------> X
6 {; q4 n4 G1 c. c6 F% i    |
1 t7 p9 p5 H$ U    |
    |
! Y, g5 q7 A  n. d    |
' k+ G! P* {- D" J    |          . p(x,y)
    |
- |$ W- U. n# r0 E  z    |
# g0 x5 {8 j  I% S9 m9 u2 j1 P( d    |
    |
" v, M1 V! V' Y/ w5 Z
, O% [: J/ i) l: v; D( [# _% ]    Y
% v: Q& f- v$ }2 o/ B  c
% }) l# F- m" U3 v! e8 R  K3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
' B  y# _8 k0 h0 ?! x# ]1 K2 S  1)
  如: 月饼实例的创建, 使用面和馅创建.
              制作(构造器)
  月饼模子(类)  -----> 月饼(对象)
              原料(构建参数)
+ f, E6 W& C: x8 }
  点类型   -------->  原点
8 z, U+ m; ^& q           坐标(1,2)
( P: }- E& V% n
' q) U7 a1 s7 _4 t 2) Java中的构造器: 声明在类内部, 方法名与类名一致
4 F( j. z, P/ U: W% b# ]6 |  的方法叫构造方法, 构造方法不能声明返回值类型.
$ F4 l1 _0 ?+ X' N5 \! b+ _4 ]  构造方法可以包含参数, 参数一般是创建对象实例
  必须依赖的条件(前提条件).
        public class Point {
          int x;
) ?8 j5 j9 I# I* K$ l1 y          int y;
          /** 构造器 */
, u0 }2 J/ }+ j* N          public Point(int x, int y){
            this.x = x;
            this.y = y;
          }
. s* Q/ L$ ~0 i6 c) d4 S        }
+ C+ N5 D  D  H8 t7 w6 S* g" Y! i8 W
& L, s+ g' }( D) @% {, S" x9 ^ 3) 对象实例化过程:
new运算: 创建对象实例
4 L' v3 W' @, u2 [5 l) u  1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
  2 根据参数类型调用构造器.
  3 new运算返回对象的引用地址.
- D5 G& }7 U/ D" I4 e
4) this 关键字
  K, N6 L2 ?1 X- I% Z* L  this 是对当前对象的引用, 是运行期间当前对象本身.
          可以使用this明确的访问当前对象的属性或者方法
          类似于"我".
  this() 是调用本类的其他构造器, 可以使用构造器的重用,
    简化代码的实现.
  * this() 必须写在构造器的第一行!
# W7 u6 m. ~7 ^; x5 z( R* L3 U. O* g
/ ^+ }! t$ a3 {0 N' x% {/ I% f 5) 构造方法重载: 参数不一样的构造器
0 P+ y1 p1 R3 n+ p  F        案例: Point.java
   方法签名 = 方法名+参数类型列表
   方法重载:a 方法名一样 b 方法参数不一样
     也可以说: 方法名一样, 方法签名不同的方法
* b1 t! T6 N1 f  v' f$ G
6) 默认构造器
0 U8 M. j6 y- \3 o& D( P  1 java 类一定有构造器
4 b$ m+ O% g; }! R5 y6 K! Y8 v& h6 f  案例: ConstructorDemo.java
  v+ Z1 V0 K& s9 P  2 如果类没有声明任何构造器,Javac自动提供一个
  默认构造器, 无参数默认构造器
  3 如果提供构造器声明, Javac将不再提供默认构
8 |$ c4 t# u( p# z! S" j  造器.   
$ R1 W: p$ q- I7 a
4 对象的方法
1) 表示对象的功能, 依赖于对象存在.
3 U" N; S8 w# }( y, g! b/ z) ^  案例: Point.java
, N6 s- d8 z% C5 E, F4 ~; t7 s/ D+ N  如: p1.distance() 和 p2.distance()
  方法是动作,是功能,一般用动词声明.  
: S) B/ n( E1 W' T9 P/ H7 F 2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
' Z; m! ?' m) L; U8 t   功能的多态.重载的方法经常互相重用.

  对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
( g+ U) `9 p4 p: Z( Y- W6 s  引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
                实例变量(对象属性)对堆对象中分配(如: 书的名字)
                引用变量的值是地址值(透明管理,不可见), 通过这个地址
1 v: q8 a: M4 Q" {  ?                值引用了一个堆对象.

  不确切说法: 引用的值是对象
" i: K! W3 h0 L# j* k            引用变量在栈中分配
" h; G4 i, F! E  P; E  类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
; E/ K6 ^8 N9 G% H9 n% m                对象的样子.

  想着对象写类型: 面向对象, 类是对象的抽象化
- m( E6 Y2 f. }
  方法的重载: 体现了行为的多态现象

, I8 e' k# f1 m

wudizxt

不错不错不错不错

woniu

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

java宫城大师

学习一下。谢谢

发光的影子

看了看  学习学习  哈哈哈哈