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

汪星人

1 面向对象(OO)
) z8 P6 m: |3 l. B" V! P 1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
$ Y& }) i) B, I: m/ [, s- }5 N 2) 面向对象, 面向客观事物之间的关系.
4) OOA面向对象分析/OOD 面向对象设计
, B; Z4 I+ P/ U" m( f  x% b$ r   客人来了(来了一个客人类型的某人)
  Y% {# y% V: C3 D9 i4 y# U. A
5) 面向对象概念
2 A3 Y3 v5 ]7 t# ]+ @  A 类型: 名词概念, 如: 客人, 菜品, 厨师
. M7 j5 N1 m4 Q4 N5 h  B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
* g, {3 B1 f# k* m7 h  C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
% G% w9 e% i" O( M  D 行为(方法)
  基本特征:
  A 多态: 行为/引用, 在具体情形下发生了变化的现象
          一盏灯:  多态的
          打: 根据宾语发生变化
  B 封装: 任何对象实例都是尽可能封装, 减少暴露
( N/ U8 m. q6 C' O) [# }  C 继承: 概念的继承关系

2 java 类型, 引用变量 与 堆对象
1)Java 类, 是用来描述事物类型的. 如: 书
5 ?5 t% b7 u) G: X+ {& H   <图书馆管理系统>中的概念: 书 Book
  书的特征: 书号, 书名, 编号, 作者, 价格...  
2) 类的声明:
    public class Book{
% i2 g5 L0 ~8 a) D9 j            long id;
            String name;
            String isbn; //书号
6 l7 [. D# D0 x4 ?0 h. X7 @+ p1 d  u            String[] authors; //作者
  ~5 ~4 E7 M5 z: Z1 U( I4 N$ t. u            double price;
    }
& f' {% j8 @; I; P7 L! G 3) 引用变量与对象的创建过程:
  A Java的内存管理与分配:
    栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
    堆也是一块Java使用内存区域, 使用方式: 无需随机分配
' D* g% l* d: |& q  i  B 局部变量 与 堆对象空间分配
& _1 o1 t7 x2 V0 t   Java 局部变量在栈中分配, 是按照变量的类型分配
   对象在堆中分配, 按照类的属性(实例变量)分配空间
- U. \: u5 B' {8 b& `# X  C 变量类型与分配
+ E% V* P3 E% T' j) {   变量分为: 基本类型和引用类型
   基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
, `; }  r/ e& `$ a" k$ H: f: c8 m    的值
% j1 L* p/ G1 K" x1 u   引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
   对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
   由Java系统管理: 变量占用空间以及值的管理, 都是透明的.
, ~0 o  X! ?2 J  A
4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
5) 在null引用上调用属性或方法, 会发生运行时异常
4 Q6 |5 C# i7 P1 q
案例:
% r6 ]0 G7 z, m& u) f2 Y  平面绘图坐标系中的一个点(Point),定义合理的属性
  坐标是int类型.
   O+-----------------------------> X
- t! z0 d  Z  ?$ |3 Z1 f; `. v5 m    |
  e" [% j, a# C7 T6 q    |
    |
    |
3 v7 z9 B3 `4 }2 y; r6 k# q    |          . p(x,y)
    |
    |
    |
    |

" v+ P* r0 g1 ~- \  F4 W    Y

+ W5 ~1 Y7 u6 l5 ^7 p5 U% ?& E3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
# U+ z9 K/ h. M, s  1)
  如: 月饼实例的创建, 使用面和馅创建.
1 c+ A3 ]# q; v/ k. {+ ?              制作(构造器)
) @& i! s, B0 J4 o- B1 r  月饼模子(类)  -----> 月饼(对象)
/ z4 E0 p4 y$ D8 H% g( C              原料(构建参数)

  点类型   -------->  原点
' k9 F- O6 z  W, ~           坐标(1,2)
9 F8 V$ Q# \+ u& N
2) Java中的构造器: 声明在类内部, 方法名与类名一致
  Z, |( |" A5 ^7 O  的方法叫构造方法, 构造方法不能声明返回值类型.
  构造方法可以包含参数, 参数一般是创建对象实例
  D' g# f. b* r8 I1 x0 i  必须依赖的条件(前提条件).
9 v) M: c* c1 m        public class Point {
          int x;
          int y;
. p2 H  v' B0 o          /** 构造器 */
2 e% q; p0 G# o$ b$ ?/ J! @2 i          public Point(int x, int y){
            this.x = x;
  [, T8 i9 L3 c% N4 s6 n; Q4 M5 ?            this.y = y;
4 ^+ i6 N  I" C          }
        }

3) 对象实例化过程:
8 h7 \' G7 o) B: r' b' X7 V& \- O# u new运算: 创建对象实例
  1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
" L! ]5 e9 V/ D+ I  e$ V  2 根据参数类型调用构造器.
! r% }, i) {) f3 I; Z, ]  3 new运算返回对象的引用地址.

4) this 关键字
  this 是对当前对象的引用, 是运行期间当前对象本身.
          可以使用this明确的访问当前对象的属性或者方法
, Z, n; [1 _3 [2 L" `          类似于"我".
0 v. E: U% j, h' b  this() 是调用本类的其他构造器, 可以使用构造器的重用,
    简化代码的实现.
7 d" z. }- s3 M  * this() 必须写在构造器的第一行!
# z" ]+ u' L! @4 a/ S  C
4 l, D( c4 o! H, B7 r5 I6 ]2 F+ i 5) 构造方法重载: 参数不一样的构造器
        案例: Point.java
   方法签名 = 方法名+参数类型列表
* ^) k* c5 e. o; f   方法重载:a 方法名一样 b 方法参数不一样
     也可以说: 方法名一样, 方法签名不同的方法
7 o3 z; L. c" K4 r& {2 I
6) 默认构造器
1 m- L& R+ z: e# g+ y) P  1 java 类一定有构造器
  案例: ConstructorDemo.java
  2 如果类没有声明任何构造器,Javac自动提供一个
  默认构造器, 无参数默认构造器
  3 如果提供构造器声明, Javac将不再提供默认构
+ f4 }6 T' |+ g7 z  造器.   
! q0 `! K( e$ P9 C
4 u& R; M, b! p! R  v5 G4 \& Y9 H  y4 对象的方法
1) 表示对象的功能, 依赖于对象存在.
  案例: Point.java
  如: p1.distance() 和 p2.distance()
: Q/ I+ W( G) Y. a- d% W  方法是动作,是功能,一般用动词声明.  
- h% ?+ [+ Z# }9 { 2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
   功能的多态.重载的方法经常互相重用.

; |5 _+ v$ q" _$ F! Y  对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
# K3 k& H+ e8 C8 `# g  引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
$ S3 e) w- O* C. W4 C* k: v* e                实例变量(对象属性)对堆对象中分配(如: 书的名字)
                引用变量的值是地址值(透明管理,不可见), 通过这个地址
                值引用了一个堆对象.

  不确切说法: 引用的值是对象
            引用变量在栈中分配
  类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
                对象的样子.
/ ^$ Z# C! }( A3 ]5 g) e2 y; ?" W
- i6 ^4 k  P) b/ J  [0 J  想着对象写类型: 面向对象, 类是对象的抽象化

  方法的重载: 体现了行为的多态现象
& H9 F+ q) o5 S' f

发光的影子

看了看  学习学习  哈哈哈哈

java宫城大师

学习一下。谢谢

woniu

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

wudizxt

不错不错不错不错