面向对象编程

1. 什么是面向对象

• 面向过程思想
  • 步骤清晰简单，第一步做什么，第二步做什么…
  • 面对过程适合处理一些较为简单的问题
• 面向对象思想
  • 物以类聚，分类的思维模式，思考问题会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题!
• 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

面向对象编程（Object-Oriented Programming, OOP)
面向对象编程的本质是：以类的方式组织代码，以对象的组织(封装)数据。

抽象

三大特性：

• 封装
• 继承
• 多态

---

从认识论角度考虑是先有对象后有类。对象、是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行的角度是先有类后有对象。类是对象的模板。

2. 类与对象的创建

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。

• 动物、植物、手机、电脑…
• Person类、Pet类、Car类等,这些类都是用来描述/定义某一类具体的事物，应该具备的特点和行为。

对象是抽象概念的具体实例

• 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
• 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

概念总是那么难以让人理解…赶紧写代码吧。

使用new关键字创建对象

• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点
  • 必须和类的名字相同
  • 必须没有返回类型，也不能写void

构造器必须要掌握

这里创建对象的时候使用了全参构造器，如果不写构造器的话，会默认存在一个无参构造器。可以看到输出的结果。两个不同的实例，他们的name以及age都是不一样的。

3. 封装

1、概念：

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

2、好处：

• 只能通过规定的方法访问数据。
• 隐藏类的实例细节，方便修改和实现。

3、封装的实现步骤

需要注意：对封装的属性不一定要通过get/set方法，其他方法也可以对封装的属性进行操作。当然最好使用get/set方法，比较标准。

A、访问修饰符
　从表格可以看出从上到下封装性越来越差。

B、this关键字
1.this关键字代表当前对象

• this.属性 操作当前对象的属性

• this.方法 调用当前对象的方法。

2.封装对象的属性的时候，经常会使用this关键字。

3.当getter和setter函数参数名和成员函数名重合的时候，可以使用this区别。如：

C、Java 中的内部类
　内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

那么问题来了：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！

答：内部类的主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据。

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便。

内部类可分为以下几种：

• 成员内部类
• 静态内部类
• 方法内部类
• 匿名内部类　　
  各个内部类的具体使用请转移到另一篇文章：各种内部类说明

4. 继承、多态

这里笔者感觉写的比较好的一篇文章，附上链接：JAVA封装、继承、多态详解

5. 补充

如果看了链接之后感觉文字的内容难以理解，或者理解了想通过代码进一步加深理解。那么我编写了以下三个类供大家理解。Animal 即动物类，是一个父类。 Dog类 、Cat类 都是Animal的子类。并且Dog类和Cat类都继承并且重写了Animal类的eat()方法。并且Dog类和Cat类都存在自己独有的方法，Dog类中的wangwang() 和 Cat类中的 miaomiao()方法。

1. Animal类代码。

//父类，动物类
public class Animal {
   private String name;
   private int age;

   public void eat(){
       System.out.println("吃东西");
   }
}

2. Dog类代码。

public class Dog extends Animal{
   @Override
   public void eat() {
       System.out.println("狗吃东西....");
   }

   public void wangwang(){
       System.out.println("汪汪.......");
   }
}

3. Cat类代码

public class Cat extends Animal{
   @Override
   public void eat() {
       System.out.println("猫吃东西....");
   }

   public void miaomiao(){
       System.out.println("喵喵.....");
   }
}

下面通过主方法来向大家说明以下 多态的问题。在这里，Animal父类的name和age字段是private类型的。所以子类Cat和Dog都无法直接点出来。
我们可以通过使用get\set方法在里面对Animal 的字段进行封装。这里就体现了封装的理念。继承的话就是使用 extends ，Cat类和Dog类都继承了Animal类。Java中是单继承，即一个父类可以有很多个子类。但是子类只能有一个父类，即只能有一个extends。 但是可以多实现 Implement。

在这里，主要来说明一下多态的问题。应该多态是大家最不好理解的地方。
我们先附上测试的代码。

//Demo01 类 , 启动类
public class Demo01 {
    //main方法
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat();

        //多态
        Animal dog = new Dog();
        dog.eat();      //狗吃东西....

        //父类的引用指向子类的时候，只能调用父类存在的方法
        //父类的引用指向子类的时候，会优先执行子类重写的方法
        Animal cat = new Cat();
        cat.eat();      //猫吃东西....

        //子类的引用指向本类的时候，可以调用子类所有的方法
        Dog dog1 = new Dog();
        dog1.wangwang(); //汪汪.......
        dog1.eat();     //狗吃东西....

        Cat cat1 = new Cat();
        cat1.miaomiao();

        //不能使用一个子类的引用来指向父类的对象
        //Cat cat2 = new Animal();

        //向上转型，可以直接转，小类型转换到大类型
        Animal animal1 = dog1;
        /*向上转型后，animal1只能调用父类Animal存在的方法，Dog子类中的
          wangwang()方法不能被调用，即本类的实例只能调用本类或父类存在的方法。
        */
        animal1.wangwang();

        //向下转型， 强制类型转换
        Dog dog2 = (Dog) animal;

    }

}

我们来看一下运行的结果：

吃东西
狗吃东西…
猫吃东西…
汪汪…
狗吃东西…

解释：

• 父类的引用可以指向本类的对象。
• 父类的引用可以指向子类的对象；

不管父类引用的是本类还是子类的对象。都只能调用本类存在的方法和本类继承的父类的方法。比如 所有Animal的引用，都只能调用 Animal类的eat方法以及Animal继承的Object类的一堆方法比如 toString方法。

• 当父类的引用可以指向本类的对象时，调用的是本类的eat方法。
• 当父类的引用可以指向子类的对象时，调用的是子类重写(Override)的eat方法。

子类的引用可以调用子类自己独有的方法，即Cat的引用可以调用miaomiao()方法。Dog的引用可以调用wangwang()方法。

总之一句话：本类的方法只能调用本类的方法和本类继承的所有方法。

---

向上转型（隐式/自动类型转换）：是小类型转换到大类型。
向下类型转换(强制类型转换)，是大类型转换到小类型(有风险,可能出现数据溢出)。