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

汪星人

1 面向对象(OO)
1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
2) 面向对象, 面向客观事物之间的关系.
4) OOA面向对象分析/OOD 面向对象设计
   客人来了(来了一个客人类型的某人)

5) 面向对象概念
  A 类型: 名词概念, 如: 客人, 菜品, 厨师
6 C7 X( A3 Y: _" n1 A% P5 A3 M  B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
' t5 D. K- {, g+ V' h1 q9 F  C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
  D 行为(方法)
  基本特征:
  A 多态: 行为/引用, 在具体情形下发生了变化的现象
          一盏灯:  多态的
0 p6 c) V, c9 l. R! O1 X          打: 根据宾语发生变化
6 `& R4 q1 s# g" T& J( |  B 封装: 任何对象实例都是尽可能封装, 减少暴露
  C 继承: 概念的继承关系
8 }0 S6 z; j  |! s( O: P  P3 A
( j% a: h% r& D( Y2 q2 java 类型, 引用变量 与 堆对象
8 Q" Y/ `7 G( G$ E 1)Java 类, 是用来描述事物类型的. 如: 书
& S" z* D& K; a0 P! C   <图书馆管理系统>中的概念: 书 Book
3 H- S, M0 o" T2 K  书的特征: 书号, 书名, 编号, 作者, 价格...  
2) 类的声明:
% M7 M/ \9 l, k8 Q4 N$ p    public class Book{
            long id;
            String name;
            String isbn; //书号
            String[] authors; //作者
            double price;
    }
( ~. t/ M& _; W4 f 3) 引用变量与对象的创建过程:
# \3 i! T8 W0 c% `3 R* K1 {4 F  A Java的内存管理与分配:
    栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
    堆也是一块Java使用内存区域, 使用方式: 无需随机分配
& g1 A, r1 O. s- |# W6 [: W  B 局部变量 与 堆对象空间分配
   Java 局部变量在栈中分配, 是按照变量的类型分配
   对象在堆中分配, 按照类的属性(实例变量)分配空间
7 h% Z9 H; M" L/ \0 t  C 变量类型与分配
7 B& A% _4 w+ Q4 ^1 h   变量分为: 基本类型和引用类型
   基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
8 S* W- ~( M+ t, G9 N0 X8 M6 T6 _+ g    的值
% @- G  Y4 l( y+ w: M# g$ @   引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
4 {% }8 q7 G7 q* U   对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
   由Java系统管理: 变量占用空间以及值的管理, 都是透明的.

4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
( z9 s  ]+ \5 Z) |% H+ t# x' P 5) 在null引用上调用属性或方法, 会发生运行时异常

案例:
! t( ^" m2 c8 [! G+ }  平面绘图坐标系中的一个点(Point),定义合理的属性
* i: t. @+ i& q+ H" l1 ?  坐标是int类型.
+ J% z- u* @, q5 }% }   O+-----------------------------> X
    |
& D8 _: q0 X* p3 y' T7 K' [1 g: N, @    |
    |
3 T) h4 d2 ]5 `6 C    |
  n0 S; v6 y0 |% q    |          . p(x,y)
    |
& u1 s% f0 e# h% g5 x9 g    |
9 r6 X, i3 s" e8 N. R# y    |
    |
& w' i8 R5 g. M( U. c
( V7 Q. Q* E" C1 ~/ k    Y

3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
  1)
  如: 月饼实例的创建, 使用面和馅创建.
# c/ O# P  V) G+ ]  ~# O1 r, x              制作(构造器)
  月饼模子(类)  -----> 月饼(对象)
              原料(构建参数)
1 C8 j# x9 T* _6 q4 @# f
: B/ x) d6 c( H, y  点类型   -------->  原点
           坐标(1,2)

, c' O: m5 P+ H$ x$ k$ G 2) Java中的构造器: 声明在类内部, 方法名与类名一致
) J5 }0 h3 D$ z2 N: v/ \  K  的方法叫构造方法, 构造方法不能声明返回值类型.
  构造方法可以包含参数, 参数一般是创建对象实例
8 A; Y4 G% |* a  必须依赖的条件(前提条件).
        public class Point {
4 n+ }. O; v0 J) \* I9 A. b1 V          int x;
          int y;
4 L; F/ ^# I# x2 X8 M4 U% D4 }          /** 构造器 */
) _% {! }! s3 [          public Point(int x, int y){
3 i+ J# L% j9 _5 q            this.x = x;
            this.y = y;
7 P- f0 T$ o8 m! r; m/ O# V0 Q, S          }
5 [5 K( A! t8 w- C  O9 p5 q; `        }
! O8 z* b& ?& [) a* P* @
3) 对象实例化过程:
6 Q3 |3 s  S, {$ g new运算: 创建对象实例
  1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
! p: v0 h1 ^  I) k" b& U  2 根据参数类型调用构造器.
  3 new运算返回对象的引用地址.
7 C# h' F7 f+ o9 P$ w" l5 `& ]9 g
4) this 关键字
) c( {% S% p" P6 ~1 d( B; m* k9 D  this 是对当前对象的引用, 是运行期间当前对象本身.
          可以使用this明确的访问当前对象的属性或者方法
          类似于"我".
  this() 是调用本类的其他构造器, 可以使用构造器的重用,
! `, `# H% q% w4 I) H    简化代码的实现.
  * this() 必须写在构造器的第一行!
% B! i, C( S9 ?5 ^* E' `. v) q
5) 构造方法重载: 参数不一样的构造器
$ Q5 ~& V) [+ q& E        案例: Point.java
   方法签名 = 方法名+参数类型列表
* Z, Q: i6 f1 f4 ?7 j6 r/ o   方法重载:a 方法名一样 b 方法参数不一样
     也可以说: 方法名一样, 方法签名不同的方法
' k9 E! `1 r  w2 R1 ^  j7 R) [
6) 默认构造器
  1 java 类一定有构造器
  案例: ConstructorDemo.java
  2 如果类没有声明任何构造器,Javac自动提供一个
" f) t2 U$ n# _; Q  默认构造器, 无参数默认构造器
  3 如果提供构造器声明, Javac将不再提供默认构
) x4 J  X0 S5 J! d. _4 x  造器.   

4 对象的方法
1) 表示对象的功能, 依赖于对象存在.
* j% [9 _* Q: s) w" V  案例: Point.java
  如: p1.distance() 和 p2.distance()
  方法是动作,是功能,一般用动词声明.  
2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
' W' f1 N, p+ }- H   功能的多态.重载的方法经常互相重用.
$ B8 d- w& E, J, Y7 Z+ s1 n$ z
  对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
  引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
                实例变量(对象属性)对堆对象中分配(如: 书的名字)
' J( b8 M# a$ v7 h/ X$ X  V                引用变量的值是地址值(透明管理,不可见), 通过这个地址
                值引用了一个堆对象.
7 {' W4 u7 ]) r; W
7 R6 O% D0 k! t; X  不确切说法: 引用的值是对象
            引用变量在栈中分配
) x& Q4 |. u% m+ ^' i) D, M; s  类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
                对象的样子.

  想着对象写类型: 面向对象, 类是对象的抽象化

5 e$ J) d% U" j' y( H, D( u  方法的重载: 体现了行为的多态现象
% h" J8 R4 `: H) I5 A

发光的影子

看了看  学习学习  哈哈哈哈

java宫城大师

学习一下。谢谢

woniu

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

wudizxt

不错不错不错不错