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

　　　

万物皆对象

 

万物皆对象

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

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

基本步骤：

• 发现类

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

• 

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

• 找出属性（名词）

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

• 找出行为（动词）

• 吃饭、说话、表演……

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

2. 使用类图描述类

• 作用：直观容易理解

• 参考工具：StarUML、Astah UML

 

•         

3. 类与对象的关系

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

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

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

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

•             

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

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

• 在内部类可以直接访问。

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

4. 类之间的的关系

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

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

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

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

• 

5. 预定义类

• 在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语言中访问器和更改器没有明显的语法区别。

 

 

6. 用户自定义类

• 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();

    }

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

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

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核心技术》

 

7. 对象构造

• 构造器：

• 特点：没有返回值（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(...)，如：

 

 

构造器小结注意事项：

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

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

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

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

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

 

8. 包

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

• 为保证包的绝对唯一性，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();但是，这样降低了程序的可读性。

 

9. 类设计的技巧

• 保证数据的私有。

• 数据一定要初始化。

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

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

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

• 优先使用不可变的类。

 

 

 

• ---

   基本定义：继承是一种is-a的关系，比如上一篇中提到的Employee类（员工类）和Manager类（经理类），实际上经理也是属于员工，但是，待遇跟普通员工不一样，就可以把Employee类当做父类（或者称为超类、基类），而把Manager看做是子类。用关键字extends表示继承。

  ---

  ---

  覆盖方法：当父类有些方法在子类中不适用是，子类中可以写一个新的方法覆盖父类的方法。例如，员工的总工资就是当月工资（在父类中的getSalary方法），而经理的工资是当月工资加奖金，这时候，我们可以在Manager类中改写getSalary方法。

  ---

 

• ---

 

• ---

  强制性类型转换：不单单是基本类型之间可以强制性装换，也可以将一个对象引用强制性转换为另一个对象引用。在Java中，每个对象变量都属于一个类型。一般，在转换之前我们要检查是否可以进行强制性转换。

  ---

  ---

  注意：在Java中，子类数组的引用可以转化为父类数组的引用，不需要采用强制性转化，而父类转化为子类需要强制性转化。就拿Employee类与Mananger类来说，不是所有的员工都是经理。

  ---

  ---

  因此，1、只能在继承层次内进行类型转换。 2、将父类转化为子类之前，应该使用instanceof进行检查。

  ---

  ---

  假如想要阻止人们定义某个类的子类，这时候就可以在定义这个类的时候使用final修饰符。对于final来说，在构造对象之后，就不允许改变它们的值了。如果一个类被声明为final类，这个类中的所有方法也会默认为final，但，不包括域。

  ---

  

装饰器：decorator

组件：Component，相当于JavaIO中的InputStream/Read/writer

JavaIO：核心类的设计使用了装饰模式