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

汪星人

1 面向对象(OO)
1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
4 _' m: B( X$ h+ K( h 2) 面向对象, 面向客观事物之间的关系.
5 z+ @. L) I! Q) |7 M 4) OOA面向对象分析/OOD 面向对象设计
9 a4 c" j3 M8 P2 x   客人来了(来了一个客人类型的某人)

5) 面向对象概念
- t$ a. @! _" L- W/ w0 r4 X  A 类型: 名词概念, 如: 客人, 菜品, 厨师
  B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
. T% f3 z$ B5 ?( T8 `  C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
" a3 y( ^5 T; q+ k% i. d4 _  D 行为(方法)
  基本特征:
  A 多态: 行为/引用, 在具体情形下发生了变化的现象
* G' {& M* F. v4 R+ c4 B, C          一盏灯:  多态的
* o7 ?( O6 i8 \          打: 根据宾语发生变化
  B 封装: 任何对象实例都是尽可能封装, 减少暴露
  C 继承: 概念的继承关系
5 t# K2 w8 Y: `% M2 Z( @
2 t3 n& g$ |( n6 `2 java 类型, 引用变量 与 堆对象
5 z1 m5 Y; D$ Z% c9 [7 d4 ` 1)Java 类, 是用来描述事物类型的. 如: 书
, h/ L  R4 p+ M1 v: {+ f1 Y   <图书馆管理系统>中的概念: 书 Book
% M3 Z9 O' i5 ~$ v% }  书的特征: 书号, 书名, 编号, 作者, 价格...  
2 E4 v, \/ Y  K* ^) V+ B 2) 类的声明:
    public class Book{
            long id;
: q1 Q+ b6 T# K4 m( H. _            String name;
+ q& t& {; s- }            String isbn; //书号
            String[] authors; //作者
* U# g% t" P, ?3 b6 @8 F/ P            double price;
    }
3) 引用变量与对象的创建过程:
( L  x9 l( g, X5 v0 j, f  A Java的内存管理与分配:
    栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
5 w1 @4 w3 [1 |! F    堆也是一块Java使用内存区域, 使用方式: 无需随机分配
# T  S4 s# l9 f5 M* D4 s& n! L% s  B 局部变量 与 堆对象空间分配
9 ?& s6 r; i/ O- I+ W   Java 局部变量在栈中分配, 是按照变量的类型分配
5 j! m& N+ ?1 f) ~. e9 H6 Y6 T   对象在堆中分配, 按照类的属性(实例变量)分配空间
9 Q; o) x2 \" z9 e* E) H: Q2 L  C 变量类型与分配
7 n& l& F6 `5 {7 O$ Q) _4 u3 k) H) D   变量分为: 基本类型和引用类型
   基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
    的值
2 }8 U+ W/ q# X+ R/ I6 f  N- ^  C0 Y   引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
- ?; j6 q! Y, e) [   对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
   由Java系统管理: 变量占用空间以及值的管理, 都是透明的.
7 Y5 L! Z+ `1 s4 @' T
; C5 O3 g  E# ^* ~2 r1 b 4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
5) 在null引用上调用属性或方法, 会发生运行时异常

案例:
  平面绘图坐标系中的一个点(Point),定义合理的属性
4 \" P3 Z" ~: w1 ]& a  坐标是int类型.
0 T4 c. b# j- K! f& ?   O+-----------------------------> X
" H- F+ a1 i3 p% J( a    |
    |
    |
  L) A$ r1 P- \3 d4 c0 l    |
    |          . p(x,y)
7 q3 Y9 _0 ?0 K- S; u. o2 W8 H( T    |
    |
7 M. d6 c# j% j5 Q2 M* y9 i! G7 q: T    |
    |
* C: N, Z1 o% F- {9 D: l
    Y

3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
  1)
  如: 月饼实例的创建, 使用面和馅创建.
              制作(构造器)
# J2 C9 d% J1 P  月饼模子(类)  -----> 月饼(对象)
; k) _6 U7 b3 _; g              原料(构建参数)

6 Y. U% L! o  e  点类型   -------->  原点
. r4 ?4 a( Y/ a9 g0 d* D           坐标(1,2)
1 S8 z/ }5 M8 o3 k" ~
0 k9 A, ?$ [2 y 2) Java中的构造器: 声明在类内部, 方法名与类名一致
! \6 N0 M$ W' A) Q  的方法叫构造方法, 构造方法不能声明返回值类型.
. p) [$ w5 T5 |0 A/ d  构造方法可以包含参数, 参数一般是创建对象实例
  必须依赖的条件(前提条件).
! |+ L) q; p3 f! m        public class Point {
          int x;
          int y;
: Y9 P$ e, [; |# ]2 a  M7 L; |          /** 构造器 */
          public Point(int x, int y){
0 w; `1 e1 U! c5 ~% p6 i            this.x = x;
            this.y = y;
          }
        }
+ J% a7 A: d7 K- a
3) 对象实例化过程:
* G6 D2 H# S3 Y6 c0 ]' u# y/ z new运算: 创建对象实例
1 @8 ]2 Y% r+ M/ A* X  1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
  2 根据参数类型调用构造器.
  3 new运算返回对象的引用地址.
" x+ R- s  m( G' b9 M7 c
% Y5 e6 S: ^, g% z 4) this 关键字
2 D5 Q6 a4 a! Z# O, X9 @  G  this 是对当前对象的引用, 是运行期间当前对象本身.
) @- c, P4 A( N/ L          可以使用this明确的访问当前对象的属性或者方法
          类似于"我".
  this() 是调用本类的其他构造器, 可以使用构造器的重用,
    简化代码的实现.
% e% d" q. k8 x% Q5 ^2 `% y* f  * this() 必须写在构造器的第一行!

2 a" x1 s4 O8 ]0 m9 k# F2 p 5) 构造方法重载: 参数不一样的构造器
/ x) w* l5 @. D( n! Q! \        案例: Point.java
! W& R/ Q4 w. |( @- i+ i   方法签名 = 方法名+参数类型列表
   方法重载:a 方法名一样 b 方法参数不一样
     也可以说: 方法名一样, 方法签名不同的方法
+ ?3 W/ ?3 D$ o5 S  `
' V" U2 _7 {3 B1 K; S 6) 默认构造器
/ c! Y0 |6 I% H; M) E6 O0 h9 z% r7 T/ E) T  1 java 类一定有构造器
  案例: ConstructorDemo.java
  2 如果类没有声明任何构造器,Javac自动提供一个
  默认构造器, 无参数默认构造器
  3 如果提供构造器声明, Javac将不再提供默认构
( s6 _/ L$ z; Q2 P, G) ^  造器.   
- P0 P2 A4 I5 g/ _/ `4 v$ X
4 对象的方法
1) 表示对象的功能, 依赖于对象存在.
  案例: Point.java
  如: p1.distance() 和 p2.distance()
  方法是动作,是功能,一般用动词声明.  
2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
2 O7 M5 Z4 j3 S5 K   功能的多态.重载的方法经常互相重用.
; C+ z& @. ~  T% Q' l& m# P
  对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
# c1 O" }/ e6 f6 Y2 V7 W  引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
                实例变量(对象属性)对堆对象中分配(如: 书的名字)
                引用变量的值是地址值(透明管理,不可见), 通过这个地址
                值引用了一个堆对象.

5 ]/ H3 u- @0 [; I& C' e3 N6 P, Z  不确切说法: 引用的值是对象
6 K' B0 S- u# ]" V8 H            引用变量在栈中分配
: V$ u8 I+ T9 P! h4 ?$ Z  类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
                对象的样子.

  c. x7 A9 h  D" d* u6 g! J  想着对象写类型: 面向对象, 类是对象的抽象化

  方法的重载: 体现了行为的多态现象

# ~* m  x- y$ h0 U1 T3 J

发光的影子

看了看  学习学习  哈哈哈哈

java宫城大师

学习一下。谢谢

woniu

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

wudizxt

不错不错不错不错