一.面向对象

• 需要记住的知识点
  • 面向对象的特征
    • 继承
      • java只支持单继承，不支持多继承，但是可以形成继承体系
      • 接口倒是可以继承（实现）多个。
      • 子类继承父类，在子类初始化时，会先调用父类的初始化，否则子类是无法使用父类的方法和成员变量的；
        • 默认子类调用父类的无参构造。如果父类显式声明了有参构造，系统不会默认生成父类的无参构造，因此子类默认调用父类的无参构造也就无从说起，编译时报错。此时需要使用super.父类已有构造 来实现父类的初始化
        • 成员方法和成员变量的调用遵循就近原则，如果子类和父类存在同名的成员变量和方法，子类会优先使用本类的成员变量和方法。如果想调用同名的父类方法和成员变量，就必须使用supper关键字，来显式的表示这是父类的。
        • 如果子类中的方法名与父类中的方法名同名，就叫方法重写（override）。方法重载（overload）是多态的表现。
    • 多态
    • 封装
      • 使用this关键字，表示当前对象。this.成员变量 表示当前对象的成员变量。this.成员方法 表示当前对象的成员方法。
      • 详见后续封装介绍：接口与抽象类
      • 所谓的重构，就是不断抽象的过程

           

  • 对象的构成
    • 构造器
      • 构造代码块
        • 构造代码块是所有构造函数同类型的抽象，每调用一次构造函数，都会在构造函数的第一行执行构造代码块。
        • 构造代码块是没有static关键字修饰的，但是静态代码块有。
        • 静态代码块是随着类的加载而加载的，主要对类初始化。构造代码块是对象的初始化，每创建一个对象都会先执行构造代码块。构造方法是用来创建对象的。创建对象时，先调用构造方法，然后构造代码块是构造方法中第一个执行的命令。
      • 代码示例
        • 创建对象

          package oop;
          
          /**
           * 测试构造代码块
           */
          public class CodeBlock {
              private String name;
              private int age;
          
              public CodeBlock(String name, int age) {
                  this.name = name;
                  this.age = age;
                  System.out.println("我在执行有参构造。");
              }
          
              public CodeBlock() {
                  System.out.println("我在执行无参构造。");
              }
          
              // 构造代码块
              {
                  this.name="huabingood";
                  this.age=18;
                  System.out.println("执行到了构造代码块。");
              }
          
              @Override
              public String toString() {
                  return "CodeBlock{" +
                          "name='" + name + '\'' +
                          ", age=" + age +
                          '}';
              }
          }

        • 测试

        • package oopTest;
          
          import oop.CodeBlock;
          import org.junit.Test;
          
          public class CodeBlockTest {
              @Test
              public void test(){
                  CodeBlock codeBlock = new CodeBlock();
                  System.out.println(codeBlock.toString());
              }
              @Test
              public void test1(){
                  CodeBlock codeBlock = new CodeBlock("华彬",22);
                  System.out.println(codeBlock.toString());
              }
          }

           

    • 成员变量
      • 类的变量会初始化，但是方法的变量并不会初始化。
    • 成员方法
  • static是随着类的加载而加载的，优先于对象而存在，被该类的所有对象共享；可以通过类名（对象名）调用（不用new对象就可以直接使用，当然使用new出来的对象调用也是可以的）；静态的都在方法去，因此不需要new即可调用；静态修饰的不能访问this关键字，静态方法只能访问静态成员变量，因为他是随着类的加载而加载的。
    • 静态方法只能访问静态成员变量，不能访问非静态成员变量，因为对象没有实例化的时候，非静态成员变量没有到堆内存中，但是静态成员变量已经在方法区了。先存在的不能调用不存在的东西。
    • 同样的道理，静态方法只能调用静态的方法，不能调用非静态的成员方法。但是非静态方法既能调用静态的方法也能调用非静态的成员方法
  • final关键字
    • 修饰方法则该方法不能被override
    • 修饰成员变量只能被赋值一次，赋值之后不能被更改
    • 修饰类则该类不能被继承
    • final修饰引用类型，表示引用类型的地址不能变。就比如教室是不会变的，但是学生可以改变
• 类的初始化与实例化_{（这里的理解需要JVM知识）}
  • 一个对象可以被使用之前，必须被正确的初始化。在实例化一个对象时，JVM会检查相关类型是否已经加载并初始化。如果没有，JVM立即进行加载并调用类构造器完成类的初始化。初始化完成之后才会对类进行实例化
  • 对象创建过程
    • 实例变量初始化
    • 实例代码块初始化
    • 构造函数初始化
  • 如果存在继承
    • 父类的成员变量，父类的实例代码块，父类构造，子类成员变量，子类代码块，子类构造函数 的过程。
• 接口与抽象类
  • 接口
    • 是什么
      • 是一种规范。只说明应该做什么，但是并不规定如何做。这意味着接口里通常定义一组公用方法
      • 接口只有方法名没有方法体，实现接口就是让其既有方法名又有方法体。
      • 体现了规范和实现分离的设计哲学，降低了模块之间的耦合
    • 和其他的对比
      • 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。接口只能定义一系列方法，算是定义行为，而不能包含具体的变量，不能拥有自己的属性，但是抽象类能够拥有变量。
    • 怎么用
      • 注意要点
        • 接口无法被实例化，不能new一个对象，但是可以使用多态来接具体实现子类
        • 接口的方法默认使用public修饰，且只能是public abstract修饰（因为是默认的可以省略），所有方法不能有方法体。但是抽象类是可以有非抽象方法的。
        • 接口中的实例变量默认是final,且只能是public static final 修饰（因为是默认的可以省略），但是抽象类中不一定。
        • 一个类实现接口的话就要实现接口的所有方法（抽象类不必实现所有的方法，但是具体实现子类必须实现所有的方法），而抽象类不一定？
        • 接口是多个类的公共行为规范，接口里的所有成员，常量，方法，内部类都必须是public修饰。但是不能有构造器和初始化代码块。因为不能实例化，所以具体实现子类若想调用父接口的成员变量，就只能调用静态的成员变量。
        • 通用设置

          [修饰符] interface 接口名 [extends 父接口1，父接口2…]{

          零到多个的常量定义…
          零到多个的抽象方法顶底…

          零到多个内部类，接口，枚举定义…

          零到多个默认方法或类定义…

          }

  • 抽象类
    • 是什么

      抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板

  • 抽象类和接口的异同

抽象类	接口
对类的抽象	对行为的抽象
主要是模块内部的抽象	主要是模块之间的联系
自下而上的设计，需要在重构中抽取	自上而下，只需定义规则
子类继承必须实现所有的抽象方法	子类实现可以实现部分抽象方法，但是在一个继承体系内实现万所有的方法
使用abstrict关键字修饰接口	使用interface关键字修饰抽象类
默认是public修饰类	默认是public abstrice修饰类，可以省略
成员变量是public，protected 的	成员变量public static final，可以省略
可以有抽象方法，抽象方法不能有实现。可以有普通方法。	只能是public abstrict修饰的没有实现的抽象方法。（java8中存在静态方法）
类是单继承	接口是多继承
不能被实例化，但是可以有构造，有成员变量，方便子类调用父类的方法和成员变量。	不能被实例化，没有构造。
往抽象类中添加新方法，可以给出默认实现，不需修改已经存在的类	JDK8可以使用default给出默认实现，实现类可以不实现这个方法

• 具体案例代码

  package oop.amimailDemo;
  /**
   * 描述：
   * 这个抽象类主要定义动物的抽象行为
   *
   * @author huabingood@qq.com
   * @version 1.0
   * @create 2018-09-06
   */
  public interface AnimalActive {
      // 接口成员变量默认是public static final 修饰
      int hige = 10;
  
      // 抽象方法默认是public abstract 修饰
      void eat(AnimalImple animalImple);
  
      void sleep();
  
      void jump(AnimalImple animalImple);
  } 
  
  package oop.amimailDemo;
  
  /**
   * 描述：
   * 这个是抽象类，实现了接口的部分方法，并定义一个抽象方法，给孩子
   *
   * @author huabingood@qq.com
   * @version 1.0
   * @create 2018-09-06
   */
  public abstract class AnimalImple implements AnimalActive {
      private String name;
      private int age;
  
      public AnimalImple() {
      }
  
      public AnimalImple(String name, int age) {
          this.name = name;
          this.age = 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;
      }
  
      @Override
      public void eat(AnimalImple animalImple) {
          System.out.println(animalImple.getName() + "正在吃饭。");
      }
  
      @Override
      public void sleep() {
          System.out.println(this.getName() + "正在睡觉");
      }
  
  } 
  
  package oop.amimailDemo;
  
  /**
   * 描述：
   *
   * @author huabingood@qq.com
   * @version 1.0
   * @create 2018-09-06
   */
  public class Cat extends AnimalImple {
      public Cat() {
      }
  
      // 调用构造时，调用父类的构造，不再调用默认的父类构造
      public Cat(String name, int age) {
          super(name, age);
      }
  
      @Override
      public void jump(AnimalImple animalImple) {
          System.out.println(animalImple.getName() + "年龄是：" + animalImple.getAge() + "。能跳：" + AnimalActive.hige);
      }
  
      public void myOnly() {
          System.out.println("这是猫独有的方法");
      }
  }