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

Posted Archer-LCY

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了DAY10-万物皆对象-2018-2-2相关的知识，希望对你有一定的参考价值。

　　　

万物皆对象

 

万物皆对象
  • 终于到了对象这里。面向对象程序设计（简称OOP），Java是完全面向对象的。
  1. 使用面向对象思想描述现实世界。
基本步骤：
  • 发现类
  • 如下图：可以将下图的人分为几类
  • 人类/科学家类/演员类/逗比类
  • 找出属性（名词）
  • 姓名、性别、职业、年龄、爱好……
  • 找出行为（动词）
  • 吃饭、说话、表演……
数据抽象：是数据和处理方法的结合
  1. 使用类图描述类
  • 作用：直观容易理解
  • 参考工具：StarUML、Astah UML
 
  •         
  1. 类与对象的关系
  • 类：是抽象概念，仅仅是模板，比如说“演员”、“总统”。类是构造对象的模板和蓝图，用于描述一种数据类型。
  • 对象：是你能够看到摸到的具体实物。
  • 拿小甜饼举例，将类想象成制作小甜饼的机器，而对象就是一个小甜饼。由类构造（construct）对象的过程称作为创建类的实例（instance）。
  • 如图：左边是类，右边是对象
  •             
  • 补充：怎么另一个类中怎么访问其他的类private的变量的方法
  • 在另一个类中，是无法访问其他类的私有属性或方法的。
  • 在内部类可以直接访问。
  • 可以通过定义方法的形式，让内部类调用，以获得方法的返回值。
  1. 类之间的的关系
  • 常见关系有：依赖、聚合、继承
  • 依赖（uses-a）：如果说一个类的方法操纵另一个类的对象，就说一个类依赖于另一个类,我们应该尽可能让相互依赖的类减少，用软件工程的术语来说，就是让类之间的耦合度最小。
  • 聚合（has-a）：类A的对象包含类B的对象。
  • 继承（is-a）：特殊与一般的关系。
  1. 预定义类
  • 在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. 用户自定义类
  • 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类的对象时，构造器会运行，以便将实例域初始化为希望的状态。
  1. 例如：new Employee("Herry", 70000, 1988, 12, 3);    这条代码在创建Employee类实例时，将会把实例域设置为：name=”Herry”;    salary=70000;        hireDay=LocalDate.of(1988,12,3);    
  1. 构造与其他方法不一样的是，构造器总是会伴随着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核心技术》
 
  1. 对象构造
  • 构造器：
  • 特点：没有返回值（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. 一个类中可以有多个构造器，这些构造与类名相同，当存在多个构造方法时，这些方法传递的参数不一样。
  1. 如果一个类中没有构造器也没有main方法，这时候会默认一个无参构造；这个构造器会将所有实例域设置为默认值，即实例域里，数值型为0，布尔型为false，对象变量为null。
  1. 如果类中至少有一个构造器，并且这个构造器不带有参数，这时，如果在构造对象时没有提供参数就会视为不合法的。
  1. 如果构造器中没有显示地给实例域赋值，这时会自动地赋为默认值：数值为0，布尔值为false，对象引用为null。这样，会影响代码的可读性。
  1. 注：在c++中，不能直接初始化类的实例域，所有的域都必须在构造器里面设置。
 
  1. 包
  • 使用包的主要原因是保证类名的唯一性，当两个程序员各自建立了两个类名相同的类时，只要将类放在不同的包中，就不会产生冲突。
  • 为保证包的绝对唯一性，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();但是，这样降低了程序的可读性。
 
  1. 类设计的技巧
  • 保证数据的私有。
  • 数据一定要初始化。
  • 不要在类中使用过多的私有类型。
  • 一个类的职责不应该太多或者太少。
  • 类名和方法名尽可能体现其职责。
  • 优先使用不可变的类。