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

汪星人

1 面向对象(OO)
1) 什么是Object(对象), Object 本意:东西,是指一个具体事物实例
2) 面向对象, 面向客观事物之间的关系.
1 t! ]4 v6 O* V 4) OOA面向对象分析/OOD 面向对象设计
   客人来了(来了一个客人类型的某人)
. k. p0 z5 S- ?8 l  v# w
, J& x7 H: p9 L 5) 面向对象概念
  A 类型: 名词概念, 如: 客人, 菜品, 厨师
  B 引用(变量): 引用具体概念实例的代词, 如: 某人, 特价菜
  C 对象(东西): 具体概念的个体实例,如:张三丰这个人, 一盘大盘鸡
7 K& ^& z8 N  F' p  D 行为(方法)
/ q8 s# P2 R& f) F  基本特征:
1 I6 g! [/ `2 ~  X- H  A 多态: 行为/引用, 在具体情形下发生了变化的现象
. y2 k$ m+ o% Y2 A" D8 S2 N- N          一盏灯:  多态的
! H9 G. i- F9 i+ V0 g          打: 根据宾语发生变化
  B 封装: 任何对象实例都是尽可能封装, 减少暴露
  C 继承: 概念的继承关系

2 java 类型, 引用变量 与 堆对象
1)Java 类, 是用来描述事物类型的. 如: 书
# J; ?4 l9 w1 a+ K6 s' Q   <图书馆管理系统>中的概念: 书 Book
  书的特征: 书号, 书名, 编号, 作者, 价格...  
8 e. ]; b2 X8 p3 t, K5 ]+ m 2) 类的声明:
% ^+ q/ _5 O- B. k+ _# C0 [    public class Book{
            long id;
            String name;
& @8 R& x/ _& |" V% |            String isbn; //书号
9 _, t6 k9 {9 o5 Y7 D* {            String[] authors; //作者
            double price;
    }
3) 引用变量与对象的创建过程:
  E- a, K2 ~6 N4 h( F  A Java的内存管理与分配:
2 E0 Y# j0 d, v& L3 a    栈是一块Java使用内存区域, 使用的方式IFO(后来者居上)
    堆也是一块Java使用内存区域, 使用方式: 无需随机分配
4 o' \* L4 y, }! Q5 [, C" X* R0 H  B 局部变量 与 堆对象空间分配
   Java 局部变量在栈中分配, 是按照变量的类型分配
   对象在堆中分配, 按照类的属性(实例变量)分配空间
8 r! P! [# ~+ X  C 变量类型与分配
   变量分为: 基本类型和引用类型
9 l& p% l3 X8 }8 k+ w2 i2 ^! R   基本类型变量的空间大小: 就是基本类型的空间大小, 值是基本类型
  U: B3 o) |: R8 k# l    的值
1 V( V% {1 T# ?9 E& b% F   引用变量的值是一个对象的地址值, 引用变量通过地址引用了一个堆
   对象.引用类型变量的占用空间大小和值管理是"透明的(不可看见)",
5 A8 R( N! C1 l2 O   由Java系统管理: 变量占用空间以及值的管理, 都是透明的.

+ p$ U( f8 \* I! O- X8 ] 4) 对象的属性默认自动初始化的. 自动初始化为"零"值, 引用为null
5) 在null引用上调用属性或方法, 会发生运行时异常
$ d/ O+ f- r! w1 y: X1 f
% s% y6 r5 Q& q& y$ e 案例:
  平面绘图坐标系中的一个点(Point),定义合理的属性
  坐标是int类型.
   O+-----------------------------> X
1 c& ^& P1 Q; W- b) t: u    |
    |
    |
    |
3 s5 B, m+ m9 s9 ^    |          . p(x,y)
    |
    |
/ e; |# v  V2 H* j/ M) P2 W9 _' c    |
# V5 ~, ^5 ]4 T1 N" e+ q6 c    |
$ @/ {- |# ^" t4 k! w
    Y
7 s9 J( p/ M% w6 P! D' t, O
3 构造器(构造方法) 的作用: 用来描述对象的创建过程的.
9 ~! m9 Z% q7 M  1)
. l! F' q& |. Y" d% K  如: 月饼实例的创建, 使用面和馅创建.
  p' f9 [3 z: f) ?3 T/ f( ~  |              制作(构造器)
6 [. C% \% c+ e, ~  月饼模子(类)  -----> 月饼(对象)
. }" Y6 ], E/ [2 d2 ]              原料(构建参数)

  点类型   -------->  原点
" ]$ K- S1 j& R           坐标(1,2)

2) Java中的构造器: 声明在类内部, 方法名与类名一致
, W( q; G# L0 K2 M* v5 q% a  H  的方法叫构造方法, 构造方法不能声明返回值类型.
0 ^0 n5 Z6 X! y# n- U9 {1 ]  构造方法可以包含参数, 参数一般是创建对象实例
  必须依赖的条件(前提条件).
6 L: p  y7 G4 h        public class Point {
          int x;
9 V' \, Y2 `6 X! ]( g          int y;
          /** 构造器 */
          public Point(int x, int y){
            this.x = x;
            this.y = y;
$ a) ~. e* N2 p6 u: j2 O7 R  ~3 @          }
3 E1 e0 R2 a6 ^# Y: e# O3 Z        }

3) 对象实例化过程:
new运算: 创建对象实例
1 h1 j8 R8 B3 B% K# U" `! g  1 根据类的属性在堆中分配对象空间.并且自动初始化实例变量
  2 根据参数类型调用构造器.
5 A; x" ~3 T! h8 L  3 new运算返回对象的引用地址.
5 ]' Q3 K+ O( N. _5 Q. V5 s7 g
, E/ v1 E8 b+ y) D1 ^' y 4) this 关键字
0 G) a, q' P+ \: @$ O$ U, {- ]  this 是对当前对象的引用, 是运行期间当前对象本身.
' c% m( j0 r2 }" M          可以使用this明确的访问当前对象的属性或者方法
3 G) D0 {' L  `( E* j8 i; n$ C          类似于"我".
  this() 是调用本类的其他构造器, 可以使用构造器的重用,
$ I( G9 W' Q1 Q4 e. ?* D    简化代码的实现.
  * this() 必须写在构造器的第一行!

$ Y7 R( C+ O+ I* q" _% Z7 N- p 5) 构造方法重载: 参数不一样的构造器
$ s1 k3 g# o- Z) ^        案例: Point.java
9 P, D- ]7 z. ?) p+ E' c3 a  [8 {9 C: {   方法签名 = 方法名+参数类型列表
8 {, c, }$ z. n) A* w  Y$ @, E   方法重载:a 方法名一样 b 方法参数不一样
5 h( c# X% Z. T4 ~0 |     也可以说: 方法名一样, 方法签名不同的方法
3 j, a" }3 D5 h' l! i- D+ p
% I; ~& _$ _2 g, c4 V. T. d2 s 6) 默认构造器
, F4 a+ N+ Y9 @' g' Z; o3 d  1 java 类一定有构造器
  案例: ConstructorDemo.java
  2 如果类没有声明任何构造器,Javac自动提供一个
2 M" a7 W( ^! X' @! h+ h  默认构造器, 无参数默认构造器
7 R0 m5 s8 _5 ^# W$ m& `( ?  3 如果提供构造器声明, Javac将不再提供默认构
  造器.   

4 对象的方法
1) 表示对象的功能, 依赖于对象存在.
  案例: Point.java
$ ]2 X; Y% {/ S( c( s: z$ ]  ]; D8 g  如: p1.distance() 和 p2.distance()
! M* f1 y" i4 O5 g/ e( i% d  方法是动作,是功能,一般用动词声明.  
2)方法也经常重载, 重载:方法名一样, 参数不一样重载体现了,
: u9 L5 w/ R* R6 u: Q/ G   功能的多态.重载的方法经常互相重用.

9 B/ ]& S$ R; G7 c6 ^$ _  对象: java运行期在堆(内存空间)中分配, 大小按照属性分配
  引用(引用变量): 临时变量(方法中的变量和方法参数)在栈中分配
                实例变量(对象属性)对堆对象中分配(如: 书的名字)
                引用变量的值是地址值(透明管理,不可见), 通过这个地址
                值引用了一个堆对象.

  不确切说法: 引用的值是对象
0 P; G; ]" I2 t8 e  `2 Y- f            引用变量在栈中分配
3 [2 h' ]' W: h* D7 |3 J  类(类型, 是名词概念): 对象的模板, 是对象的样子, 蓝图, 类型决定了
                对象的样子.

4 n, w  r# E: H+ o  想着对象写类型: 面向对象, 类是对象的抽象化

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

4 h7 B8 A: U& J

发光的影子

看了看  学习学习  哈哈哈哈

java宫城大师

学习一下。谢谢

woniu

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

wudizxt

不错不错不错不错