面向对象（上）

一、概述

    面向过程注重的是功能和行为，而面向对象注重的是具备功能和行为的对象。面向对象是一种基于面向过程的编程思想。
    学过C语言的都知道她是面向过程的，而后来的C++、C#、Java等都在这个基础上，都部分或全部地转移到了面向对象的大阵营中。简单来说就是同样做一件事，面向过程要自己做所有的事，事无巨细面面俱到；而面向对象是先找有没有能做这件事的对象实体，把要做的事委托给对象来做，自己只要调用对象做事，不用管对象是怎么做的。例如：你为远方的好友写信，完了要寄给TA这件事。
    面向过程：（假设没有邮差）你写完信就得自己拿着信，走上几百里地甚至更远的路去 给TA。
    面向过程：有邮差了，写好信直接给邮差付钱就OK了，让邮差给你寄去，不管邮差是 怎么到达怎么给TA的，你只要确认信发到了就好。
    从上述例子可知，面向对象相对于面向过程处理一件事更简单，咱的身份也从执行者变成了指挥者，爽！！！
面向对象有3大特征：封装（encapsulation）   继承（inheritance）   多态（polymorphism）
二、类与对象
    说到特性就要引出一个词“类”，字面意思是具有相同特征的事物的集体。而对于计算机编程语言来说，类是对对象的属性和行为的描述，世间万物都是实体对象，而有些对象有共同的一些属性和行为，为了便于描述和使用，就将这些共同的属性和行为放在类中。这就是说：“类是对象的抽象，对象是类的实例。”
三、封装
1、概述：
    定义：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
    优点： 1、将变化隔离 2、便于使用 3、提高重用性 4、提高安全性
    原则：将不需要对外提供的内容隐藏起来；把自有属性都隐藏，提供公共方法对其访问。
    深入了解3大特征之前要定义一个类，这里用Person表示人这一类事物，人有姓名和年龄这2个属性，人也可以说话。Person类代码如下：

public class Person {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Person() {
		super();
	}

	public void sayHello(){
		System.out.println("Hello,itheima.");
	}
}

    看懂上述代码还需知道Java中的权限修饰符：private、protected、default、public。以下用表格显示出被不同权限修饰符对应的不同访问权限：

    从上面Person类中可以看出，我们每个人的姓名和年龄都是自己的隐私信息，不想让外界直接访问和操作，那就用private修饰变成私有的，仅仅提供getAge()和setAge()供外界访问和操作，这就是Person类对于人这一类事物信息的封装。类一般由成员变量（属性）、成员函数（行为）和构造函数构成。
2、成员变量和局部变量
1）区别 ：
    作用范围：成员变量作用于整个类中；局部变量作用于函数（方法）中或者整个语句中。
    内存位置：成员变量存在于堆内存中；随着对象存在而存在，随着对象消失而消失。局部变 量存在于栈内存中。当方法被调用或语句被执行的时候存在；当方法调用完，或者 语句结束后，就自动释放内存。
    初始值：成员变量有默认初始值；局部变量没有默认初始值，使用前必须赋值。
    定义位置：成员变量定义在类中，方法外；局部变量定义在方法内或者作为方法的形式参数 存在。
Note：使用变量时，遵循就近原则。首先在局部范围找，有就使用；接着在成员方法里找， 有就使用；否则就报错。
2）成员变量赋值的三种方式： 
    a)直接在定义的时候赋值，或者是通过对象名.成员赋值。
    b)通过 set 方法类赋值
    c)在构造函数中赋值（在实例化对象的时候赋值）
3、构造函数
1) 特点： 
    a）函数名与类名相同 
    b） 没有返回类型（无需定义返回值类型） 
    c）没有返回值（不写 return 语句）
2）作用：给对象进行初始化。
Note：
    构造函数是用于创建对象，并对其进行初始化赋值，对象一建立就自动调用相对应的构造函数。对于一个对象，构造函数只执行一次。一般函数是不能直接调用构造函数。
    通常情况下类中有一个默认的空参构造函数，且该构造函数的权限和所属类一致。对于默认构造函数，当一个类中没有定义任何构造函数时，那么系统会默认给该类定义一个空参的构造函数；当在类中自定义了构造函数后，默认的空参构造函数就不存在了（一般情况下建议在自定义类中手动给出无参构造函数）。同一个类中的多个构造函数是以重载的形式存在的。相对于构造函数，成员函数就普通多了，只要按照正常格式和规则定义出来的就是成员函数。
3）构造函数与成员函数的区别：
    a）构造函数与一般函数格式（写法）不同：构造函数和类名相同，并且没有返回类型，也没有返回值；而普通成员函数可以任意起名，必须有返回类型，可以没有返回值。  
    b）构造函数与一般函数作用（运行上）不同：构造函数用于创建对象，并进行初始化值；而普通成员函数是用于完成特定功能的。    
    c）构造函数与一般函数调用方式不同：构造函数是在创建对象时被系统调用的，对于同一个对象只调用一次相应构造函数；而普通成员函数一般是由创建好的对象调用，并且可以调用多次。类中除上述内容之外还会有代码块。
4）代码块：
格式：由{}括起来的代码。
分类：局部代码块（定义在方法中的代码块） 、构造代码块（定义在方法外的代码块）
作用：
    a）局部代码块：控制代码块内变量的生命周期和作用域（使用范围）， 从而提高效率。
    b）构造代码块：把所有构造方法中共同的内容定义在构造代码块。
    c）构造代码块与构造函数都是给对象进行初始化的，但是构造代码块中定义的是同一类下不同对象的共性初始化内容，并且对象一建立就运行，对对象进行统一初始化，优先于构造函数执行。而构造函数是给对象进行特定初始化的。
4、this关键字
1）概述：this代表所在函数所属对象的引用。（简单说，谁调用 this 所在的方法，this 就代表谁。） 
2）this 应用：
    a）用于区分同名成员变量和局部变量。
    b）当定义类中功能时，该函数内部要用到调用该函数的对象时，用 this 来表示这个对象。但凡本类功能内部使用了了本类对象，都用 this 表示。
    c）在构造函数间互相调用对象时，只能用 this（参数）；并且 this（参数）只能定义在构造函数的第一个语句（因为初始化动作要先执行）。
5、static关键字
1）概述：static关键字用于修饰成员（成员变量和成员方法），写在权限修饰符之后，类型名之前。
2）static特点：（被修饰后的成员具备的特点）
    a）随着类的加载而加载。
    b）优先于对象存在。
    c）被所有对象所共享。
    d）可以直接被类名调用（类名.成员）
Note：
    a）静态方法只能访问静态成员（静态方法不能调用、获取非静态变量；非静态方法既可以访问静态，也可以访问非静态。）
    b）静态方法中不可以出现 this、super 关键字（因为静态优先于对象存在）。
    c）主函数是静态的
被static修饰的还有静态代码块，例如：

static{
      System.out.println(“静态代码块输出”);
}

其特点是：随着类的加载而执行，只执行一次，用于给类进行初始化的。
2）实例变量（成员变量）与类变量（静态变量）的区别：
    a）调用方式：静态变量也称为类变量，可以直接通过类名调用，也可以通过对象名调用，这个变量属于类。用 static 修饰 成员变量也称为实例变量，只能通过对象名调用。这个变量属于对象。
    b）存储位置：静态变量存储在方法区中的静态区。成员变量存储在堆内存。
    c）生命周期：静态变量随着类的加载而存在，随着类的消失而消失，生命周期长。成员变量随着对象的创建而存在，随着对象的消失而消失。
    d）与对象的相关性：静态变量是所有对象共享的数据。成员变量是每个对象所特有的数据。
Note：静态变量的优势：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。缺陷：生命周期过长，访问出现局限性。(静态虽好，只能访问静态。)
6、单例设计模式
1）概述：解决某一问题最行之有效的方法，java中共有23种设计模式。此处我们讲解其中之一：单例设计模式。
2）单例设计模式的作用：使一个类在内存中只存在一个对象。用代码实现单例设计模式需要做三部：
    a）将构造函数初始化。
        eg：private SingleModel(){}

    b）在类中创建一个本类对象。
        eg：private staticSingleModel s= newSingleModel（）；
    c）提供一个访问方法可以获取到该对象。
        eg：public staticSingleModel getInstance（）
            {
                  return s;
            }
3）写法：单例设计模式只是为了保证内存中的对象唯一，其他在类中该怎么描述吗，还是怎么描述。单例设计模式有两种写法：
    a）饿汉式：也就是刚三部中的示例语句。它的特点是先初始化对象。如：Single类一进内存，就已经创建好了对象（在实际开发中，出于安全考虑，建议使用饿汉式）。
代码如下：

class SingleModel
{
     private static SingleModels=new SingleModel（）；
     private SingleModel（）{}
     public static SingleModel getInstance（）
     {
          return s；
     }
}

    b）懒汉式：它的特点对象是方法被调用时，才初始化，这也叫对象的延时加载。如：在以下完整代码中，Single类进内存，对象还没有存在，只有调用了getInstance()方法时，才创建对象。

代码如下：

class SingleModel
{
     private static SingleModels=null；
     private SingleModel（）{}
     public static SingleModel getInstance（）
     {
          if（s==null） 
               s=new SingleModel（）；
          return s；
     }
}

下面演示单例设计模式的使用，代码如下：

class Person {
	private static Person person = new Person();
	private Person() {
	}
	public static Person getPerson() {
		return person;
	}
}
public class SingleModel {
	public static void main(String[] args) {
		Person p1 = Person.getPerson();
		Person p2 = Person.getPerson();
		System.out.println("p1==p2::" + (p1 == p2));
		System.out.println("p1.equals(p2)::" + p1.equals(p2));
	}
}

     结果如下：

    本篇幅所描述的仅代表个人看法，如有出入请见谅。