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

汪星人

1 面向对象(OO)
1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
2) 面向对象, 面向客观事物之间的关系.
4) OOA面向对象分析/OOD 面向对象设计
9 n6 [8 O$ b8 L# ^9 W+ ?   客人来了(来了一个客人类型的某人)
1 H2 I4 A, V9 |
5) 面向对象概念
  A 类型: 名词概念, 如: 客人, 菜品, 厨师
  B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
+ R+ E# v4 K. k' ^! x5 ?  }# d  C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
; \( R7 w+ ~& a% J  D 行为(方法)
0 V" H, n5 k: s% R9 {& ]# y# X. I- Z  基本特征:
1 {# C% u+ Q1 C2 L/ u+ ^" p0 ^  A 多态: 行为/引用, 在具体情形下发生了变化的现象
          一盏灯:  多态的
          打: 根据宾语发生变化
$ \2 o2 G8 R3 p  B 封装: 任何对象实例都是尽可能封装, 减少暴露
  C 继承: 概念的继承关系

1 e8 y. a3 t* l# ]& G/ G3 f0 R4 ?5 @4 u2 java 类型, 引用变量 与 堆对象
5 @0 M% l- d+ e 1)Java 类, 是用来描述事物类型的. 如: 书
- a$ n' Z$ U) G0 \4 M   <图书馆管理系统>中的概念: 书 Book
  书的特征: 书号, 书名, 编号, 作者, 价格...  
2) 类的声明:
    public class Book{
( U, k) h7 A' z4 Z$ @1 T8 C            long id;
            String name;
8 A5 Z% W3 I6 p: S* c            String isbn; //书号
% ^6 e8 R' Z7 t$ q% @            String[] authors; //作者
            double price;
    }
3) 引用变量与对象的创建过程:
$ X  C3 ]# u0 o- Y  A Java的内存管理与分配:
    栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
    堆也是一块Java使用内存区域, 使用方式: 无需随机分配
  B 局部变量 与 堆对象空间分配
   Java 局部变量在栈中分配, 是按照变量的类型分配
5 X+ ^) m/ I  [7 E8 n   对象在堆中分配, 按照类的属性(实例变量)分配空间
  C 变量类型与分配
   变量分为: 基本类型和引用类型
. Z1 J, ^# l# P( x" S. u. S   基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
    的值
7 K4 C1 ~- x2 T: s- g9 G2 A! V6 |0 l% M   引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
& A" E, v9 E( u4 r   对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
; Z& P/ S( V& _   由Java系统管理: 变量占用空间以及值的管理, 都是透明的.
6 @: }- @# v! |% n/ D
4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
& K' `$ C* c; t# Q 5) 在null引用上调用属性或方法, 会发生运行时异常

4 `& G5 [) [' h 案例:
$ D0 p( m: x9 T: p# L8 w9 t. r  平面绘图坐标系中的一个点(Point),定义合理的属性
  坐标是int类型.
4 S+ {# U- U- Q; p% }   O+-----------------------------> X
" M9 {0 R" ^# K- L) S- X# Q" p    |
    |
    |
    |
    |          . p(x,y)
    |
3 R2 c: \. k- G9 n/ o( r    |
    |
    |

, k% k& c( z; g; A+ d3 C    Y

/ r, J5 F3 H& b4 k7 o7 P( S3 S( R4 o3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
  1)
  如: 月饼实例的创建, 使用面和馅创建.
              制作(构造器)
  月饼模子(类)  -----> 月饼(对象)
* R8 O* E( R9 l$ S8 G$ h              原料(构建参数)

  点类型   -------->  原点
           坐标(1,2)

2) Java中的构造器: 声明在类内部, 方法名与类名一致
  的方法叫构造方法, 构造方法不能声明返回值类型.
  构造方法可以包含参数, 参数一般是创建对象实例
  必须依赖的条件(前提条件).
$ Q2 U2 J7 p+ {8 \& S- B$ @        public class Point {
! r8 z4 S2 t( ^- a( W( S          int x;
          int y;
0 R# p8 W( w: k* C- x1 E% B          /** 构造器 */
4 ^: {9 f. }# [4 A- Y6 R6 m8 K, [          public Point(int x, int y){
/ R  Z* C! X! c            this.x = x;
: t0 x5 \4 V- p0 [. _4 b/ k1 q" H            this.y = y;
% ^, B5 |) L: C( M: B& Z% u          }
) R7 ^4 j1 d1 a4 W: i7 q2 c        }
  L) X9 ]: ~& \
3) 对象实例化过程:
new运算: 创建对象实例
' V' y2 R) z+ s9 `2 l  1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
  2 根据参数类型调用构造器.
: ?) ^* z0 u1 m) y0 j0 ^8 _; a  3 new运算返回对象的引用地址.

2 j2 ?" C# |  g 4) this 关键字
  this 是对当前对象的引用, 是运行期间当前对象本身.
: w3 g$ K  q1 \7 T9 L          可以使用this明确的访问当前对象的属性或者方法
          类似于"我".
  this() 是调用本类的其他构造器, 可以使用构造器的重用,
    简化代码的实现.
9 l5 I5 |8 C$ ~' x8 d- v2 {  * this() 必须写在构造器的第一行!
) M2 l6 Y& e  N' g- K/ Y! x/ L
5) 构造方法重载: 参数不一样的构造器
( U+ j! F* K' c% @9 K, i        案例: Point.java
   方法签名 = 方法名+参数类型列表
2 v, f9 L( k1 I   方法重载:a 方法名一样 b 方法参数不一样
8 A& K) p" G$ X6 V. H0 H9 f& e8 ]     也可以说: 方法名一样, 方法签名不同的方法

6) 默认构造器
  1 java 类一定有构造器
7 r/ ~* I1 y$ l% N( A  案例: ConstructorDemo.java
0 T8 {1 f2 I+ h# z/ A  2 如果类没有声明任何构造器,Javac自动提供一个
) N. P" x2 r! I; q2 F4 p  默认构造器, 无参数默认构造器
4 l% Z/ `6 @8 E0 n/ D7 P( Y) ]2 _  3 如果提供构造器声明, Javac将不再提供默认构
& [" m2 {& G) j0 |- }& U6 p  造器.   
! @& g7 O3 ]& x0 a$ {6 a! A
2 [  P+ p, T; J5 r5 O* _7 v6 x5 f4 对象的方法
8 Z4 q3 P; t& I: F0 { 1) 表示对象的功能, 依赖于对象存在.
+ Q, M3 d0 F' L* i% `7 l  案例: Point.java
9 u/ _7 {! e% {0 _  如: p1.distance() 和 p2.distance()
! D0 g' b" q* ~, K* X# M7 Q  方法是动作,是功能,一般用动词声明.  
; }, N& \$ J. A% I  u 2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
   功能的多态.重载的方法经常互相重用.

  对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
( v% \; x7 D8 f; H  引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
                实例变量(对象属性)对堆对象中分配(如: 书的名字)
, }/ @# v4 i7 [! \. a( W                引用变量的值是地址值(透明管理,不可见), 通过这个地址
                值引用了一个堆对象.
4 e) |! ~7 O* R; D8 Q  `
  不确切说法: 引用的值是对象
; e/ B2 I) L: k" w: M' r2 h& C$ B            引用变量在栈中分配
  类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
                对象的样子.

. }% {8 M+ T0 `" J( E; H1 o  想着对象写类型: 面向对象, 类是对象的抽象化

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

8 Q1 h. K0 t" S+ |7 g

发光的影子

看了看  学习学习  哈哈哈哈

java宫城大师

学习一下。谢谢

woniu

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

wudizxt

不错不错不错不错