java基础之 面向对象

学习java最核心最重要的就是要理解面向对象。

以对象为基础点，把对象拆开就是学习java一个一个的知识点，把对象进行扩展探寻对象之间的关系就是学习java代码的对象之间的关系，设计模式。

面向对象特性

要理解面向对象，就要理解面向对象里面的三个核心思想：

• 封装
• 继承
• 多态

封装

利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在封装的抽象数据类型内部，尽可能隐藏其内部的细节，只保留一些对外接口与外部发生联系。使用者不需要知道对象内部的细节，通过对象对外提供的接口来访问这个对象。

示例：封装一个Person对象

public class Person {

    private String name;
    private int sex;
    private int age;

    public String getName() {
        return name;
    }

    public String getSex() {
        return sex == 0 ? "man" : "woman";
    }

    public void work() {
        if (18 <= age && age <= 65) {
            System.out.println(name + " is working very hard!");
        } else {
            System.out.println(name + " can't work any more!");
        }
    }
}

继承 

继承就是 IS-A 的关系 ，如Dog is a Animal，因此，Dog可以继承来自Animal的非private的属性和方法。

class Dog extends Animal {}

多态

多态分为 编译时多态 和 运行时多态

编译时多态主要指的是方法重载

运行时多态指在代码运行期间才能确定对象引用所指向的具体类型（向上转型）

运行时多态示例：

/**
* 父类：Instrument
*/
public class Instrument {
    public void play() {
        System.out.println("Instrument is playing...");
    }
}

/**
* 子类：Wind 
*/
public class Wind extends Instrument {
    public void play() {
        System.out.println("Wind is playing...");
    }
}

/**
* 子类：Percussion 
*/
public class Percussion extends Instrument {
    public void play() {
        System.out.println("Percussion is playing...");
    }
}

public class Music {
    public static void main(String[] args) {
        List<Instrument> instruments = new ArrayList<>();
        instruments.add(new Wind());
        instruments.add(new Percussion());
        for(Instrument instrument : instruments) {
            instrument.play();
        }
    }
}

在代码实际运行时，调用play()方法会执行父类对象实际引用的子类对象的play()方法。

类图

看懂别人画的类图：学习人家写代码运用的模式结构和逻辑思维

自己动手画类图：能够在写代码的时候有清晰的条理逻辑

画类图的网站：传送门

泛化（继承）关系

 子类继承父类，在java中使用extends关键字

@startuml

title Generalization

class Vehical
class Car
class Train
class Aircraft


Vehical <|-- Car
Vehical <|-- Train
Vehical <|-- Aircraft

@enduml

实现关系

 用来实现接口，java中使用implements关键字

@startuml

title Realization

interface MoveBehavior
class Fly
class Run
class Swim

MoveBehavior <|.. Fly
MoveBehavior <|.. Run
MoveBehavior <|.. Swim

@enduml

聚合关系

整体由部分组成，但是整体和部分不是强依赖，整体不存在了部分还是会存在。

@startuml

title Aggregation

class Computer
class Keyboard
class Mouse
class Screen

Computer o-- Keyboard
Computer o-- Mouse
Computer o-- Screen

@enduml

组合关系

整体和部分之间是强依赖，整体不存在了部分也不存在（公司和部门之间的关系）。

@startuml

title Composition

class Company
class DepartmentA
class DepartmentB
class DepartmentC

Company *-- DepartmentA
Company *-- DepartmentB
Company *-- DepartmentC

@enduml

关联关系

对象之间的对应，1对1,1对多，多对多

@startuml

title Association

class School
class Student
class Subject

School "1" - "n" Student
Student "1" - "n" Subject

@enduml

依赖关系

比如：汽车的启动依赖引擎的启动

class Car {
    Engine engine;
    
    void start() {
        engine.start();
    }
}

class Engine {
    void start() {
        // 启动引擎的逻辑
    }
}

一种较弱的关联关系，表示类的实现依赖于另一个类的接口或者方法。

@startuml

title Dependency

class Vehicle {
    move(MoveBehavior)
}

interface MoveBehavior {
    move()
}

note "MoveBehavior.move()" as N

Vehicle ..> MoveBehavior

Vehicle .. N

@enduml