四、对象与类

Myth丶恋晨 2022-03-19 08:49 234阅读 0赞

**目录**

一、面向对象程序设计概述

二、使用预定义类

三、用户自定义类

四、静态域和静态方法

五、方法参数

六、对象构造

对象析构与finalize方法

七、包

包的导入

静态导入

将类放入包中

包作用域

八、类路径

设置类路径

九、文档注释

注释的插入

类注释

方法注释

包与概述注释

注释的抽取

--------------------

# 一、面向对象程序设计概述 #

*    类之间的关系：

依赖（use a)   聚合（has a） 继承（is a）

*    一个对象变量没有实际包含一个对象，仅仅引用一个对象。任何对象变量的值都是对存储在另外一个地方的一个对象的引用
 *  可以显式的将对象变量设置为null,表示这个对象变量目前没有引用任何对象。局部变量不会自动初始化为null,必须显式设置（对象内变量可以）
 *  Java引用看成C++对象指针
 *  在 Java 中， 必须使用 clone 方法获得对象的完整拷贝„

# 二、使用预定义类 #

只访问对象而不修改对象的方法有时称为访问器方法，否则称为更改器方法。

标准Java类库分别包含两个类：一个是用来表示时间点的Date类；另一个是用来表示大家熟悉的日历表示法的LocalDate类

Date：

public class BigIntegerTest
    {
    	static Date d;
       public static void main(String[] args)
       {
    	   Date date=new Date();
    	   String s=date.toString();
    	   if(d==null) {
    		   System.out.println("God");
    	   }
       }
    }

LocalDate：不要使用构造器来构造LocaDate类的对象。实际上，应当使用静态工厂方法代表调用构造器

类库设计者决定将保存时间与给时间点命名分开。所以标准Java 类库分别包含了两个类： 一个是用来表示时间点的 Date 类；另一个是用来表示大家熟悉的日历表示法的 LocalDate 类。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70][]

# 三、用户自定义类 #

*     在一个源文件中，只能有一个公有类，但可以有任意数目的非公有类。
 *     构造器与其他的方法有一个重要的不同。 构造器总是伴随着new操作符的执行被调用，而不能对一个已经存在的对象调用构造器来达成重新设置实例域的目的，例如：

james.Employee("James Bond",1950,1,1);

*   raiseSalary方法有两个参数。第一个参数称为隐式参数，是出现在方法前的Employee类对象。第二个参数位于方法名后面括号中的数值，这是一个显式参数。在每一个方法中，关键字this表示隐式参数

public void raiseSalary(double byPercent) {
    	   double raise=this.salary*byPercent/100;
    	   this.salary+=raise;
       }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 1][]

*   注意不要编写返回引用可变对象的访问器方法,如果需要返回一个可变对象的引用， 应该首先对它进行克隆（clone )。对象 clone 是 指存放在另一个位置上的对象副本。
 *  一个方法可以访问所属类的所有对象的私有数据

public class Three {
        private Date birthday;
        public int age = 5;
        public void print(Three employee){
            System.out.println(employee.age);
        }
        public static void main(String[] args) {
            new Three().print(new Three());
        }
    }
    
    /输出结果：5

*  有时，可能希望将一个计算代码划分成若干个独立的辅助方法。通 常， 这些辅助方法不应该成为公有接口的一部分，这是由于它们往往与当前的实现机制非常紧 密， 或者需要一个特别的协议以及一个特别的调用次序。最好将这样的方法设计为 private 的。
 *  可以将实例域定义为 final。 构建对象时必须初始化这样的域。也就是说， 必须确保在每 一个构造器执行之后，这个域的值被设置， 并且在后面的操作中， 不能够再对它进行修改。
 *  final 修饰符大都应用于基本 （primitive ) 类型域，或不可变（immutable) 类的域（如果类 中的每个方法都不会改变其对象， 这种类就是不可变的类。
 *   如果查看一下 System 类， 就会发现有一个 setOut 方法， 它可以将System.out 设 置为不同的流。  为什么这个方法可以修改 final 变量的值。原因在 于，setOut 方法是一个本地方法， 而不是用 Java 语言实现的。本地方法可以绕过Java 语 言的存取控制机制。这是一种特殊的方法， 在自己编写程序时， 不应该这样处理。

# 四、静态域和静态方法 #

*      如果将域定义为 static, 每个类中只有一个这样的域。而每一个对象对于所有的实例域 却都有自己的一份拷贝。
 *     静态方法是一种不能向对象实施操作的方法，没有隐式的参数。类的静态方法不能访问非静态域， 因为它不能操作对象，但是，静态方法可以访问自身类的静态域。可以使用对象调用静态方法。
 *  在下面两种情况之下使用静态方法：

1.       一 方法不需要访问对象状态，其所需参数都是通过显式参数提供
2.       一个方法只需要访问类的静态域

*   main 方法不对任何对象进行操作。事实上，在启动程序时还没有任何一个对象。静态的 main 方法将执行并创建程序所需要的对象。每一个类可以有一个main方法。
    
        class Employee
        {
            public Employee(String n, double s, int year, int month, int day){
                name = n;
                salary = s;
                Local Date hireDay = Local Date.now(year, month , day) ;
            }
            public static void main(String[] args) // unit test
            {
                Employee e = new Employee("Romeo", 50000, 2003, 3, 31);
                e .raiseSalary(lO);
                System.out.println(e .getName() + " " + e.getSalaryO);
            }
        }

class Employee
    {
        public Employee(String n, double s, int year, int month, int day){
            name = n;
            salary = s;
            Local Date hireDay = Local Date.now(year, month , day) ;
        }
        public static void main(String[] args) // unit test
        {
            Employee e = new Employee("Romeo", 50000, 2003, 3, 31);
            e .raiseSalary(lO);
            System.out.println(e .getName() + " " + e.getSalaryO);
        }
    }

如果想要独立地测试 Employee 类， 只需要执行

java Employee

如果 Employee 类是一个更大型应用程序的一部分， 就可以使用下面这条语句运行程序

java Application

Employee 类的 main 方法永远不会执行。

# 五、方法参数 #

*  方法参数共有两种类型：

1.  基本数据类型
2.  对象引用

*  认为Java程序设计语言对对象采用的是引用调用，实际上，这种理解是不对的。实际上， 对象引用是按值传递的。
 *  总结Java方法中方法参数的使用情况：

1.     一个方法不能修改一个基本数据类型的参数（即数值型或布尔型）。
2.  一个方法可以改变一个对象参数的状态。 
3.  一个方法不能让对象参数引用一个新的对象。

# 六、对象构造 #

*   如果多个方法（比如， StringBuilder 构造器方法）有 相同的名字、 不同的参数，便产生了重载。编译器必须挑选出具体执行哪个方法，它通过用 各个方法给出的参数类型与特定方法调用所使用的值类型进行匹配来挑选出相应的方法。如 果编译器找不到匹配的参数， 就会产生编译时错误，因为根本不存在匹配， 或者没有一个比 其他的更好。
 *  返回类型不是方法签名的一部分。也就是说， 不能有两个名字相同、 参数类型也相 同却返回不同类型值的方法。
 *  如果在构造器中没有显式地给域赋予初值，那么就会被自动地赋为默认值： 数值为 0、 布尔值为 false、 对象引用为 null。
 *  如果在编写一个类时没有编写构造器， 那么系统就会提供一个无参数构造器。这个构造 器将所有的实例域设置为默认值。于是， 实例域中的数值型数据设置为 0、 布尔型数据设置 为 false、 所有对象变量将设置为 null。 如果类中提供了至少一个构造器， 但是没有提供无参数的构造器， 则在构造对象时如果 没有提供参数就会被视为不合法。
 *  可以在类定义中， 直接将一个值赋给任何域。在执行构造器之前，先进行赋值操作。

class Employee
    {
        private int age = 13;
    }

*  初始值不一定是常量值。可以调用方法对域进行初始化。

class Employee
    {
        private int age = initAge();
        
        public int initAge(){
            return 13;
        }
    }

*  如果构造器的第一个语句形如 this(...)， 这个构造器将调用同一个类的另一个构造器。下 面是一个典型的例子：

public Employee(double s)
    {
        // calls Employee(String, double)
        this("Employee #" + nextld, s);
        nextld++;
    }

前面已经讲过两种初始化数据域的方法：

•在构造器中设置值

•在声明中赋值

实际上，Java 还有第三种机制， 称为初始化块（initializationblock)。在一个类的声明中， 可以包含多个代码块。只要构造类的对象，这些块就会被执行。

class Employee
    {
    private static int nextld;
    private int id;
    private String name;
    private double salary;
    // object initialization block
    {
    id = nextld;
    nextld++;
    }
    public Employee(String n, double s){
    salary = s;
    }
    public Employee()
    {
    name = "";
    salary = 0;}
    }

首先运行初始化块，然后才运行构造器的主体部分。 建议将初始化块放在域定义之后。

下面是调 用构造器的具体处理步骤：

> 1 ) 所有数据域被初始化为默认值（0、false 或 null)。
> 
> 2) 按照在类声明中出现的次序， 依次执行所有域初始化语句和初始化块
> 
> 3 ) 如果构造器第一行调用了第二个构造器，则执行第二个构造器主体
> 
> 4) 执行这个构造器的主体.

如果对类的静态域进行初始化的代码比较复杂，那么可以使用静态的初始化块。将代码放在一个块中，并标记关键字static。在类第一次加载的时候， 将会进行静态域的初始化。与实例域一样，除非将它们显式地 设置成其他值， 否则默认的初始值是 0、 false 或 null。 所有的静态初始化语句以及静态初始化块都将依照类定义的顺序执行。

static
    {
    Random generator = new Random();
    nextld = generator.nextlnt(lOOOO);
    }

###  对象析构与finalize方法 ###

由于 Java 有自动的垃圾回收器，不需要人工回收内存， 所以 Java 不支持析构器。 当然，某些对象使用了内存之外的其他资源， 例如，文件或使用了系统资源的另一个对 象的句柄。在这种情况下，当资源不再需要时， 将其回收和再利用将显得十分重要。 可以为任何一个类添加 finalize 方法。finalize 方法将在垃圾回收器清除对象之前调用。 在实际应用中，不要依赖于使用 finalize 方法回收任何短缺的资源， 这是因为很难知道这个 方法什么时候才能够调用。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 2][]

# 七、包 #

使用包的主要原因是确保类名的唯一性。 从编译器的角度来看， 嵌套的包之间没有任何关系。例如，java.utU 包与java.util.jar 包 毫无关系。每一个都拥有独立的类集合。

### 包的导入 ###

一个类可以使用所属包中的所有类， 以及其他包中的公有类（ public class。) 我们可以 采用两种方式访问另一个包中的公有类。第一种方式是在每个类名之前添加完整的包名。 例如

java.tiie.LocalDate today = java.tine.Local Date.now();

可以使用 import 语句导人一个特定的类或者整个包。

import java.util .*;

但是， 需要注意的是， 只能使用星号（\*) 导入一个包， 而不能使用 import java.\* 或 import java.\*.\* 导入以 java 为前缀的所有包。编译器无法确定程序使用的是哪一个 Date 类。可以采用增加一个特定的 import 语句来 解决这个问题。

在包中定位类是编译器 （ compiler) 的工作。类文件中的字节码肯定使用完整的包名来引 用其他类。

import java.util .*;
    import java.sql .*;
    import java.util .Date;

C++ 程序员经常将 import 与 \#include 弄混。 实际上， 这两者之间并没有共同 之处。在 C++ 中，必须使用 include 将外部特性的声明加栽进来，这是因为 C++ 编译器 无法查看任何文件的内部，除了正在编译的文件以及在头文件中明确包含的文件。Java 编译器可以查看其他文件的内部，只要告诉它到哪里去查看就可以了。

### 静态导入 ###

import 语句不仅可以导人类，还增加了导人静态方法和静态域的功能。 例如，如果在源文件的顶部， 添加一条指令：

import static java.lang.System.\*;

就可以使用 System 类的静态方法和静态域，而不必加类名前缀

另外，还可以导入特定的方法或域： import static java.lang.System.out;

### 将类放入包中 ###

要想将一个类放人包中， 就必须将包的名字放在源文件的开头，包中定义类的代码之 前。例如

package co«.horstiann.corejava;
    public class Employee
    {
    }

如果没有在源文件中放置 package 语句， 这个源文件中的类就被放置在一个默认包 ( defaulf package ) 中。默认包是一个没有名字的包。在此之前，我们定义的所有类都在默认 包中。 将包中的文件放到与完整的包名匹配的子目录中。例如，com.horstmann.corejava 包 中的所有源文件应该被放置在子目录 com/horstmann/corejava ( Windows 中 com\\horstmann\\ corejava) 中。编译器将类文件也放在相同的目录结构中。

编译器在编译源文件的时候不检查目录结构。 例如，假定有一个源文件开头有下 列语句： package com.myconpany; 即使这个源文件没有在子目录 com/mycompany 下， 也可以进行编译。如果它不依赖于其他包， 就不会出现编译错误。但是， 最终的程序将无法运行， 除非先将所有类文件 移到正确的位置上。 如果包与目录不匹配， 虚拟机就找不到类.

### 包作用域 ###

标记为 public 的部分可以被任意的类使用；标记为 private 的部分只能被定义它们的类使用。如果没有指定 public 或 private , 这 个 部 分（类、方法或变量）可以被同一个包中的所有方法访问。

# 八、类路径 #

类存储在文件系统的子目录中。类的路径必须与包名匹配。 另外， 类文件也可以存储在 JAR(Java 归档）文件中。在一个 JAR 文件中， 可以包含 多个压缩形式的类文件和子目录。

JAR 文件使用 ZIP 格式组织文件和子目录。可以使用所有ZIP 实用程序查看内部 的 rt.jar 以及其他的 JAR 文件.

为了使类能够被多个程序共享，需要做到下面几点：

*   把类放到一个目录中， 例如 /home/user/classdir。需要注意， 这个目录是包树状结构 的基目录。如果希望将 com.horstmann.corejava.Employee 类添加到其中，这个 Employee.class 类文件就必须位于子目录 /home/user/classdir/com/horstmann/corejava 中。
 *    将 JAR 文件放在一个目录中，例如：/home/user/archives。
 *   设置类路径（classpath)。类路径是所有包含类文件的路径的集合。而在 Windows 环境中，则以分号（;）分隔： c:\\classdir;.;c:\\archives\\archive.jar

类路径包括：

###  设置类路径 ###

最好采用 -classpath (或 -cp) 选项指定类路径： java -classpath /home/user/dassdir；.；/home/user/archives/archive.jar HyProg

也可以通过设置 CLASSPATH 环境变量 完成这个操作（不推荐）

*  基目录 /home/user/classdir 或 c:\\classes；
 *  当前 目录 (.) ；
 *  JAR 文件 /home/user/archives/archive.jar c:\\archives\\archive.jar

# 九、文档注释 #

JDK 包含一个很有用的工具，叫做**javadoc**, 它可以由源文件生成一个 HTML 文档。

###  注释的插入 ###

javadoc 实用程序（utility) 从下面几个特性中抽取信息：

*  包
 *  公有类与接口
 *  公有的和受保护的构造器及方法
 *  公有的和受保护的域

每个 /\*\* . . . \*/ 文档注释在标记之后紧跟着自由格式文本（ free-form text )。标记由 @开 始， 如@author 或@param。在自由格式文本中，可以使用HTML修饰符。

###  类注释 ###

类注释必须放在import语句之后，类定义之前

###  方法注释 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 3][]

域注释

只需要对公有域（通常指的是静态常量）建立文档

通用注释

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 5][]

### 包与概述注释 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 6][]

### 注释的抽取 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 7][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70]: /images/20220319/a759ccc409cd483195a4544610f71277.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 1]: /images/20220319/33d9b0fb5f07406bb8280a07cdd91f71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 2]: /images/20220319/dc4adc19379a4a69b22cd7113632ebbd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 3]: /images/20220319/040a48982a3e42c4a01d4bc0ee5cb78e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 4]: /images/20220319/3e62603434c342a3a2dbcb6d016a13af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 5]: /images/20220319/03124e7200e04723b6f76e7fea251824.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 6]: /images/20220319/8fbb8e5261e44b48806c2f8210e74ff3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzI2NDcy_size_16_color_FFFFFF_t_70 7]: /images/20220319/c989b2e9f54f4aa89beb964767f88cd4.png