关于继承:Java进阶-从整体上观察面向对象

面向对象是 Java 编程中最外围的思维，基本特征：继承、封装、多态。

将构造、数据、操作封装在对象实体中，应用时能够不关注对象内部结构，只能拜访凋谢权限的性能入口，从而升高程序耦合水平，提供安全性和可继续维护性。

public class Concept01 {public static void main(String[] args) {Student student = new Student("张三","高三",29f);
        student.conclusion();}
}
class Student {
    private String name ;
    private String grade ;
    private Float score ;
    public Student(String name, String grade, Float score) {
        this.name = name;
        this.grade = grade;
        this.score = score;
    }
    public void conclusion (){System.out.println("姓名："+this.getName());
        System.out.println("年级："+this.getGrade());
        System.out.println("分数："+this.getGrade());
        if (this.getScore() >= 100.0f){System.out.println("评语：本学期优等生");
        } else {System.out.println("评语：本学期潜力股");
        }
    }
}

案例形容 Student 的学期总结，通过构造方法构建具体的学生对象，并且只通过 conclusion 办法获取学生学期评估。

子类除了提供本身的能力之外，还能够通过继承的形式获取父类凋谢的属性和办法，以加强本身的性能。

public class Concept02 {public static void main(String[] args) {
        // 判断 Digital 是 Phone 父类
        System.out.println(Digital.class.isAssignableFrom(Phone.class));
    }
}
class Digital {}
class Phone extends Digital{}

这里通过 isAssignableFrom 办法判断 Digital 是 Phone 父类。

不同主体类对同一个动作给出不同的实现形式，多态也是 Java 形容设计模式的罕用伎俩，最间接的作用就是程序解耦。

public class Concept03 {public static void main(String[] args) {Animal animalDog = new Dog();
        Animal animalCat = new Cat();
        animalDog.voice();
        animalCat.voice();}
}
class Animal {public void voice () {System.out.println("Animal ... voice");
    }
}
class Dog extends Animal {
    @Override
    public void voice() {System.out.println("Dog ... Wang wang");
    }
}
class Cat extends Animal {
    @Override
    public void voice() {System.out.println("Cat ... Meow meow");
    }
}

通常动物都有发出声音的能力，然而不同动物声音不同，这里基于多态实现，不同动物的声音特色。

在理解面向对象之后，还须要了解一下根底的关系模型，在理论的业务中都是基于这些根底的关系解决场景问题。

继承关系：强调属性和办法从父类向子类的传承。实现关系：强调形容形象和具体实现的逻辑。

/**
 * 继承
 */
class classA {}
class classB extends classA {}
interface interfaceA {}
interface interfaceB extends interfaceA {}
/**
 * 实现
 */
class classC implements interfaceA,interfaceB{}

依赖关系：罕用来形容办法局部变量或者入参，即类的办法中调用了另一个类。关联关系：类的成员变量是另一个类，比方常见的一对一，一对多关系。

/**
 * 依赖
 */
class RelyA {}
class RelyB {public void depend (RelyA rely){}}
/**
 * 关联
 */
class AssociateA {}
class AssociateB {private AssociateA associateA ;}

聚合关系：形容整体与局部的关系，然而局部不须要依赖整体存在。组合关系：形容整体与局部的关系，然而局部须要依赖整体存在。

/**
 * 聚合
 */
class ElementA {}
class ElementB {}
class Aggregation {
    private ElementA elementA ;
    private ElementB elementB ;
}
/**
 * 组合
 */
class PortionA{}
class PortionB{}
class Composition {
    private PortionA portionA ;
    private PortionB portionB ;
}

在面对简单业务时，能够时常参考设计模式和根本准则，以此设计正当的业务构造，实现代码的高内聚低耦合，然而在一些特定场景下，也要果决的冲破这些模板或准则，能够更好的撑持业务。

创立模式

形象对象实例化的创立过程，对不同类型的对象提供高效的治理形式与正当的创立伎俩。

单例模式
原型模式
工厂模式
建造者模式

构造模式

设计类的组装模式，正当的对象构造，有利于反对业务的继续迭代，构造会间接影响代码的可继续维护性。

代理模式
外观模式
适配器模式
装璜者模式
组合模式
享元模式
桥梁模式

行为模式

行为模式波及对象职责定义，通信合作，和最具体的业务逻辑实现，明确程序运行时的流程轨迹。

能够基于继承或实现的形式管制不同类的行为职责，即顶层形象管制行为，上层逐级做具体逻辑实现；或者间接聚合治理责任对象，做统一分配。

观察者模式
模版办法模式
策略模式
命令模式
调停者模式
备忘录模式
解释器模式
迭代器模式
状态模式
责任链模式
访问者模式

开闭准则：在做代码结构设计时，应该思考对扩大凋谢，对批改敞开，抽象思维搭建构造，具体实现扩大细节。
繁多职责：一个类应该只负责一项职责；缩小代码一处变更引起的程序大规模改变状况，升高类的复杂度；
接口隔离：每一个接口应该是一种角色；尽量避免具体实现类中用不到然而又必须实现的办法；
依赖倒转：下层模块不应该依赖上层模块，形象逻辑不应该依赖具体细节，即中心思想是面向接口编程。
里氏替换：继承时遵循里氏替换准则，子类中尽量不要重写父类的办法，能够扩大父类的性能；
迪米特准则：起码晓得准则即类对象对其依赖的类晓得的越少越好，以此升高耦合水平；
组合 / 聚合复用：新对象应应用局部已有的对象，使其成为新对象组成部分，实现已有性能的复用，以此升高单个类的复杂程度。

在业务开发中，很多简单的逻辑都是基于面向对象的思维做的设计和具体实现，然而在实际上业务是一直变动的，所以不论是罕用的 Mvc 模式，或者畛域设计，只有通过多个版本迭代，多人参加的开发，到最初代码在逻辑层面都会让人着迷。

也就是常说的一种景象：新人重构，老人一直修复问题，然而铁打的问题，流水的开发，凡是经验过重构的同学都晓得，所谓的大规模重构很难彻底解决问题，甚至这是个循环动作。所以业务代码更多是在那个版本周期内是正当的，站在一个开发的角度，这里也能够了解为笔者集体角度，通常从上面几个角度去思考具体的业务开发：

标准束缚

这是集体认为业务工程中最重要的根底，不论业务如何简单，都离不开与之相应的数据增删改查，所以对惯例根底操作做好对立代码格调治理，这样有助于他人疾速了解整体构造和逻辑。

这里格调指：接口命名，参数，组件，中间件等对立，以长久层为例，防止多个组件混用的状况，如果是周期绝对较长的我的项目，常常看到单是分页查问的实现逻辑都有多种状况。

可复用性

易变是业务自身的特点，所以高度复用的业务代码自身就存在很大的限度，例如常见的很多办法，为了适配各种场景，一直扩大入参，而后有些非凡业务也会进行非凡传参。

还有一些开发常说的，能用一个接口实现，相对不应用两个接口，看似很有共性，理论曾经走在挖坑的路上，多个性能申请同一个接口，即意味着任何接口的改变都要思考很多逻辑的适配。

所以从下层向下看，不用适度思考复用，从下向上看，底层的改变绝对较少，应该思考复用。

业务分层

从我的项目生命周期的角度思考，业务是一个迭代的过程，不须要适度前卫的设计，我的项目的生命周期是多久没人晓得，最稳当的做法是疾速迭代，产品和技术工程能疾速稳固的撑持业务倒退即可。

经典的业务分层治理是疾速迭代的根本撑持，例如罕用的 Mvc 模式，在简单的业务场景下能够再次细化治理，或者向畛域设计凑近。

流程分段

业务能够了解为流程治理，小的流程通常 service 中能够间接解决，然而简单流程则非常考究设计，一个根底思维就是分段治理，比拟经典的案例就是下单：构建结算页面时初始化订单 - 领取时订单提交 - 领取胜利才会执行订单。

细节问题

逻辑上的细节要继续谋求谨严，业务实现伎俩和思路适当放宽，流程经得起考验，底层实现正当的复用，组件抉择上应该站在高纬度，就根本足以。

GitHub·地址
https://github.com/cicadasmile/java-base-parent
GitEE·地址
https://gitee.com/cicadasmile/java-base-parent

浏览标签

【Java 根底】【设计模式】【构造与算法】【Linux 零碎】【数据库】

【分布式架构】【微服务】【大数据组件】【SpringBoot 进阶】【Spring&Boot 根底】

【数据分析】【技术导图】【职场】

关于继承:Java进阶-从整体上观察面向对象

一、面向对象

1、特色之封装

2、特色之继承

3、特色之多态

二、关系图谱

1、继承与实现

2、依赖与关联

3、组合与聚合

三、模式与准则

1、设计模式

2、根本准则

四、业务利用

五、源代码地址