万物皆对象

终于到了对象这里。面向对象程序设计（简称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，但，不包括域。

装饰器：decorator

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

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

转载于:https://www.cnblogs.com/archer-lcy/p/8407432.html

DAY10-万物皆对象-2018-2-2相关推荐

javascript”面向对象编程”- 1万物皆对象
javascript几乎成了如今web开发人员必学必会的一门语言,但很多人却只停在了一些表单验证等基础操作层面上,在面向对象语言大行其道的当下,我们需要去学习javascript的面向对象的知识,以便 ...
python一切皆对象的理解_在 Python 中万物皆对象
在 Python 中一切都是对象,并且几乎一切都有属性和方法.所有的函数都有一个内置的 __doc__ 属性,它会返回在函数源代码中定义的 doc string:sys 模块是一个对象,它有一个叫作 ...
理解“万事万物皆对象”
什么是对象? 对象(Object)是一个应用系统中的用来描述客观事物的实体,是有特定属性和行为(方法)的基本运行单位.是类的一个特殊状态下的实例.对象可以是一个实体.一个名词.一个可以想象为有自己标识 ...
Python源码解读之一万物皆对象(上)
万物皆对象初探对象 Python中一切皆对象,在Python的世界里面,所有东西都是对象.整型.字符串.字典.int.str.list.class自定义类都是对象. 像int.str.list等基本 ...
Java的 “万物皆对象“
面向对象面向过程和面向对象的区别类和对象的关系类和对象的创建类的创建对象的创建构造器构造器重载 this的使用 static修饰代码块包(import) 面向过程和面向对象的区别面 ...
scala(4)-万物皆对象
转载:http://blog.csdn.net/y3wegy/article/details/8024880 Scala作为一个纯面向对象的语言,于是在Scala中万物皆对象,包括数字和函数.在这方面 ...
你还认为JS中万物皆对象？
经常在国内的各大网站博客上看到一句话,叫做JS中万物皆对象,那是否真是如此? 那么,我们先来捋一捋JS中的数据类型,JS中的数据类型有下面几种 Undefined Null Boolean Numbe ...
js对象：从万物皆对象说起
经常见很多文章中说:在js中万物皆对象,但真的万物皆对象吗?答案肯定是否定的先不说概念性的东西,我们随便定义一些变量,然后打印出他们的类型,看如下代码: //先定义一些变量; var iNum = ...
Kotlin入门-万物皆对象，基础类型
Kotlin说:万物皆对象. 可以说,Kotlin全面的接管了所有类型.一统天下. 即是基础,那就需要,通盘了解.按目录来就行.也有Xmind版本 github地址本文将从下面几个方面去讲解数字 ...
万物皆对象，Python的对象概述（简述）
在 Python 的世界中,一切皆对象.int/list/dict / - 都是对象,除此之外,函数.类本身也是对象,那么,这些对象究竟是什么呢? 注 : 要是看不懂, 直接跳转到最后. 从结果看,P ...

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

万物皆对象

DAY10-万物皆对象-2018-2-2相关推荐

最新文章

热门文章