Java学习之==>面向对象编程 Part2

一、封装

　　封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和方法都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。

• 理解
  • 开车时，我们不需要知道发动机的运转原理；
  • 开飞机时，我们不需要知道是什么驱动螺旋桨来转动的；
• 思想
  • 高内聚，低耦合；
• 原则
  • 把尽可能多的东西藏起来.对外提供简捷的接口，尽量降低对外的暴露；
  • 把所有的属性藏起来；

如何实现封装：

1、权限修饰符

• public
  • 公开的，作用范围一个工程内；
• protected
  • 保护的，作用范围一个体系内；
• 默认
  • 默认的，作用范围一个包内；
• private
  • 私有的，作用范围一个类内；

作用点：

• 修饰类
• 修饰方法
• 修饰属性
• 修饰构造器

总结：

• 在不同的包内，只能调用修饰符为public的属性和方法；
• 在不同的包内，如果是继承父类，则可调用修饰符为public和protected的属性和方法；
• 在同一个包内，可以调用修饰符为public、protected和默认的属性和方法；
• 在同一个包内，如果是继承父类，则可调用修饰符为public、protected和默认的属性和方法；

2、getter&setter方法

我们先来看下面一个类：

public class User {

  private Integer id;

  private String name;

  private Integer age;

  public Integer getId() {
    return id;
  }

  public void setId(Integer id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Integer getAge() {
    return age;
  }

  public void setAge(Integer age) {
    this.age = age;
  }

  @Override
  public String toString() {
    return "User{" +
            "id=" + id +
            ", name='" + name + '\'' +
            ", age=" + age +
            '}';
  }
}

再来看下这个类中getter和setter方法的调用

public class Test {

  public static void main(String[] args) {

    User user = new User();

    user.setId(1);
    System.out.println("id = " + user.getId());

    user.setName("jack");
    System.out.println("name = " + user.getName());

    user.setAge(25);
    System.out.println("age = " + user.getAge());
    System.out.println("user = " + user);
  }
}

private的属性只有对象自己才可以访问，其他任何对象不行，包括它的子类和父类。安全性高，其他对象只能通过它的public方法（getter&setter）来获取或设置原对象的private属性。如果属性设置为public，其他对象可以直接访问，安全性就不高了。定义为private，实现数据的隐藏和封装；

3、静态工厂方法（of）

我们再来看下下面这个类：

public class User {

  private Integer id;

  private String name;

  private Integer age;

  private User() {
  }

  private User(String name) {
    this();
    this.name = name;
  }

  private User(Integer id, String name) {
    this(name);
    this.id = id;
  }

  private User(Integer id, String name, Integer age) {
    this(id,name);
    this.age = age;
  }

  public static User of() {
    return new User();
  }

  public static User of(String name) {
    return new User(name);
  }

  public static User of(Integer id, String name) {
    return new User(id, name);
  }

  public static User of(Integer id, String name, Integer age) {
    return new User(id, name, age);
  }

  public Integer getId() {
    return id;
  }

  public void setId(Integer id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Integer getAge() {
    return age;
  }

  public void setAge(Integer age) {
    this.age = age;
  }

  @Override
  public String toString() {
    return "User{" +
            "id=" + id +
            ", name='" + name + '\'' +
            ", age=" + age +
            '}';
  }
}

可以看到，我们在类中提供了多个 public 的方法 of()，返回的是该类的对象，这样我们使用时就不用再 new 一个对象出来，只要使用 User.of() 方法就可以了，如下：

public class Demo {

  public static void main(String[] args) {

  User user = User.of(1,"jack", 22);

    System.out.println("user = " + user);
  }
}

类中的 of() 是我们自己定义的名称，可以根据传入的参数不同来自定义，其中除了可以返回当前类的对象，还可以返回其子类的对象。

二、继承

• 优点
  • 减少了重复代码的编写，提高了代码的复用性；
• 语法
  • extends关键字
  • class Sub extends Super {}
• 注意
  • Java中不支持多继承，一个类只能继承自一个父类；
  • 可以多个子类继承同一个父类；
  • 多层继承时，继承依然有效；
• 思考
  • 实例化子类时，父类会被实例化吗？

super关键字：

• 定义
  • 指向父类的指针；
• 作用
  • 在子类中，调用父类的属性、方法、构造器；
• 语法
  • super.name
  • super.run()
  • super("jack", 35)
• 注意
  • super查找顺序是先找自己的直接父类；
  • super调用父类的构造器必须在首行；

总结：

• 语法
  • 基于关键字extends实现类和类之间的继承关系；
  • 实现继承之后，属性、方法等都会被子类继承；
  • 在子类中如果有和父类相同的属性和方法，且想调父类的实现时，可使用关键字super；
• 思想
  • 把相同的东西抽出来，don't copy yourself；
• 继承的弊端
  • 破坏了类的封装性；

三、多态

多态，简单解释就是一种事物的多种形态，我们先来看下以下几段代码：

public class Car {

  /**
   * 品牌
   */
  private String brand;

  /**
   * 排量
   */
  private String output;

  /**
   * 速度
   */
  private int speed;

  public Car(String brand, String output) {
    this.brand = brand;
    this.output = output;
  }

  public int getSpeed() {
    return speed;
  }

  public void setSpeed(int speed) {
    this.speed = speed; }

  public String getBrand() {
    return brand;
  }

  public void setBrand(String brand) {
    this.brand = brand;
  }

  public String getOutput() {
    return output;
  }

  public void setOutput(String output) {
    this.output = output;
  }
}

Car.java

public class Benz extends Car {

  public Benz() {
    super("奔驰", "1.0");
  }
}

Benz.java

public class Bmw extends Car {

  public Bmw() {
    super("宝马", "2.0");
  }

  @Override
  public String getBrand() {
    return "宝马mini";
  }
}

Bmw.java

public class George extends Car {

  public George() {
    super("乔治巴顿", "7.5L");
  }
}

George.java

以上四段代码中，Car 是父类，Benz、Bmw 和 George 是子类，三个子类当中都传入了自己的品牌和排量调用了一次父类 Car 的构造方法，然后我们再来看下入口程序：

public class App {

  public static void main(String[] args) {

    // 以下写法就是多态的表现，将子类的实例化结果指向父类
    Car car1 = new Bmw();
    Car car2 = new Benz();
    Car car3 = new George();

    run(car1);
    run(car2);
    run(car3);
  }

  /**
   * 体现多态的写法,是下面的run方法, run方法在面向的是一个抽象的Car
   * 在run方法看来, 它只看Car这个抽象的东西, 它可以是Bmw、Benz或者George都可以，run不在乎
   */
  private static void run(Car car) {

    System.out.println("路上跑的是：" + car.getBrand() + "车");
  }
}

可以看到，run 方法传入的参数是一个抽象的 car，它可以是 Bmw、Benz、George，也可以是 Car 的其他子类的对象，因为我们把子类的实例化结果都指向了父类 Car，以上就是多态的最简单的表现形式，我们来看一下运行的结果：

理解

• 专业说法：一个事物的多种形态；
• 通俗说法：我要找个人来帮我‘

现象

• 将子类的实现方法指向父类的引用；
• Car car = new Bmw();

注意

• 多态针对的是方法，不是属性；

instanceof关键字：

作用

• 用于判断对象是否是某个类的实例；

语法

• obj instanceof Class；

使用场景

• 多态实现时用于前置判断，避免类转换异常；

我们将以上 run 方法加入 instanceof 判断，再看一下运行结果：

private static void run(Car car) {

  if (car instanceof George) {
    System.out.println("不行不行,速度太快");
    return;
  }
  System.out.println("路上跑的是：" + car.getBrand() + "车");
}

判断 car 对象如果是 George 类的实例，则输出“不行不行，速度太快"，而如果是其他类的实例，则还是输出“路上跑的是XX车”。

通过以上对多态的介绍，我个人感觉，多态其实是对继承的一种更深入表现形式。

面向对象编程再拓展一下可以理解为面向抽象编程。

多态中还有两种比较经典的表现形式：抽象类和接口。

抽象类

抽象类，我们可以理解为：面向模板编程

定义

• 使用 abstract 关键字修饰的类就为抽象类；
• 使用 abstract 关键字修饰的方法就为抽象方法；

特点

• 定义一个抽象方法, 使用abstract关键字, 但是方法不能有实现；
• 子类继承抽象类的时候, 必须实现抽象方法；
• 抽象类不可以被实例化；

举例：

public abstract class Person {

  private String type;

  public Person(String type) {
    this.type = type;
  }

  public String getType() {
    return type;
  }

  /**
   * 跑和跳，任何人都一样
   * 不用抽象
   */
  public void run() {
    System.out.println("两条腿跑");
  }

  public void jump() {
    System.out.println("两条腿跳");
  }

  /**
   * 讲话，不同国家的人语言不一样
   * 抽象，由具体的子类去实现
   */
  protected abstract void talk();

  /**
   * 不抽象, 代码显得很乱
   */
  // if (this instanceof China) {
  //   System.out.println("先来个开场白");
  //   System.out.println("一顿吹牛逼");
  //   System.out.println("人种:" + this.getType() + ",讲中文");
  // } else if (this instanceof English) {
  //   System.out.println("上来就一顿鸟语花香");
  //   System.out.println("人种:" + this.getType() + ",讲英文");
  // }
}

Person

public class Chinese extends Person {

  public Chinese() {
    super("中国人");
  }

  @Override
  protected void talk() {
    System.out.println("先来个开场白");
    System.out.println("一顿吹牛逼");
    System.out.println("人种:" + this.getType() + ",讲中文");
  }
}

Chinese

public class English extends Person {

  public English() {
    super("英国人");
  }

  @Override
  protected void talk() {
    System.out.println("上来就一顿鸟语花香");
    System.out.println("人种:" + this.getType() + ",讲英文");
  }
}

English

定义了一个抽象类 Person，其中定义了三个方法：run()、jump() 和 talk()，对于不同国家的人来说，跑和跳都是一样，的不用抽象，而说话可能使用的是不同的语言，则可以用代表不同国家的人 Chinese 和 English 具体来实现；再来看一下入口程序和运行结果：

public class App {

  public static void main(String[] args) {

    Person china = new Chinese();
    Person english = new English();

    speak(china);
    System.out.println("--------------");
    speak(english);
    System.out.println("--------------");
    china.run();
    System.out.println("--------------");
    english.jump();
  }

  private static void speak(Person person) {
    person.talk();
  }
}

接口

接口，我们可以理解为：面向规范编程

定义

• 接口是对类的一组需求的描述；
• 接口所描述的方法不能有实现；
• 接口所描述的方法都是 public，不写也是 public；
• 接口的“继承”叫实现，使用implements关键字

特性

• 接口不是类，不能进行实例化；
• 接口运行多实现，使用逗号隔开；

举例：

public interface Person {

  /**
   * 普通类中方法的定义方式: public void talk(){ }
   *
   * 抽象类中抽象方法的定义方式: protected abstract void talk();
   *
   * 接口的方法的定义方式: void talk();
   */
  void talk();
}

Person

public interface Study {

  void english();

}

Study

/**
 * 子类是实现接口, 使用关键字. implements
 *
 * 可以实现多个接口, 多个接口之间使用逗号进行分割
 */
public class Student implements Person, Study {

  @Override
  public void talk() {
    System.out.println("Student talk");
  }

  @Override
  public void english() {
    System.out.println("Student study english");
  }
}

Student

public class Teacher implements Person {

  @Override
  public void talk() {
    System.out.println("teacher talk");
  }
}

Teacher

定义了两个接口 Person 和 Study，子类Student实现了接口 Person 和 Study 中的 talk() 和 study() 方法，而子类 Teacher 只实现了Person 中的 talk() 方法。再来看一下入口程序和运行结果：

public class App {

  public static void main(String[] args) {

    Person stu = new Student();
    Study study = new Student();
    Person tea = new Teacher();

    speak(stu);
    study(study);
    speak(tea);
  }

  private static void speak(Person person) {
    person.talk();
  }

  private static void study(Study study) {
    study.english();
  }
}

抽象类 VS 接口

相同点

• 都可以用来描述抽象；
• 都不能进行实例化；

不同点

• 抽象类还说类，其中定义的普通方法（非抽象方法）可以有实现；
• 接口中的方法不能有实现；

区别

• 抽象类一般是抽象能力；
• 接口一般是抽象规范；

举例：

public abstract class Person {

  /**
   * 模板
   * 打电话的一套流程
   */
  public void call() {
    pickUp();

    talk();

    hello();

    goodbye();

    putDown();
  }

  protected void pickUp() {
    System.out.println("拿起电话");
  }

  protected abstract void talk();

  protected abstract void hello();

  protected abstract void goodbye();

  protected void putDown() {
    System.out.println("挂了电话");
  }
}

Person

Person类是一个抽象类，启动定义了一套打电话的流程，拿起电话和挂断电话对所有人来说都是一样的，所以在抽象类当中使用普通方法实现，但是打电话是使用什么语言、开始打招呼和结束语怎么说都因人而异，所以这三个方法使用抽象方法进行定义，但不实现。在一套模板中既有固定的步骤，又有不固定的步骤，这周情况下我们使用抽象类。

public class Chinese extends Person {

  @Override
  protected void talk() {
    System.out.println("中文语言");
  }

  @Override
  protected void hello() {
    System.out.println("你好！！");
  }

  @Override
  protected void goodbye() {
    System.out.println("再见！！");
  }
}

Chinese

Chinese类继承自 Person 类，根据中国人的特性实现了 Person 类当中的 talk()、hello()、goodbye() 三个方法。

public class Englishi extends Person {

  @Override
  protected void talk() {
    System.out.println("englishi");
  }

  @Override
  protected void hello() {
    System.out.println("hello！！");
  }

  @Override
  protected void goodbye() {
    System.out.println("goodbye！！");
  }
}

Englishi

同样，English 类根据英国人的特性实现了 Person 类当中的 talk()、hello()、goodbye() 三个方法。

/**
 * 文学素养
 */
public interface Literature {

  /**
   * 写诗
   */
  void writePoet();
}

Literature

Literature 是一个关于文学素养的接口，里面定义了一个写诗的方法，但没有实现。文学素养不是每个人都有，写诗也不是每个人都会，所以这种情况我们使用接口来实现。

/**
 * 诗人
 */
public class Poet extends Person implements Literature {

  @Override
  protected void talk() {
    System.out.println("诗情画意");
  }

  @Override
  protected void hello() {
    System.out.println("轻轻的我来了");
  }

  @Override
  protected void goodbye() {
    System.out.println("轻轻的我走了");
  }

  @Override
  public void writePoet() {
    System.out.println("诗人写诗");
  }
}

Poet

Poet 定义为一个诗人类，它既有人的所有特征（能打电话），又有诗人独特的气质（能写诗），所以它继承自 Person 类、实现自 Literature 类，其中实现了Person 类当中的 talk()、hello()、goodbye() 三个方法和 Literature 接口中的 writePoet() 方法。最后我们再来看下入口程序和运行结果：

public class App {

  public static void main(String[] args) {
    Person p1 = new Chinese();

    Person p2 = new Englishi();

    Person p3 = new Poet();

    Literature li = new Poet();

    p1.call();

    System.out.println("=================");

    p2.call();

    System.out.println("=================");

    p3.call();
    li.writePoet();
  }
}