重温Java（五）：面向对象基础
本章目录
1.面向过程和面向对象
2.类和对象
3.this关键字
4.static关键字
5.参数传值机制
6.包（package）
1.面向过程和面向对象
面向过程和面向对象都是对软件分析、设计和开发的一种思想，它指导着人们以不同的方式去分析、设计和开发软件。
面向过程 思想思考问题时，我们首先思考“怎么按步骤实现？”并将步骤对应成方法，一步一步，最终实现。这个适合简单任务，不需要过多协作的情况下。比如，如何开车？
面向过程适合简单、不需要协作的事务。但是当我们思考比较复杂的问题，比如“如何造车？”就会发现列出1234这样的步骤，是不可能的。那是因为，造车太复杂，需要很多协作才能完成。此时面向对象思想就应运而生了。
面向对象（Object Oriented Programming， OOP） 思想更契合人的思维模式。我们首先思考的是“怎么设计这个事物？”比如思考造车，我们就会思考“车怎么设计？”，而不是“怎么按步骤造车的问题”，这就是思维方式的转变。
例如，面向对象思想思考造车，发现车由以下对象组成：
- 轮胎 2. 发动机 3. 车壳 4. 座椅 5. 挡风玻璃
为了便于协作，我们找轮胎厂完成制造轮胎的步骤，发动机厂完成制造发动机的步骤。这样，发现大家可以同时进行车的制造，最终进行组装，大大提高了效率。但是，具体到轮胎厂的一个流水线操作，仍然是按步骤的，还是离不开面向过程的思想。
因此，面向对象可以帮助我们从宏观上把握、从整体上分析整个系统。但是，具体到实现部分的微观操作（就是一个个方法），仍然需要面向过程的思路去处理。
所以，面向对象和面向过程不是对立的，而是相辅相成的。面向对象离不开面向过程。
面向对象和面向过程的总结：
- 都是解决问题的思维方式，都是代码组织的方式。
- 解决简单问题可以使用面向过程
- 解决复杂问题：宏观上使用面向对象思想把握，微观处理上仍然是面向过程。
面向对象思考方式：
遇到复杂问题，先从问题中找名词，然后确立这些名词哪些可以做为类，再根据问题需求确定类的属性和方法，确定类之间的关系。
建议：
- 面向对象具有三大特性：封装性、继承性和多态性，而面向过程没有继承性和多态性，并且面向过程的封装只是封装功能，而面向对象可以封装数据和功能。所以面向对象优势更明显。
- 一个经典的比喻：面向对象就是盖浇饭，面向过程就是蛋炒饭。盖浇饭的好处就是“菜”和“饭”分离。
2.类和对象
类（class）是构造对象的模版，或者图纸，系统根据类的定义来造出对象。我们要造一个汽车，怎么样造?类就是这个图纸，规定了汽车的详细信息，然后根据图纸将汽车造出来。由类构造（construct）对象的过程称为创建类的实例（instance）。
类：我们叫做class。 对象：我们叫做Object,instance(实例)。以后我们说某个类的对象，某个类的实例。是一样的意思。
总结
1.对象是具体的事物；类是对对象的抽象;
2.类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
3.类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法。
类的定义方式：
// 每一个源文件必须有且只有一个public class，并且类名和文件名保持一致！但可以有任意数目的非公有类
public class Car {
}
class Tyre { // 一个Java文件可以同时定义多个class
}
class Engine {
}
class Seat {
}
上面的类定义好后，没有任何的其他信息，就跟我们拿到一张张图纸，但是纸上没有任何信息，这是一个空类，没有任何实际意义。所以，我们需要定义类的具体信息。对于一个类来说，一般有三种常见的成员：属性field、方法method、构造器constructor。这三种成员都可以定义零个或多个。
简单的学生类编写
public class SxtStu {
// 属性（成员变量）
int id;
String sname;
int age;
// 方法
void study() {
System.out.println("我正在学习！");
}
// 构造方法
SxtStu() {
}
}
属性（field，或者叫成员变量）
属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。
属性定义的格式：
[修饰符] 属性类型 属性名 = [默认值] ;
总结：数值默认值为0；布尔值默认为false；对象引用默认为null。
方法（method）
方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法定义的格式
[修饰符] 方法返回值类型 方法名(形参列表) {
// n条语句
}
构造方法（constructor）
构造器也叫构造方法(constructor)，用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法，目的是对象的初始化。构造器的名称应与类的名称一致。Java通过new关键字来调用构造器，从而返回该类的实例，是一种特殊的方法。
声明格式：
[修饰符] 类名(形参列表){
//n条语句
}
要点：
- 通过new关键字调用!!
- 构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。
- 如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加!
- 构造器的方法名必须和类名一致!
- 每个类可以有一个以上的构造器
- 构造器可以有0或多个参数
实例：定义一个“点”(Point)类用来表示二维空间中的点(有两个坐标)。要求如下：
(1) 可以生成具有特定坐标的点对象。
(2) 提供可以设置坐标的方法。
(3) 提供可以计算该“点”距另外一点距离的方法。
class Point {
double x, y;
public Point(double _x, double _y) {
x = _x;
y = _y;
}
public double getDistance(Point p) {
return Math.sqrt((x - p.x) * (x - p.x) + (y - p.y) * (y - p.y));
}
}
public class TestConstructor {
public static void main(String[] args) {
Point p = new Point(3.0, 4.0);
Point origin = new Point(0.0, 0.0);
System.out.println(p.getDistance(origin));
}
}
调用构造器的具体处理步骤：
- 所有数据域被初始化默认值（0、false或null）。
- 按照在类声明中出现的次序，依次序执行所有域初始化语句和初始化块。
- 如果构造器第一行调用了其他构造器，则执行其他构造器的主体。
- 执行这个构造器的主体。
补充知识：构造方法的重载
构造方法重载
构造方法也是方法，只不过有特殊的作用而已。与普通方法一样，构造方法也可以重载。
public class User {
int id; // id
String name; // 账户名
String pwd; // 密码
public User() {
}
public User(int id, String name) {
super();
this.id = id;
this.name = name;
}
public User(int id, String name, String pwd) {
this.id = id;
this.name = name;
this.pwd = pwd;
}
public static void main(String[] args) {
User u1 = new User();
User u2 = new User(101, "高小七");
User u3 = new User(100, "高淇", "123456");
}
}
雷区：如果方法构造中形参名与属性名相同时，需要使用this关键字区分属性与形参。如示例所示：this.id 表示属性id;id表示形参id
类之间的关系
在类之间，最常见的关系有：
- 依赖（use-a）
- 聚合（has-a）
- 继承（is-a）
依赖（dependence），即use-a关系，是一种最明显、最常见的关系；如果一个的方法操纵另一个类的对象，我们就说一个类依赖于另一个类。（应该尽可能将相互依赖的类减至最少，也就是降低类之间的耦合度。）
聚合（aggregation），即has-a关系，是一种具体且易于理解的关系；聚合关系意味着类A的对象包含类B的对象。
继承（inheritance），即is-a关系，是一种用于表示特殊与一般关系的。一般而言，如果类A扩展类B，类A不但包含类B继承的方法，还会拥有一些额外的功能。
对象
对象的三个主要特征：
- 对象的行为（behavior）：可以对对象施加哪些操作，或可以对对象施加哪些方法
- 对象的状态（state）：当施加那些方法时，对象如何响应
- 对象的标识（identity）：如何辨别具有相同行为与状态的不同对象
每个对象都保存着描述当前特征的信息，这就是对象的状态。对象的状态可能会随着调用的方法不同而改变。每个对象都有唯一的身份（identity）。
3.this关键字
对象创建的过程和this的本质
构造方法是创建Java对象的重要途径，通过new关键字调用构造器时，构造器也确实返回该类的对象，但这个对象并不是完全由构造器负责创建。创建一个对象分为如下四步：
- 分配对象空间，并将对象成员变量初始化为0或空
- 执行属性值的显示初始化
- 执行构造方法
- 返回对象的地址给相关的变量
this的本质就是“创建好的对象的地址”! 由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用this代表“当前对象” 。
this最常的用法：
- 在程序中产生二义性之处，应使用this来指明当前对象；普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。
- 使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。
- this不能用于static方法中。
this代表“当前对象”示例
public class User {
int id; //id
String name; //账户名
String pwd; //密码
public User() {
}
public User(int id, String name) {
System.out.println("正在初始化已经创建好的对象：" + this);
this.id = id; //不写this，无法区分局部变量id和成员变量id
this.name = name;
}
public void login() {
System.out.println(this.name + ",要登录！"); //不写this效果一样
}
public static void main(String[] args) {
User u3 = new User(101, "高小七");
System.out.println("打印高小七对象：" + u3);
u3.login();
}
}
运行结果：
this()调用重载构造方法
public class TestThis {
int a, b, c;
TestThis() {
System.out.println("正要初始化一个Hello对象");
}
TestThis(int a, int b) {
// TestThis(); //这样是无法调用构造方法的！
this(); // 调用无参的构造方法，并且必须位于第一行！
a = a; // 这里都是指的局部变量而不是成员变量
// 这样就区分了成员变量和局部变量. 这种情况占了this使用情况大多数！
this.a = a;
this.b = b;
}
TestThis(int a, int b, int c) {
this(a, b); // 调用带参的构造方法，并且必须位于第一行！
this.c = c;
}
void sing() {
}
void eat() {
this.sing(); // 调用本类中的sing();
System.out.println("你妈妈喊你回家吃饭！");
}
public static void main(String[] args) {
TestThis hi = new TestThis(2, 3);
hi.eat();
}
}
4.static关键字
在类中，用static声明的成员变量为静态成员变量，也称为类变量。 类变量的生命周期和类相同，在整个应用程序执行期间都有效。它有如下特点：
- 为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。
- 对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享!!
- 一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例化)访问静态成员。)
- 在static方法中不可直接访问非static的成员。
静态初始块
构造方法用于对象的初始化!静态初始化块，用于类的初始化操作！在静态初始化块中不能直接访问非static成员。
注意事项：静态初始化块执行顺序
- 上溯到Object类，先执行Object的静态初始化块，再向下执行子类的静态初始化块，直到我们的类的静态初始化块为止。
- 构造方法执行顺序和上面顺序一样！！
示例
public class User {
int id; //id
String name; //账户名
String pwd; //密码
static String company; //公司名称
static {
System.out.println("执行类的初始化工作");
company = "北京尚学堂";
printCompany();
}
public static void printCompany() {
System.out.println(company);
}
public static void main(String[] args) {
User u3 = new User();
}
}
静态方法
静态方法是一种不能向对象实施操作的方法。例如，Math类的pow方法就是一个静态方法。在运算时，不使用任何Math对象。
静态方法可以访问自身类中的静态域。
注：Java中允许使用对象调用静态方法。但是避免混淆，一般建议使用类名，而不是对象来调用静态方法。
在以下两种情况使用静态方法：
- 一个方法不需要访问对象状态，其所需参数都是通过显示参数提供。
- 一个方法只需要访问类的静态域
5.参数传值机制
Java中，方法中所有参数都是“值传递”，也就是“传递的是值的副本”。 也就是说，我们得到的是“原参数的复印件，而不是原件”。因此，复印件改变不会影响原件。
- 基本数据类型参数的传值：传递的是值的副本。 副本改变不会影响原件。
- 引用类型参数的传值：传递的是值的副本。但是引用类型指的是“对象的地址”。因此，副本和原参数都指向了同一个“地址”，改变“副本指向地址对象的值，也意味着原参数指向对象的值也发生了改变”。
示例：
public class User {
int id; //id
String name; //账户名
String pwd; //密码
public User(int id, String name) {
this.id = id;
this.name = name;
}
public void testParameterTransfer01(User u) {
u.name = "高小八";
}
public void testParameterTransfer02(User u) {
u = new User(200, "高三");
}
public static void main(String[] args) {
User u1 = new User(100, "高小七");
u1.testParameterTransfer01(u1);
System.out.println(u1.name);
u1.testParameterTransfer02(u1);
System.out.println(u1.name);
}
}
6.包（package）
我们通过package实现对类的管理，package的使用有两个要点：
- 通常是类的第一句非注释性语句。
- 包名：域名倒着写即可，再加上模块名，便于内部管理类。
例如：com.baidu.test
注：写项目时都要加包，不要使用默认包。使用包的主要原因是确保类名的唯一性。
JDK中主要的包
7.导入类import
如果我们要使用其他包的类，需要使用import导入，从而可以在本类中直接通过类名来调用，否则就需要书写类的完整包名和类名。import后，便于编写代码，提高可维护性。
注意要点：
- Java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
- 如果导入两个同名的类，只能用包名+类名来显示调用相关类：java.util.Date date = new java.util.Date();
静态导入
静态导入(static import)是在JDK1.5新增加的功能，其作用是用于导入指定类的静态属性，这样我们可以直接使用静态属性。
//以下两种静态导入的方式二选一即可
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性
public class Test2{
public static void main(String [] args){
System.out.println(PI);
System.out.println(random());
}
}