第4章 对象和类

目录

4.1 面向对象程序设计概述    1

4.4.1 类    1

4.1.2 对象    1

4.1.3 识别类    1

4.1.4 类之间的关系    1

4.2 使用预定义类    2

4.3 用户自定义类    2

4.3.1 Employee类    2

4.3.2 多个源文件的使用    2

4.3.3 剖析Employee类    2

4.3.4 从构造器开始    2

4.3.5 隐式参数与显式参数    3

4.3.6 封装的优点    3

4.3.7 基于类的访问权限    3

4.3.8 私有方法    3

4.3.9 final实例域    3

4.4 静态域或静态方法    3

4.4.1 静态域    3

4.4.2 静态常量    3

4.4.3 静态方法    4

4.4.4 工厂方法    4

4.4.5 main方法    4

4.5 方法参数    4

4.6 对象构造    4

4.6.1 重载    4

4.6.2 默认域初始化    4

4.6.3 无参数的构造器    5

4.6.4 显式域初始化    5

4.6.5 参数名    5

4.6.6 调用另一个构造器    5

4.6.7 初始化块    5

4.6.8 对象析构与finalize方法    5

4.7 包    5

4.7.1 类的导入    5

4.7.2 静态导入    6

4.7.3 将类放入包中    6

4.7.4 包的作用域    6

4.8 类路径    6

4.9 文档注释    6

4.10 类的设计技巧    6

 

 

面向对象程序设计概述,使用预定义类,用户自定义类,静态域与静态方法,方法参数,对象构造,包,类路径,文档注释,类设计技巧

4.1 面向对象程序设计概述

 面向对象的程序是由对象组成的,每个对象包含对用户公开的特定功能部分和隐藏的实现部分。在oop中,不必关心对象的具体实现,只要能够满足用户的需求即可。

4.4.1 类

类是构造对象的模板和蓝图。封装(数据隐藏),是与对象有关的一个重要对象。所有的类都直接或间接的继承自Object(所有类的超类)。

4.1.2 对象

对象的三个主要特性:

对象的行为

对象的状态

对象的标识

4.1.3 识别类

传统的过程化程序设计,必须冲顶部的main函数开始编写程序。在面向对象程序设计是没有所谓的"顶部"。对于oop,首先从设计类开始,然后再往每个类中添加方法。

4.1.4 类之间的关系

依赖("uses-a"),一个类的方法操纵另一个类的对象

聚合("has-a"),聚合关系意味者类A的对象包含类B的对象。

继承("is-a")

应该尽可能地将相互依赖的类减至最少。

4.2 使用预定义类

4.3 用户自定义类

4.3.1 Employee类

在java中,最简单的类定义形式为:

class ClassName{

    field1

    field2

    ...

    constructor1

    constructor2

    ...

    method1

    method2

    ...

}

4.3.2 多个源文件的使用

在程序清单4-2中,一个源文件包含了两个类。许多程序员习惯于将每一个类存在一个单独的源文件中。

4.3.3 剖析Employee类

在java中有4中访问级别。

4.3.4 从构造器开始

构造器和类名同名。

每个类可以有一个以上的构造器。

构造器可以有0个、1个或多个参数。

构造器没有返回值。

构造器总是伴随着new操作一起调用。

4.3.5 隐式参数与显式参数

this(对象本身)隐式参数,方法中可以看到的传参,显式参数。

4.3.6 封装的优点

封装:

一个私有的数据域。

一个公有的域访问器方法;

一个共有的域更改器方法;

优点:

改变内部实现,除了该类的方法以外,不会影响其他代码。

更改器方法可以执行错误检查,然而直接对域进行赋值将不会进行这些处理。

4.3.7 基于类的访问权限

4.3.8 私有方法

在Java中,为了实现一个私有方法,只需要将关键字public改为private即可。

私有的不会被其他类操作调用。

4.3.9 final实例域

可以将实例域定义为final。构造对象时必须初始化这样的域。也就是说,必须确保在一个构造器执行之后,这个域的值被设置。

4.4 静态域或静态方法

4.4.1 静态域

如果将域定义为static,每个类中只有一个这样的域。而每个对象对于所有的实例域却都有自己的一份拷贝。

4.4.2 静态常量

static final修饰

4.4.3 静态方法

静态方法是一种不能向对象实施操作的方法。

换句话说,没有隐式的参数。

静态方法可以访问静态域。

不需要使用对象调用静态方法,可以直接使用类名。

在下面两种情况下使用静态方法:

一个方法不需要访问对象状态, 其所需参数都是通过显式参数提供。

一个方法只需要访问类的静态域。

4.4.4 工厂方法

静态方法的一种常见用途。

4.4.5 main方法

程序默认入口方法

4.5 方法参数

一些专业术语:

按值调用(call by value)表示方法接收的是调用者提供的值。而按引用调用(call by reference)表示方法接受的是调用所对应的变量地址。

java程序设计语言总是采用按值调用。

4.6 对象构造

4.6.1 重载

如果多个方法有相同的名字、不同的参数,便产生了重载。

4.6.2 默认域初始化

如果在构造器中没有显示的给域赋予初值,那么就会被自动的赋为默认值:数值为0、布尔值为false、对象引用为null。然而,只有缺少程序设计经验的人才会这样做。确实,如果不明确地对域进行初始化,就会影响程序代码的可读性。

4.6.3 无参数的构造器

如果在编写一个类时没有编写构造器,那么系统就会提供一个无参构造器。这个构造器将所有的实例域设置为默认值。

4.6.4 显式域初始化

由于类的构造器方法可以重载,所以可以采用多种形式设置类的实例域的初始状态。

4.6.5 参数名

使参数名都有意义,可以提高代码的可读性。

4.6.6 调用另一个构造器

在一个构造中使用this()调用另一个构造器。

4.6.7 初始化块

在一个类中直接写{}代码块。

4.6.8 对象析构与finalize方法

可以为任何一个类添加finalize方法。finalize方法将在垃圾回收器清除对象之前调用。在实际应用中,不要依赖于使用finalize方法回收任何短缺的资源,这是因为很难知道这个方法什么时候才能够调用。

4.7 包

java允许使用包(package)将类组织起来。借助于包可以方便地阻止自己的代码,并将自己的代码与别人提供的代码库分开管理。

使用包的主要原因是确保类名的唯一性。

4.7.1 类的导入

import关键字,可以导入单个类,也可以导入一个包下的所有类*。

4.7.2 静态导入

import static ,可以直接使用类的静态方法和静态域,而不需要使用类名作为前缀。

4.7.3 将类放入包中

package关键字定义类所在的包。

4.7.4 包的作用域

对于不同的权限限定符,不同的包访问权限不同。

4.8 类路径

classpath,编译时确定导入的类。

4.9 文档注释

javadoc

4.10 类的设计技巧

  • 一定要保证数据私有。
  • 一定要对数据初始化。
  • 不要在类中使用过多的基本数据类型。
  • 不是所有的域都需要独立的域访问器和域更改器。
  • 将职责过多的类进行分解。

 

 

 

 

 

posted @ 2017-10-20 09:56  Bug的梦魇  阅读(211)  评论(0编辑  收藏  举报