面向对象（OOP）

面向对象&面向过程

• 面向过程思想：
  • 步骤清晰简单，第一步做什么、第二步做什么……
  • 面对过程适合处理一些较为简单的问题
• 面对对象思想：
  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

面向对象简介

OOP ：Object-Oriented Programming

面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据

核心思想：抽象

三大特性：封装、继承、多态

方法回顾

• 方法的定义：

  • 修饰符

    访问修饰符：public、protect、default、private四种访问访问权限：public>protected>default>private

    非访问修饰符：static、final、abstract、synchronized 和 volatile

  • 返回类型

  • break&return

  • 方法名

  • 参数列表

  • 异常抛出：

    public void readFile(String file) throws IOException{    
        
    }
    

• 方法的调用：

  • 静态方法（static）

    1. 静态方法可以直接调用，而非静态方法需要实例化。比如在Student类中定义say方法，如果加了static修饰符，可以在另外一个类Demo中，直接使用Student.say();如果没添加static，需要new一个Student对象再调用。

    2. static方法是和类一起加载的，非静态方法要在类实例化之后才存在。比如在同一个类中，定义两个方法：a()、b()。如果两个方法都不是静态，a可以直接调用b（反正都要初始化之后才能用）；如果两个方法都是静态，a也可以直接调用b（类定义好两个方法就存在了）；但如果a是静态而b是非静态，则a无法直接调用b（a已经存在，b需要实例化之后才存在，不能调，反之b调a则可行）。

    3. static可以看作是类的方法，而非static可以看作是对象的方法。

          public void a(){
               b();              //非静态调用非静态
           }
           public void b(){
           }
       //------------------------
           public static void a(){
               b();              //静态调用静态
           }
           public static void b(){
           }
       //-------------------------
           public static void a(){
               b();               //静态调用非静态，报错
           }
           public void b(){
           }
       

  • 非静态方法

  • 形参和实参

  • 值传递和引用传递

  • this关键字

类和对象的关系

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

创建和初始化对象

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

构造器必须要掌握！

如果一个类什么都不写，也会存在一个方法（构造器），构造方法可以在编译好的class文件中查看

当然也能显示定义构造器。定义有参构造之后，如果想使用无参构造，需要显示的定义一个无参构造

使用new关键字必须要有构造器，本质就是在调用构造器

快捷键：将鼠标光标放在类代码块内，按下alt+insert，可快速生成构造函数

内存分析

public class Pet {
    String name;
    int age;

    public void shout()
    {
        System.out.println("C++isthebestlanguage.java");
    }
}

public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "wangcai";
        dog.age = 3;
        dog.shout();

        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

1. 将Application类加载到方法区，里面有个main方法，以及常量池：wangcai
2. main方法入栈
3. new Pet()，将pet类也加载进方法区
4. 栈里生成个dog（引用变量名），堆里面生成个dog对象（实体），堆里的dog包含地址、属性、方法
5. 给dog的属性赋值

注：

• 栈里的dog是对象实体的引用变量，而非对象实体本身
• 对象实体本身创建在堆中，它的引用变量创建在栈中
• 对象的引用变量可以理解为指针，存在的对象实体的引用

封装

程序设计追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是暴露少量的方法给外部使用。

封装（数据的隐藏），通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

属性私有，get/set

• 将属性前加private，即只能在本身的class中使用，无法在其他类中赋值。
• 提供一些public的get、set方法

快捷键：alt+insert可自动生成get与set

封装能避免一些不合法的问题，比如说对于一个Person类的age属性，可以在setAge中判断年龄区间，避免输入一些不合理的数据。

• 提高程序的安全性，保护数据
• 隐藏代码的实现细节
• 统一接口
• 提高系统可维护性

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

extends的意思是“扩展”。子类是父类的扩展

Java里没有多继承

概述

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
• 子类和父类之间，从意义上讲应该具有“is a”的关系。

特性

• 子类继承父类，就会有父类的全部方法
• 父类的public属性可以直接拥有，private属性只有父类自己可以用（一般属性都定义为private）
• 在Java中，所有的类都默认直接或者间接继承Object类

super

• 用以访问父类的属性、调用父类的方法。

• private的属性无法访问，可以访问protected属性（总结下就是private的东西无法被继承）

• new子类的时候，在调用子类的构造函数之前会默认调用父类的构造函数（有一行看不见的代码super()）。如果想显示的显示父类的构造函数，super()必须放在子类构造函数的第一行

• 注意点：

  1. 根据前面构造器的知识点，如果显示定义了一个有参构造函数，那么就没有默认的无参构造了。因此，如果父类定义了 有参构造而没有显示定义无参，那么子类就无法隐式的实现无参构造，因为子类构造函数第一步就是调用父类的构造函数（super()），此时父类已经没有无参了，自然实现不了。不过可以在子类里定义个有参的。

  2. super必须只能出现在子类的方法或者构造方法中。

  3. super和this不能同时调用构造方法。（在构造函数中使用this()实现递归。不过如果是子类就没法这样用，因为子类里有个super()）

方法重写（override）

• 重写都是方法的重写，和属性无关。

• 只有非静态的方法才能重写

  //A、B的test都是static的
  public class B {
      public static void test(){
          System.out.println("B=>test");
      }
  }
  public class A extends B {
      public static void test() {
          System.out.println("A=>test");
      }
  }
  public class Applicaton {
      public static void main(String[] args) {
          A a = new A();
          a.test();                                // A=>test
  
          B b = new A();
          b.test();                                // B=>test
      }
  }
  

  //A、B的test都是非static的
  public class B {
      public void test(){
          System.out.println("B=>test");
      }
  }
  public class A extends B {
      public void test() {
          System.out.println("A=>test");
      }
  }
  public class Applicaton {
      public static void main(String[] args) {
          A a = new A();
          a.test();                                // A=>test
  
          B b = new A();
          b.test();                                // A=>test
      }
  }
  

  以上两个例子的解释：

  • 父类的引用可以指向子类。
  • 方法的调用只和左边（定义的数据类型）有关（可以调用继承来的方法，但是没有的就是没法用）。
  • 静态方法是类的方法，而非静态方法是对象的方法。
  • B b = new A()，可以看作栈里有一个B类型的b，指向堆里A对象的实例，即父类的引用指向子类。那么，在第一个例子里，调用b.test()时，由于A、B类的test函数都是静态的，即都是类的方法，并不是对象的方法，所以b调用不了对象A的方法，只能调用自己那个类的test方法，故第一个例子会输出B=>test。而第二个例子，由于不是static方法了，非静态方法属于对象的方法，b正好指向A对象，调用A的test方法，故输出A=>test。By the way，由于不是static方法，所以A在继承B的时候，能把test方法给重写了。假如上面的例子中，A类新增个public的方法try，b虽然指向A的实例对象，但是是无法调用try方法的，这就是方法的调用只和左边有关。

• 注意重写和重载别搞混了：重载是一个类里同名的函数，参数列表不同；重写需要有继承，是子类把父类的方法实现方式给改变了。

• 重写的几个注意事项：

  1. 方法名必须相同，方法体不同

  2. 参数列表必须相同

  3. 修饰符：范围可以扩大，但是不能缩小。public>protected>default>private，比如：父类的是default，子类重写后可以变为protect。

     注：如果父类的方法被private修饰则无法重写

  4. 抛出的异常：异常的范围可以被缩小，但不能扩大。

     解释:在编译的时候的异常是父类定义的,如果子类抛出的异常比父类的大,在运行的时候执行的是子类的方法，就会有代码风险

• 为什么需要重写：

  父类的功能，子类不一定需要，或者不一定满足

快捷键：Ctrl + h 显示继承关系

多态

编译看左边，运行看右边！

实现动态编译：类型可扩展性 见上一章节（继承）的例子B b = new A()

一个对象的实际类型是确定，但是指向的引用类型不确定，可以是其父类

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大

父类型可以指向子类，但是不能调用子类的方法；子类引用不可以指向父类

以上几点可参考上一章方法重写那个小节的例子

高类型可强制类型转换为低类型（父类强转子类），这样能调用子类的方法。

public class Person {
        public void run(){
            System.out.println("run");
        }
}
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }
}
public class Application {
    public static void main(String[] args) {
        // 一个对象的实际类型是确定的
        // new Student()
        // new Person()
        //但是可以指向的引用类型就不确定了
        Student s1 = new Student();
        Person s2 = new Student(); // 父类的引用指向子类
        Object s3 = new Student();

        s2.run();  //子类重写了父类
        s1.run();
        s2.eat();   //这一步会报错，对象能执行哪些方法，主要看对象左边的类型
        ((Student)s2).eat();  //父类向子类强转！！！
    }
}

注意事项：

1. 多态是方法的多态，属性没多态

2. 父类和子类，有联系才会有多态。否则会有类型转异常。ClassCastException!

3. 多态存在条件：继承关系、方法重写、父类引用指向子类对象 Father f1 = new Son();

   总结下方法无法重写的情况（方法不重写，自然没多态）：

   1. static方法，属于类，不属于实例
   2. final修饰常量
   3. private方法

instanceof （类型转换）引用类型

之前基本类型所讲的高低指容量大小，在这就是父类子类了。

instanceof可判断一个对象是否为某一个类型，或者是这个类型的子类

System.out.println(x instanceof y);    //是否能过编译通过（是否有父子关系）
    				       //x指向的类型若为y的类或其子类则为true

1. 先看左边，x的类，是否和y的类有关系，只要有父子关系（无论谁是谁父类），编译就能通过
2. 再看右边，x指向哪个类，指向的那个类如果为y类的同一个类或是子类，则返回true，若x指向的类为y的父类，则返回false

类型转换：父（高） 子（低），高转低，要强转；低转高自动转（可能会丢失一些方法）