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

汪星人

1 面向对象(OO)
1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
; f& q. Q" v3 r3 ]( A3 N 2) 面向对象, 面向客观事物之间的关系.
' s# ]* l1 x8 R) E! g7 O% P 4) OOA面向对象分析/OOD 面向对象设计
   客人来了(来了一个客人类型的某人)
; ^3 O' d9 C. p& y
6 x' d! E$ F% s) R+ v8 S$ Z 5) 面向对象概念
  A 类型: 名词概念, 如: 客人, 菜品, 厨师
: K- s. O$ W9 l2 X) ]  B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
  C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
3 k2 E! Z  `, i* o3 C  D 行为(方法)
7 W, ~8 d; ^* X* C9 }, G  基本特征:
  A 多态: 行为/引用, 在具体情形下发生了变化的现象
          一盏灯:  多态的
          打: 根据宾语发生变化
( J3 j; \; s8 y( b* H) r2 w  B 封装: 任何对象实例都是尽可能封装, 减少暴露
3 i$ B, B6 Q1 S3 g$ g  C 继承: 概念的继承关系
* g2 R' c2 Y1 g% R
; ~- P4 Z( {9 S' |7 M2 java 类型, 引用变量 与 堆对象
1)Java 类, 是用来描述事物类型的. 如: 书
   <图书馆管理系统>中的概念: 书 Book
% E# q  D# h% _' q1 d; o  书的特征: 书号, 书名, 编号, 作者, 价格...  
5 U  l6 f* |% t# O4 {% z, M: Z 2) 类的声明:
    public class Book{
            long id;
            String name;
            String isbn; //书号
            String[] authors; //作者
            double price;
    }
' e0 |8 {! A/ q7 t, ` 3) 引用变量与对象的创建过程:
0 O+ Y- T) R2 m; e  A Java的内存管理与分配:
2 z. z  T1 o2 Y- T) R" J& D    栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
    堆也是一块Java使用内存区域, 使用方式: 无需随机分配
  B 局部变量 与 堆对象空间分配
   Java 局部变量在栈中分配, 是按照变量的类型分配
   对象在堆中分配, 按照类的属性(实例变量)分配空间
! @. _2 I( L% d& H1 j8 u  C 变量类型与分配
1 J# S4 ~# B+ Z7 R/ v7 R   变量分为: 基本类型和引用类型
" H6 i1 i9 I3 R" N   基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
    的值
" `* _5 y1 r* _- z   引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
. M2 j" U4 z9 ~" q+ K   对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
   由Java系统管理: 变量占用空间以及值的管理, 都是透明的.

4 `/ e8 |5 m0 Y 4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
' [8 {# s5 M8 ^( V" a) ~" ] 5) 在null引用上调用属性或方法, 会发生运行时异常
8 i+ p$ Y- ]8 K# i9 C' L0 ]% W
$ H& k( A) N! h7 x* {) U 案例:
* {5 [2 X) g% }  平面绘图坐标系中的一个点(Point),定义合理的属性
  坐标是int类型.
   O+-----------------------------> X
) W% L# v/ m8 Q: ]0 ^2 D    |
    |
+ K. M+ `2 e( X7 f    |
    |
: B9 q5 i$ A; N6 H8 E" v; Q- z. N    |          . p(x,y)
    |
    |
    |
    |

    Y

% V2 s) A" m# M: p6 l! `  @9 w3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
  1)
  如: 月饼实例的创建, 使用面和馅创建.
              制作(构造器)
8 }4 m* K& g" s2 V6 z  月饼模子(类)  -----> 月饼(对象)
              原料(构建参数)
, k  `( ^. S' h0 p0 D2 R8 b# R
2 N9 T8 K: f# P( r# e  点类型   -------->  原点
           坐标(1,2)
! x' M$ T6 O9 I
2) Java中的构造器: 声明在类内部, 方法名与类名一致
' ^6 q' r5 z+ t  的方法叫构造方法, 构造方法不能声明返回值类型.
  构造方法可以包含参数, 参数一般是创建对象实例
  必须依赖的条件(前提条件).
        public class Point {
: H8 L$ F( y& f# r# A7 Q8 O          int x;
5 q! B9 @5 J- c/ J; Y: g          int y;
          /** 构造器 */
          public Point(int x, int y){
            this.x = x;
1 F$ F: z( X  N' g, T            this.y = y;
9 {) t, `6 p4 j& k" Z% }3 ]5 E! |          }
' i/ _; d4 T7 z  E2 e1 R/ t7 R; ~3 L        }
/ Y0 j, [, [6 \0 ~5 p
$ K& Z/ v' o8 D# A9 Y9 n 3) 对象实例化过程:
new运算: 创建对象实例
  1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
  2 根据参数类型调用构造器.
3 t4 M" x( m% ]7 c( A8 I  3 new运算返回对象的引用地址.

9 \3 l$ X& ?- V: G, w0 L. h: l( ?$ g 4) this 关键字
, S+ n1 g7 p) U1 s8 ]7 ]+ Z# ?  this 是对当前对象的引用, 是运行期间当前对象本身.
          可以使用this明确的访问当前对象的属性或者方法
6 \* Y7 K4 G! D4 K! a; K, a3 ^          类似于"我".
5 o! r1 l4 f( w' ^9 V  this() 是调用本类的其他构造器, 可以使用构造器的重用,
# J- \2 |( m% c0 \8 e/ q    简化代码的实现.
/ p. @+ w- N5 m& R7 Q8 Z  * this() 必须写在构造器的第一行!
5 Z  L, A9 l) d0 D
# u2 s7 k, D( W3 s8 Y( ]- q+ `3 ] 5) 构造方法重载: 参数不一样的构造器
! ]3 G! q% p; Y# s        案例: Point.java
- h$ U1 M7 M4 |2 a' A   方法签名 = 方法名+参数类型列表
' H6 A' U1 T8 f7 ~" b6 b6 C   方法重载:a 方法名一样 b 方法参数不一样
     也可以说: 方法名一样, 方法签名不同的方法

6) 默认构造器
% |  j; u/ ~+ D4 `  1 java 类一定有构造器
6 K! R9 e5 n- J( p  E" ~3 x  案例: ConstructorDemo.java
  2 如果类没有声明任何构造器,Javac自动提供一个
  默认构造器, 无参数默认构造器
% U) g* F, V1 |* g' o  3 如果提供构造器声明, Javac将不再提供默认构
- t/ d9 U" u' t" T, q  造器.   
5 ~( R" H" y9 P: q( d: `  |" P
4 对象的方法
1) 表示对象的功能, 依赖于对象存在.
. g# Y' _5 i9 X  案例: Point.java
1 H1 {" ?: l" c+ r$ a+ n$ d  如: p1.distance() 和 p2.distance()
  方法是动作,是功能,一般用动词声明.  
2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
" }! G3 I; u  b( p  a7 r  V   功能的多态.重载的方法经常互相重用.

  对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
4 U& F8 ]4 a1 G. U; {2 d' c6 u  引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
) h  q% y; L- u6 W0 o& c$ l5 [                实例变量(对象属性)对堆对象中分配(如: 书的名字)
7 L8 h6 _0 g) H5 I3 ^" d- G  i                引用变量的值是地址值(透明管理,不可见), 通过这个地址
                值引用了一个堆对象.

  不确切说法: 引用的值是对象
            引用变量在栈中分配
% q- d! N- v" M, q$ l  类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
                对象的样子.
, L( F. M' c1 F( O. d9 b6 u+ o! T
* w9 c% B1 k6 D7 P  想着对象写类型: 面向对象, 类是对象的抽象化
5 `( k" _4 G+ T" n
# c& B) b% k2 j7 n) X2 X( P  方法的重载: 体现了行为的多态现象
; @+ m- C+ k; Z4 f
/ r# O9 V/ K; L: o7 S2 X

发光的影子

看了看  学习学习  哈哈哈哈

java宫城大师

学习一下。谢谢

woniu

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

wudizxt

不错不错不错不错