首页 > > 程序设计 > Java技术 >

DAY10-万物皆对象-2018-2-2

2018-06-18 03:31:01来源：未知阅读 ()

万物皆对象

终于到了对象这里。面向对象程序设计（简称OOP），Java是完全面向对象的。

使用面向对象思想描述现实世界。

基本步骤：

发现类

如下图：可以将下图的人分为几类

人类/科学家类/演员类/逗比类

找出属性（名词）

姓名、性别、职业、年龄、爱好……

找出行为（动词）

吃饭、说话、表演……

数据抽象：是数据和处理方法的结合

使用类图描述类

作用：直观容易理解

参考工具：StarUML、Astah UML

类与对象的关系

类：是抽象概念，仅仅是模板，比如说“演员”、“总统”。类是构造对象的模板和蓝图，用于描述一种数据类型。

对象：是你能够看到摸到的具体实物。

拿小甜饼举例，将类想象成制作小甜饼的机器，而对象就是一个小甜饼。由类构造（construct）对象的过程称作为创建类的实例（instance）。

如图：左边是类，右边是对象

补充：怎么另一个类中怎么访问其他的类private的变量的方法

在另一个类中，是无法访问其他类的私有属性或方法的。

在内部类可以直接访问。

可以通过定义方法的形式，让内部类调用，以获得方法的返回值。

类之间的的关系

常见关系有：依赖、聚合、继承

依赖（uses-a）：如果说一个类的方法操纵另一个类的对象，就说一个类依赖于另一个类,我们应该尽可能让相互依赖的类减少，用软件工程的术语来说，就是让类之间的耦合度最小。

聚合（has-a）：类A的对象包含类B的对象。

继承（is-a）：特殊与一般的关系。

预定义类

在java中，没有类就无法做任何事情，然而，并不是所有类都具有面向对象特征，例如：Math类。

对象与对象变量：想要使用对象就必须先构造对象，并指定其初始状态。

区别：Date deadline;//deadline does not refer to any object，

实际上等同于c++中：Date* deadline;

定义了一个对象变量deadline，它可以引用Date类型的对象。但是，一定要认识到：变量deadline不是一个对象，也没有引用对象。首先要初始化这个变量：deadline=new Date();如果是deadline=null;表明这个对象目前没有引用任何对象。

两个变量引用一个对象：（一个对象变量没有包含实际包含一个对象，而仅仅引用一个对象。在Java中任何对象变量的值都是对存储在另外一个地方的一个对象的引用。New操作符的返回值也是一个引用。）

在c++中，稍不小心就可能创建一个错误的指针，或者造成内存溢出。而在Java语言中，这些问题都不存在，如果使用一个没有初始化的指针，会报错，而不是随机运行的结果；同时，不必担心内存的管理问题，垃圾收集器将会处理相关的事宜。

Java 类库中的 LocalDate 类

时间是用距离一个固定时间点的毫秒数（可正可负）表示的，这个点就是所谓的纪元（ epoch), 它是 UTC 时间 1970 年 1 月 1 日 00:00:00。 UTC 是 Coordinated Universal Time 的缩写，与大家熟悉的 GMT ( 即 Greenwich Mean Time, 格林威治时间）一样，是一种具有实践意义的科学标准时间。

不要使用构造器来构造 LocalDate 类的对象。

Local Date.now() 会构造一个新对象，表示构造这个对象时的日期。

可以提供年、月和日来构造对应一个特定日期的对象： LocalDate.of(1999, 12, 31)；

当然，通常都希望将构造的对象保存在一个对象变量中： LocalDate newYearsEve = Local Date.of(1999, 12, 31);

一旦有了一个 LocalDate 对象，可以用方法 getYear、 getMonthValue 和 getDayOfMonth 得到年、月和日：

int year = newYearsEve.getYearO; // 1999

int month = newYearsEve.getMonthValueO; // 12

int day = newYearsEve.getDayOfMonth(); // 31

看起来这似乎没有多大的意义，因为这正是构造对象时使用的那些值。不过，有时可能某个日期是计算得到的，你希望调用这些方法来得到更多信息。例如， plusDays 方法会得到一个新的 LocalDate, 如果把应用这个方法的对象称为当前对象，这个新日期对象则是距当前对象指定天数的一个新日期：

LocalDate aThousandDaysLater = newYearsEve.piusDays(1000);

year = aThousandDaysLater.getYearO；// 2002

month = aThousandDaysLater.getMonthValueO; // 09

day = aThousandDaysLater.getDayOfMonth(); // 26

LocalDate 类封装了实例域来维护所设置的日期。如果不查看源代码，就不可能知道类内部的日期表示。当然，封装的意义在于，这一点并不重要，重要的是类对外提供的方法。

更改器方法与使用器方法

1、访问器方法（accessor method）：只访问对象而不修改对象的方法。例如：LocalDate.getYear和GregorianCalendar.get。

LocalDate aThousandDaysLater = newYearsEve.plusDays(1000);调用newYearEve.plusDays之后不会改为1000之后的日期，实际上plusDays方法没有更改调用这个方法的对象，而是，plusDays方法会产生一个新的LocalDate对象，然后把这个新对象赋给aThousandDaysLater变量，原来对象不做任何改动。

2、更改器方法（mutator method）：对象的方法会改变

有一个GregorianCalendar方法是更改器方法，可以用于增加1000天：

CregorianCalendar so

meDay = new CregorianCalendar(1999, 11, 31); //注意月份是从0-11

someDay.add(Calendar.DAY_0F _M0NTH, 1000);

注：在c++中，带有const后缀的方法是访问器方法；默认为更改器方法。但是，在Java语言中访问器和更改器没有明显的语法区别。

用户自定义类

1、写先出一个简单的Employee类作为例子说明。

代码如下：

注意：

在这个示例中包含两个类，一个是Employee类，一个是带有public访问修饰符的EmployeeTest类。其中EmployeeTest类中包含了main方法。

源文件名是EmployeeTest.java ，这是因为文件名必须与public类的名字相匹配。在一个源文件中，只能有一个共有类，但非共有类的数目可以任意。

当编译这段源代码时，编译器将在目录下创建两个类文件：EmployeeTest.class和Employee.class 。

程序中包含main方法的类名提供字节码解释器，以便启动这个程序：java EmployeeTest ，字节码解释器开始运行EmployeeTest类的main方法的代码。在这段代码中，定义了Employee类的数组，里面有三组，先后构造了三个新的Employee对象，并显示它们的状态。

多个文件的使用

在EmployeeTest.java一个源文件中包含了两个类。但一般情况下，我们习惯于每一个类放在一个单独的源文件中。例如，将EmployeeTest类放在EmployeeTest.java中，而将Employee类放在Employee.java中。

如果习惯上述所说的分开组织文件的方法，可以采用下面三种编译源程序的方法：

注：每次在命令提示符窗口使用前记得先用dir，查看当前目录，这样可以避免不必要的尴尬错误。还需要注意的一点是javac和java时必须是在文件所在目录，如下图：

使用通配符调用java编译器：javac EmployeeTest*.java ，此时，所有的与通配符匹配的源文件都将被翻译成类文件。编译成功结果如下：

第二种是使用：javac EmployeeTest.java ，编译成功结果如下：

第三种：如果想独立测试使用：java EmployeeTest 这种方法可以将结果打印在命令提示符窗口，结果如下图：

（4）第四种：（如果该类是一个更大应用程序的一部分，可以用）：java Application

对Employee类剖析

这个类里面有一个构造器和5方法：

/**构造器*/

public Employee(String name, double salary, int year, int month, int day)

/**5个方法*/

public void output()

public String getname()

public double getSalary()

public LocalDate getHireDay()

public void raiseSalary(double byPercent)

所有方法都被public标记。关键字public意味着任何类的任何方法都可以调用这些方法。

在Employee类中有3个示例域用来存放将要操作的数据：

private String name;

private double salary;

private LocalDate hireDay;

关键字private确保只有Employee类自身才能访问这些实例域，而其他类的方法不可以。

注：可以有public来标记实例域，但是，这是一张极不为提倡的方法。public数据域允许程序中的任何方法都能对其进行读取和修改，这就破坏了封装。任何类任何方法都可以修改public与，这意味着某些代码将可以使用这种存取权限，这是我们不希望看到的。

注：有两个实例域本身就是对象：name域是String类的对象，hireDay域是LocalDate类的对象。其实，这种情形十分常见：类通常包括类型属于某个类类型的实例域。

4、构造函数的使用

A.从Employee类的构造器开始分析

public Employee(String name, double salary, int year, int month, int day) {

super();

this.name = name;

this.salary = salary;

this.hireDay = LocalDate.of(year, month, day);

output();

}

可以看到构造器与类名相同，在构造Employ类的对象时，构造器会运行，以便将实例域初始化为希望的状态。

例如：new Employee("Herry", 70000, 1988, 12, 3); 这条代码在创建Employee类实例时，将会把实例域设置为：name=”Herry”; salary=70000; hireDay=LocalDate.of(1988,12,3);

构造与其他方法不一样的是，构造器总是会伴随着New操作符的执行而被调用，而对一个已存在的对象不能调用构造器来达到从新调用的目的。例如：Herry.Employee("Herry", 70000, 1988, 12, 3); 会产生编译错误。

隐式参数与显式参数

隐式参数：出现在方法名之前的。

显式参数：位于方法名后面的括号中的。

方法用于操作对象以及存取它们的实例域。将调用这个方法的对象的salary实例域设置为新值。例如：方法：

public void raiseSalary(double byPercent) {

double raise = salary * byPercent / 100;

salary += raise;

}

在每一个方法中，关键字this表示隐式参数。可以用下面方式编写上面的方法：（这样的优点：这样可以将实例域与局部变量区分开来）

public void raiseSalary(double byPercent) {

double raise = this.salary * byPercent / 100;

salary += raise;

}

注意隐式构造和参数化构造不能共存：尽量把带参构造和默认构造都写出来，当你不把默认构造显示出来时，带参构造会将其覆盖，后面第二次使用时就会出错。

如下图：左边两组是带默认参数，不会报错；右边是不带默认参数，会报错（红色波浪线部分）

在Java中，所有的方法都必须在类的内部定义，但并不是内联（inline）方法。是否将某个变量设置为内联方法是Java虚拟机的任务

封装

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。

优点：（1）一旦在构造器中设定完毕，就没有任何一个办法可以对其修改，这样确保其不会被破坏，安全系数增加。

（2）更改器可以执行错误检查，而直接对域进行赋值就不会有这些处理。

静态方法

下面的情况适合使用静态方法：

一个方法不需要访问对象状态，其所需参数都是通过显式参数提供（例如：Math.pow）

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

Java中的静态域和静态方法在功能上与c++相同，不同的是语法书写上不一样。Java中用 . 如：Math.pow；而c++中是用::操作符访问，如：Math::PI。

关于“static”：起初，C 引入关键字 static 是为了表示退出一个块后依然存在的局部变量在这种情况下，术语“ static” 是有意义的；变量一直存在，当再次进入该块时仍然存在。随后， static 在 C 中有了第二种含义，表示不能被其他文件访问的全局变量和函数。为了避免引入一个新的关键字，关键字 static 被重用了。最后， C++ 第三次重用了这个关键字，与前面赋予的含义完全不一样，这里将其解释为：属于类且不属于类对象的变量和函数。这个含义与 Java 相同。

-------摘自《Java核心技术》

对象构造

构造器：

特点：没有返回值（void不是）、方法名和类名一致（方法名一样，参数不一样，参数可以有0个或者1个或者多个构造方法的重载）、每个类可以有一个以上的构造器、构造器总是伴随着new操作一起调用

（2）可以指定参数及实现重载

（3）注：java构造器的工作方式和C++一样。但是，所有java对象都是在堆中构造的，构造器总是伴随着new操作符一起使用。Employee number("Herry", 70000, 1988, 12, 3); //在c++中是正确的

（4）警告！！：不要在构造器中定义和实例域重名的局部变量。例如

public Employee(String n, double s, . . ){

String name = n;

double salary = s;

} //是错误的

在上述错例中，在这个构造器中声明了局部变量name和salary。这些变量只能在构造器内部访问。这些变量屏蔽了同名的实例域。

在构造器内调用同一个类的构造器，可以用到this关键字，this(...)，如：

构造器小结注意事项：

一个类中可以有多个构造器，这些构造与类名相同，当存在多个构造方法时，这些方法传递的参数不一样。

如果一个类中没有构造器也没有main方法，这时候会默认一个无参构造；这个构造器会将所有实例域设置为默认值，即实例域里，数值型为0，布尔型为false，对象变量为null。

如果类中至少有一个构造器，并且这个构造器不带有参数，这时，如果在构造对象时没有提供参数就会视为不合法的。

如果构造器中没有显示地给实例域赋值，这时会自动地赋为默认值：数值为0，布尔值为false，对象引用为null。这样，会影响代码的可读性。

注：在c++中，不能直接初始化类的实例域，所有的域都必须在构造器里面设置。

使用包的主要原因是保证类名的唯一性，当两个程序员各自建立了两个类名相同的类时，只要将类放在不同的包中，就不会产生冲突。

为保证包的绝对唯一性，sun公司建议将公司的因特网域名（这是独一无二的）以逆序形式作为包名。例如：banana.com ，逆序变为com.banana。

从编译器角度来看，嵌套的包之间没有任何联系。

一个类可以使用包中的所有类，以及其他包中的公有类（public class）。访问另一个包中的公有类的两种方法：

每个类名之前添加完整的包名（繁琐），例如：java.time.LocalDate today =java.time.LocalDate.now();

我们常用的方法是使用import导入包，import语句应位于源文件的顶部（位于package语句后面），这样就无需在前面加前缀了。例如：import java.time.LocalDate;这时候就可以使用：LocalDate today=LocalDate.now();

当两个包中含有相同的类名时，在使用时，编译器无法识别要使用哪个类，这时候我们可以在使用的语句加前缀。例如，两个不同的类中都含有Date类时，可以这样表示：

注：在 C-H■ 中，与包机制类似的是命名空间（namespace)。在 Java 中， package 与 import 语句类似于 C+H■ 中的 namespace 和 using 指令。

静态导入：如：import static java.lang.System.*;这时候就可以这样写了out.println();但是，这样降低了程序的可读性。

类设计的技巧

保证数据的私有。

数据一定要初始化。

不要在类中使用过多的私有类型。

一个类的职责不应该太多或者太少。

类名和方法名尽可能体现其职责。

优先使用不可变的类。

基本定义：继承是一种is-a的关系，比如上一篇中提到的Employee类（员工类）和Manager类（经理类），实际上经理也是属于员工，但是，待遇跟普通员工不一样，就可以把Employee类当做父类（或者称为超类、基类），而把Manager看做是子类。用关键字extends表示继承。
覆盖方法：当父类有些方法在子类中不适用是，子类中可以写一个新的方法覆盖父类的方法。例如，员工的总工资就是当月工资（在父类中的getSalary方法），而经理的工资是当月工资加奖金，这时候，我们可以在Manager类中改写getSalary方法。

强制性类型转换：不单单是基本类型之间可以强制性装换，也可以将一个对象引用强制性转换为另一个对象引用。在Java中，每个对象变量都属于一个类型。一般，在转换之前我们要检查是否可以进行强制性转换。
注意：在Java中，子类数组的引用可以转化为父类数组的引用，不需要采用强制性转化，而父类转化为子类需要强制性转化。就拿Employee类与Mananger类来说，不是所有的员工都是经理。
因此，1、只能在继承层次内进行类型转换。 2、将父类转化为子类之前，应该使用instanceof进行检查。
假如想要阻止人们定义某个类的子类，这时候就可以在定义这个类的时候使用final修饰符。对于final来说，在构造对象之后，就不允许改变它们的值了。如果一个类被声明为final类，这个类中的所有方法也会默认为final，但，不包括域。