Oop

JavaScript 面向对象面向对象的两大编程思维面向过程 面向过程很好了解，就是剖析出解决问题所须要的步骤，而后用函数把这些步骤一步一步实现，应用的时候再一个一个的顺次调用就能够了 面向对象 上大学时老师教过咱们，万物皆对象。面向对象就是把事务合成成为一个个对象，而后由对象之间分工与单干。 举个例子 一个人盖个狗窝，间接弄泥，砖头，润饰一下就成了 然而盖高楼的话，须要打地基，须要运输资料，须要财务结算等，此时不须要等，各做各的，效率才高 面向对象三大个性就拿拖拉机来说 封装性【曾经把耕地性能筹备好，负责开就行】继承性【继承与拖拉机，会开拖拉机就会弄这个，继承自拖拉机】多态性【能够拆卸不同的机械，除了耕地还能够拉货】面向过程和面向对象的优缺点面向过程 长处：性能比面向对象高，步骤练习严密毛病：不好保护，不易屡次应用及扩大面向对象 长处：易保护，可复用，可扩大，灵活性高毛病性能没有面向过程高ES6中的类和对象类class在ES6中新减少了类的概念，能够应用class关键字申明一个类，之后以这个类来实例化对象。【构造函数实例化对象】 类形象了对象的公共局部，它泛指某一大类（class） ES5：没有类，ES6：类 ES：ECMAscript 类是在ES6中新加进入的，学会区分类和对象的概念 类：泛指一类 对象：类中的具体的某个实例，【属性和办法的集合体】 类：形象 类模仿形象的，泛指的，对象是具体的 面向对象模仿事实世界，更贴近理论生存，生活照分为形象事物和具体事物 比方：手机【两层含意：具体某个手机，和抽象的概念手机】 抽取，把对象的属性和行为封装成一个类 对类进行实例化, 获取类的对象 例如：人有身高，体重等，然而具体的某个人也有这个属性 练习理解类和对象 一个对象能够继承多个类，而类就是一个泛指 对象：具体 对象：类中的具体的某个实例【属性和办法的集合体】 现实生活中：万物皆对象，对象是一个具体的事物，看得见摸得着的实物。例如，一本书、一辆汽车、一个人能够是对象 在JavaScript 中，对象是一组无序的相干属性和办法的汇合，所有的事物都是对象，例如字符串、数值、数组、函数等。 var n = 3;var arr = [1,2,3];function fn () {}var str= 'abcd';<img src='a.jpg'>复制代码对象是由属性和办法组成的 属性：对象有什么【拜访】【语法：对象.属性】 办法：对象做什么【执行】【语法：对象.办法()】 属性：事物的特色，在对象中用属性来示意（罕用名词） 办法：事物的行为，在对象中用办法来示意（罕用动词） 面向对象的思维特点 抽取（形象）对象共用的属性和办法组织(封装)成一个类(模板) 对类进行实例化, 获取类的对象 类外面的属性和办法，其实是把对象的公共属性和公共办法放到了一起 创立类语法：class 类名 {属性和办法}【构造函数语法糖】 留神类名首字母大写 类要抽取公共属性办法，定义一个类 class Star {};var ldh = new Star();复制代码类就是构造函数的语法糖 constructor 构造函数语法 class Star { constructor (uname,age) { this.uname = uname; this.age = age; }}复制代码属性：放到constructor，构造函数外面 ...

摘要：只管有很多小伙伴对面向对象的概念曾经很很熟了，然而到底什么是面向对象编程？面向对象有哪些个性？面向对象编程可能为咱们带来哪些便当？面向对象又有哪些有余呢？本文分享自华为云社区《【云驻共创】被吹捧了很多年的面向对象编程真的就这么完满吗？》，作者： 冰 河 。 说到面向对象，置信很多小伙伴都曾经很相熟了，毕竟像Java、C++这种编程语言长期排在编程语言榜的前列，而且简直每一所大学的软件工程业余和计算机专业都会开设Java和C++相干的课程。在上学时，老师就会给咱们将什么是对象、什么类。比方：在Java中，万物皆对象。 说到这儿，只管有很多小伙伴对面向对象的概念曾经很很熟了，然而到底什么是面向对象编程？面向对象有哪些个性？面向对象编程可能为咱们带来哪些便当？面向对象又有哪些有余呢？ 很少有人深究过这些问题，置信不少小伙伴都是都是只知其一;不知其二的，明天，咱们就一起来聊聊面向对象这个话题。 什么是面向对象编程？首先，咱们来聊聊什么是面向对象编程。面向对象编程的英文是Object Oriented Programming，简称OOP。在面向对象中有两个最重要，也是最根本的概念，那就是：类和对象。 这两个概念最早呈现到 Simula 编程语言中。而真正第一次应用面向对象编程这个概念的是在 Smalltalk 语言中。而 Smalltalk 语言也被公认为是世界上第一个真正意义上的面向对象编程语言。 倒退到明天，面向对象的编程语言越来越多，像C++、Java、Go、Python、C#、Object-C、Scala等都是面向对象编程语言。 其实，面向对象编程和面向对象编程语言是有着实质的区别的。 面向对象编程： 面向对象编程更多的是指一种编程束缚，以类和对象这两个概念作为输入的载体，并提供 封装、继承、形象、多态 四个个性。 面向对象编程语言： 面向对象编程语言实质上就是一种输入表白面向对象的工具，它可能将程序员的所思所想转换成计算机可能辨认的二进制码，最终可能在计算机上运行。 面向对象有哪些个性？后面咱们曾经简略的提及了面向对象的四大个性：封装、继承、形象和多态 。 封装封装，顾名思义，就是将要拜访的数据保护起来，不让外界间接拜访类的属性和字段，而是对外提供无限的拜访接口，受权内部仅能通过类提供的接口进行拜访。例如，咱们以Java语言为例，写一个只蕴含用户姓名userName和用户年龄userSex的User类。 public class User{ private String userName; private Integer userSex; public void setUserName(String userName){ this.userName = userName; } public String getUserName(){ return this.userName; } public void setUserSex(Integer userSex){ this.userSex = userSex; } public Integer getUserSex(){ return this.userSex; }}在这个User类中，总共有两个属性，也叫做类的成员变量，别离为userName和userSex。userName示意用户的姓名，userSex示意用户的名称。 咱们无奈间接拜访User类中的userName和userSex属性，因为它们都是被privaite修饰符润饰的。然而咱们能够通过如下四个办法访问者两个属性。 • void setUserName(String userName)• String getUserName()• setUserSex(Integer userSex)• Integer getUserSex() ...

What is Dependency injection依赖注入定义为组件之间依赖关系由容器在运行期决定，形象的说即由容器动静的将某个依赖关系注入到组件之中在面向对象编程中，咱们常常解决的问题就是解耦，管制反转(IoC)就是罕用的面向对象编程的设计准则，其中依赖注入是管制反转最罕用的实现。指标解决以后类不负责被依赖类实例的创立和初始化。 what is Dependency依赖是程序中常见的景象，假如有 A和B都被C耦合依赖着，在 OOP 编程中依赖无处不在。依赖模式有多种表现形式，比方一个类向另一个类发消息，一个类是另一个类的成员，一个类是另一个类的参数。 class A {}class B { classA: A; constructor() { this.classA = new A(); }}class C { classA: A; classB: B; constructor() { this.classA = new A(); this.classB = new B(); }}when is use Dependency injectioneg: 以用户调用 API 层打印日志来阐明 LoggerService被ApiService和UserService所依赖ApiService被UserService所依赖class LoggerService { constructor() { } log(args) { console.log(args) }}class ApiService { constructor ( private readonly logger: LoggerService ) { this.logger.log('api constructor') } public async getMydata () { return { name: 'mumiao', hobby: 'focusing in web'} }}class UserService { constructor ( private readonly api: ApiService, private readonly logger: LoggerService ) { this.logger.log('user constructor') } async getMyhobby () { const { hobby } = await this.api.getMydata() return hobby }}async function Main { const loggerService = new LoggerService() const apiService = new ApiService(loggerService) const userService = new UserService(loggerService, userService) console.log('my hobby is', await userService.getMyhobby())}Main()存在的问题Unit tests 很难写组件不易复用和保护，可扩展性比拟低UserService 不应该承载ApiService和LoggerService实例的创立。如何解决采纳依赖注入，UserService不负责被依赖类的创立和销毁，而是通过内部传入api和logger对象的形式注入。常见依赖注入形式有三种，本文次要以结构器注入为例解释。 ...

定义提供一个创立一系列相干或相互依赖对象的接口，而无需指定它们具体的类。 模式概述形象工厂模式是所有模式的工厂模式中最为形象和最具一般性的一种模式，该模式与工厂办法模式的区别在于：工厂办法模式针对的是一个产品等级构造，而形象工厂模式须要面对多个产品等级构造，即形象工厂模式创立的并不是一个简略的对象，而是能够创立出多个位于不同产品等级、属于不同类型的具体产品对象。 产品等级构造和产品族产品等级构造：示意产品的继承构造，如一个抽象类是狗，子类包含哈士奇、牧羊犬等等，抽象类与具体的子类便形成了一个产品等级构造。 产品族：在形象工厂模式中，产品族是指由同一个工厂生产的产品，位于不同产品等级构造中的一组产品。如动物中的哈士奇和海东青，哈士奇属于狗的产品等级构造中，海东青属于老鹰的产品等级构造中，哈士奇和海东青便形成了一个产品族(动物)。 形象工厂模式的构造 AbstractFactory(形象工厂)：申明了一组用于创立产品族的办法，其中每一个办法对应一个产品。Factory(具体工厂)：继承自形象工厂，实现了形象工厂中申明的创立产品的办法。AbstractProduct(形象产品)：为每中产品申明接口，具体产品的基类。Product(具体产品)：具体产品对象，实现了形象产品中申明的业务办法。形象工厂模式的实现形象产品类abstract class AbstractProductA{ public void SameMethod() { //所有产品的公共办法 Console.WriteLine("所有产品A的公共办法"); } //差异化行为 public abstract void DiffMethod();}abstract class AbstractProductB{ public void SameMethod() { //所有产品的公共办法 Console.WriteLine("所有产品B的公共办法"); } //差异化行为 public abstract void DiffMethod();}具体产品类//产品A1class ProductA1 : AbstractProductA{ public override void DiffMethod() { //这里实现产品A1的业务逻辑 Console.WriteLine("这里实现产品A的业务逻辑"); }}//产品B1class ProductB1 : AbstractProductB{ public override void DiffMethod() { //这里实现产品B1的业务逻辑 Console.WriteLine("这里实现产品B的业务逻辑"); }}形象工厂类abstract class AbstractFactory{ public abstract AbstractProductA CreateProductA(); public abstract AbstractProductB CreateProductB();}具体工厂类class ConcreteFactory : AbstractFactory{ public override AbstractProductA CreateProductA() { return new ProductA1(); } public override AbstractProductB CreateProductB() { return new ProductB1(); }}应用var factory = new ConcreteFactory();var productA = factory.CreateProductA();productA.SameMethod();productA.DiffMethod();var productB = factory.CreateProductB();productB.SameMethod();productB.DiffMethod();后果开闭准则歪斜性如果在应用形象工厂模式的过程中思考不全面，在设计的时候脱漏了产品族中的某一产品，导致后续需要变动呈现新的产品时，须要批改形象工厂类，以增加对新产品的创立接口，同时还要批改具体的工厂类，否则无奈将新产品利用于零碎中。 ...

简略工厂模式的弊病应用简略工厂模式设计零碎，在每次减少新的对象时除了须要新增一个类型以外，还需批改工厂类的代码，违反了开闭准则，而工厂办法模式作为简略工厂模式的延申，恰好补救的简略工厂模式的缺点。 工厂办法模式对简略工厂模式加以批改，不再提供一个工厂类负责所有对象的创立，而是先定义一个形象的工厂基类，将具体对象的创立过程交给专门的工厂子类去实现，每个工厂子类都继承自形象工厂类，且实现形象工厂类中申明的办法。应用工厂办法模式能够在呈现新的产品时不批改原有的代码，通过新增一个具体的工厂类负责创立该新产品的实例即可，合乎开闭准则。 工厂办法模式的定义：定义一个创建对象的接口，然而让子类决定实例化哪一个对象。工厂办法模式让一个类的实例化提早到其子类。 工厂办法模式的构造 Product(形象产品)：定义产品的接口，工厂办法模式所创立所有对象类型的基类。ProductA(具体产品类)：实现了形象产品的接口，由专门的具体工厂类创立，具体产品和具体工厂关系一一对应。Factory(形象工厂)：申明一个Method，返回形象产品类型。形象工厂是工厂办法模式的外围，所有具体工厂类都必须实现形象工厂类的形象办法，返回具体的产品对象。ProductAFactory(具体工厂)：形象工厂的子类，实现了形象工厂的办法，返回具体的产品实例。工厂办法模式的实现//形象工厂也能够是接口abstract class FactoryMethod{ public abstract Product Build();} //具体工厂类class ProductAFactory : FactoryMethod{ public override Product Build() { return new ProductA(); }}// 形象基类abstract class Product{ public void SameMethod() { //所有产品的公共办法 Console.WriteLine("所有产品的公共办法"); } //差异化行为 public abstract void DiffMethod();}//产品Aclass ProductA : Product{ public override void DiffMethod() { //这里实现产品A的业务逻辑 Console.WriteLine("这里实现产品A的业务逻辑"); }}通过配置文件存储具体工厂类名，实现更换新的具体工厂是无需批改源代码//配置文件<?xml version="1.0" encoding="utf-8" ?><configuration> <startup> <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" /> </startup> <appSettings> <add key="factoryName" value="Factory.ProductAFactory"/> </appSettings></configuration>static void Main(){ //读取配置文件 var factoryName = ConfigurationManager.AppSettings["factoryName"]; var factoryType = Type.GetType(factoryName); var factory = Activator.CreateInstance(factoryType) as FactoryMethod; var product = factory.Build(); product.SameMethod(); product.DiffMethod(); Console.ReadKey();}运行后果 ...

前言简略工厂模式属于创立型模式之一，是最常见的设计模式，利用也相当宽泛。创立型模式通过让对象的创立和应用拆散，使得开发人员在应用对象的时候无需关怀对象的创立细节，从而升高零碎的耦合度。 创立型模式该类模式在开发过程中的应用十分频繁，创立型模式关注对象的创立过程，对类的实例化进行了形象，将模块中对象的创立和应用拆散，对外暗藏了对象的创立细节。 简略工厂模式概念定义一个工厂类并提供一个办法，工厂办法能够依据参数的不同返回不同的实例，被创立的实例通常都具备雷同的父类。因为简略工厂模式中提供的办法通常是静态方法，所以该模式又能够成为动态工厂办法模式。 设计思维将须要创立的各种不同对象的相干代码封装到不同类中，这些类称为具体的产品类，再形象和提取它们公共的代码封装在一个形象产品类中，每一个具体产品类都继承自形象产品类(属于其子类)。而后提供一个工厂类用于创立各种不同的产品，在工厂类中提供一个创立产品的办法，这个办法反对传参，依据传入的参数不同创立不同的具体产品对象。使用者只须要调用工厂办法并传入对应的参数即可失去绝对的产品对象。 构造与实现结构图 由结构图可知，简略工厂模式蕴含3个角色，别离如下： Factory(工厂)：工厂类，简略工厂模式的外围，负责实现创立所有产品的外部逻辑。工厂类中提供的静态方法能够间接被内部调用，并且返回形象产品类型ProductProduct(形象产品)：它是工厂类所创立的所有产品的基类，封装了各种产品的公共办法ProductA&ProductB(具体产品角色)：是简略工厂模式须要创立的指标，每一个具体产品都继承自Product简略工厂模式的实现将所有产品的共性移至形象产品中// 形象基类abstract class Product{ public void SameMethod() { //所有产品的公共办法 Console.WriteLine("所有产品的公共办法"); } //差异化行为 public abstract void DiffMethod();}创立具体产品类，并实现形象办法中申明的形象办法，不同的产品能够有依据需要有不同的实现//产品Aclass ProductA : Product{ public override void DiffMethod() { //这里实现产品A的业务逻辑 Console.WriteLine("这里实现产品A的业务逻辑"); }}外围工厂类//工厂类class Factory{ //静态方法 public static Product GetProduct(string type) { if (type.Equals("A")) return new ProductA(); else if (type.Equals("B")) return new ProductB(); return null; }}应用static void Main(){ var product = Factory.GetProduct("A"); product.SameMethod(); product.DiffMethod(); Console.ReadKey();}运行后果 能够发现，如果须要创立其它的具体产品对象，必须批改获取对象时传入的参数才能够实现，且代码须要从新编译，这违反了开闭准则。能够通过读取XML配置解决该问题，批改代码如下： 将须要创立的产品类型保留到配置文件App.config中<?xml version="1.0" encoding="utf-8" ?><configuration> <startup> <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" /> </startup> <appSettings> <add key="productType" value="A"/> </appSettings></configuration>批改代码如下static void Main(){ //读取配置文件 var pType = ConfigurationManager.AppSettings["productType"]; var product = Factory.GetProduct(pType); product.SameMethod(); product.DiffMethod(); Console.ReadKey();}运行后果 ...

面向对象设计准则的作用能够进步软件的可维护性于可复用性，其中可维护性是指代码可能被了解、改过、适应扩大的难易水平，可复用性是指代码可能被重用的难易水平，可维护性和可复用性是用于掂量软件品质的两个十分重要的属性。 7个面向对象设计准则设计准则名称定义繁多职责准则一个对象只应该蕴含繁多的职责，并且该职责被残缺地封装在一个类中开闭准则软件实体应该对扩大凋谢，对批改敞开里氏代换准则所有援用基类的中央必须都能应用基类的子类替换依赖倒转准则高层模块不应该依赖底层模块，它们都应该依赖形象。形象不应该依赖细节，细节应该依赖形象接口隔离准则接口细分，不应该依赖不须要的接口合成复用准则优先应用对象组合，而不是应用继承来达到复用的目标迪米特法令每一个对象对其它的对象都只有起码的信息，而且局限于那些与本对象密切相关的信息繁多职责准则繁多职责准则是实现高内聚、低耦合的指导方针，对一个类来说，应该仅有一个引起它变动的起因。在软件系统中，一个类承当的职责越多，它被复用的可能性就越小，并且当承当过多的职责后，就相当于将这些职责耦合在一起，当其中一个职责发生变化时，极有可能会影响到其它职责的失常工作。因而要将这些职责进行拆散，将不同的职责封装在不同的类中(将不同的变动起因封装在不同的类外面)，如果多个职责总是会同时产生扭转，那么则能够将它们封装在一个类中。 开闭准则开闭准则是极其重要的设计准则，对扩大开发，对批改敞开，即尽量在不批改原有代码的状况下进行扩大。 当软件系统面临新的需要时，应该尽量保证系统的设计框架是稳固的，如果一个软件设计合乎开闭准则，那么能够十分不便的对系统进行扩大，而且在扩大时无需批改现有代码，使零碎同时具备适应性、灵活性和较好的稳定性以及延续性。 为了满足开闭准则，须要对系统进行抽象化设计，抽象化是开闭准则的要害。在C#、JAVA等编程语言中能够定义一个绝对稳固的形象层，而将不同的实现放在具体的实现层中实现。能够通过接口、抽象类等机制进行抽象化设计，定义零碎形象层，再通过具体类进行扩大，如果未来需要变动须要批改零碎的行为，毋庸对形象层进行改变，只有减少新的具体类来实现新的业务需要，在不批改原有代码的前提下扩大零碎性能，即是开闭准则。 里氏代换准则该准则示意，在软件中将一个基类对象替换成它的子类对象，程序能够失常运行，不会产生任何谬误，反之则不成立。里氏代换准则是实现开闭准则的根底，因为应用基类的中央都能够应用子类代替，因而在程序中尽量应用基类类型定义对象，在运行时再确定其子类的具体类型，用子类对象替换父类对象。 在应用里氏代换准则时应将父类设计成抽象类或者接口，让子类继承父类或实现父类接口，并实现父类中申明的办法。运行时子类实例替换父类实例，能够很不便地扩大零碎性能，无需批改原有子类代码，减少新的性能能够通过减少一个新的子类来实现。 依赖倒转准则依赖倒转准则是面向对象设计的次要实现机制之一，它是零碎抽象化的具体实现。依赖倒转准则要求：面向接口编程，不要针对实现编程。 在传递参数时或者在关联关系中尽量援用形象层，即应用接口和抽象类进行变量类型申明、参数类型申明、办法返回类型申明和数据类型转换等，而不要用具体类来做这些事件。为了确保该准则的利用，一个具体类该当只实现接口或抽象类中申明过的办法，而不要给出多余的其它办法，否则基类将无奈调用到子类中减少的新办法。 在引入形象层后，零碎将会具备很好的灵活性，在程序中应该尽量应用形象层进行编程，而将具体类写在配置文件中，这样做的益处在于，如果未来需要发生变化，只须要对形象层进行扩大，并批改配置文件，而无须批改原有的代码，满足开闭准则。 实现依赖倒转准则，须要针对形象层进行编程，将具体类的对象通过依赖注入的形式注入其它对象中。依赖注入指的是：当一个对象须要与其它对象产生依赖关系时，通过办法参数来注入所依赖的对象。罕用的注入形式：结构注入(通过构造函数传入具体类的对象)、设置注入(set办法传入具体类的对象)和接口注入(在接口中申明的业务办法传入具体类的对象)。 接口隔离准则当一个接口太大时，须要将它宰割成更细小的接口，每一个接口应该承当一种绝对独立的角色，不做与之无关的事件。 接口细分是有益处的，如果提供的接口太大，蕴含的办法太多，应用起来反而不不便，因为实现接口就须要实现这个接口的所有办法，而并不是每一个办法都是所须要的。这时候为了使职责繁多，须要将接口中的办法依据其职责别离放在不同的小接口中，确保接口应用起来不便，并且都承当繁多的角色。接口应该尽量细化，每个接口中蕴含的办法应尽量的少，最好只蕴含一个模块所有要的办法即可。 合成复用准则合成复用准则就是在一个新的对象里通过关联关系来应用一些已有的对象，使之成为新对象的一部分，复用时尽量应用组合，少用继承。 在面向对象中，能够应用组合或者继承的形式复用已有的设计和实现，但首先应该思考组合，因为这种形式能够使零碎更加灵便，升高类与类之间的耦合度，一个类的变动对其它类的影响较小。其次才思考继承，应用继承时应该恪守里氏代换准则。 继承的局限性：如果基类产生扭转，那么子类也不得不发生变化。同时继承的实现是动态的，不可能在运行时产生扭转，短少灵活性。 为什么应用组合：因为组合是将已有对象引入到新对象中，让它成为新对象的一部分，因而新对象能够调用已有对象的性能，而对象外部的实现对新对象来说并不可见。比照继承，组合的耦合度更低，成员对象的变动对新对象的影响不大，并且合成复用能够在运行时动静进行，新对象能够动静援用成员对象类型雷同的其它对象。 什么时候用继承什么时候用组合？如果两个类之间的关系是a-Has-b(a对象领有b职责)，那么应该应用组合；如果关系是a-Is-b(a对象属于b类型的某一品种)，这是应该应用继承。 迪米特法令每个模块应该尽量少地与其它模块互相援用产生关联，这样在模块变动时，对其它模块产生的影响也会最小，利用这个法令可升高类之间的耦合度。 对象只应该与本人所关怀的成员通信，如： 对象自身，即本人以参数模式传入到以后对象中的对象以后对象的成员对象以后对象所创立的对象只有数据上述的某一个类型，便可与之间接交互。在程序设计的时候，如果两个对象没有必要彼此间接通信，那么这两个对象就不应该产生任何间接关联，如果一个对象须要调用另一个对象的办法，能够通过引入一个两头者的形式来实现。 利用迪米特法令时，应尽量创立松耦合的类，耦合度越低，越利于复用；在类的结构设计上，该当升高每一个类中成员变量和成员函数的拜访权限；类型该当尽量设计成不变类；一个对象对其它对象的援用该当降到最低。

前言我的读者中应该大部分都是 Java 从业者，不晓得写 Java 这些年是否真的有找到对象？ 没找到也没关系，总不能在一棵树上吊死，咱们也能够来 Go 这边看看，说不定会有新发现。 开个玩笑，本文会以一个 Javaer 的角度来聊聊 Go 语言中的面向对象。 <!--more--> OOP面向对象这一词来源于Object Oriented Programming，也就是大家常说的 OOP。 对于 Go 是否为面向对象的编程语言，这点也是探讨已久；不过咱们能够先看看官网的说法: 其余的咱们暂且不看，Yes and No. 这个答复就比拟奥妙了，为了这篇文章还能写下去咱们先认为 Go 是面向对象的。 面向对象有着三个重要特色： 封装继承多态封装Go 并没有 Class 的概念，却能够应用 struct 来达到相似的成果，比方咱们能够对汽车申明如下： type Car struct { Name string Price float32}与 Java 不同的是，struct 中只存储数据，不能定义行为，也就是办法。 当然也能为 Car 定义方法，只是写法略有不同： func (car *Car) Info() { fmt.Printf("%v price: [%v]", car.Name, car.Price)}func main() { car := Car{ Name: "BMW", Price: 100.0, } car.Info()}在办法名称前加上 (car *Car) 便能将该办法指定给 Car ，其中的 car 参数能够了解为 Java 中的 this 以及 Python 中的 self，就语义来说我感觉 go 更加简略一些。 ...

类和对象类文件后缀：.java， 包（namespace）：我的项目上右键创立 package _17bang.CD.Yz; 引入（using），留神import的是一个“类”，不是名称空间 import _17bang.YZ.Student; 但能够应用通配符 *，比方： import _17bang.YZ.*; 没有partial类 拜访修饰符：没有关键字internal（不能显式申明，默认即可，package中可见） 一个类文件只能有一个public类 static：能够由对象调用（只warning不报错) 援用类型和值类型其余类成员快捷键生成：alt+shift+s， 构造函数间调用： public Student(int age) { this(); } 没有属性，只有getter和setter。所以也没有主动属性等一系列相干的语法。 private int age; public int getAge() { return age; } public void setAge(int age) { this.age = age; } 没有readonly关键字 final： 润饰变量/字段时，等同于 const 没有索引器 析构函数 protected void finalize() { } 动态和实例没有static构造函数 顶级类不能static，外部类能够 继承应用关键字extends示意继承，super示意基类 public class OnlineStudent extends Student { public OnlineStudent(int age) { super(age); } } ...

摘要：一提到编程范式，很容易联想到宗教的虔诚，每种宗教所表白信条都有肯定合理性，但如果始终只遵循一种教条，可能也被让本人痛苦不堪，编程范式也是如此。案例1案例一，代码摘抄来自一企业培训资料，次要代码逻辑是打印每课问题，并找出学生非F级别课程统计均匀分数： class CourseGrade { public String title; public char grade;}public class ReportCard { public String studentName; public ArrayList<CourseGrade> cliens; public void printReport() { System.out.println("Report card for " + studentName); System.out.println("------------------------"); System.out.println("Course Title Grade"); Iterator<CourseGrade> grades = cliens.iterator(); CourseGrade grade; double avg = 0.0d; while (grades.hasNext()) { grade = grades.next(); System.out.println(grade.title + " " + grade.grade); if (!(grade.grade == 'F')) { avg = avg + grade.grade - 64; } } avg = avg / cliens.size(); System.out.println("------------------------"); System.out.println("Grade Point Average = " + avg); }}下面的代码有哪些问题呢: ...

1.面向对象（1）概念：所谓的面向对象是一种编程思维，通过这种思维能够把生存中的简单事件变得简单化，从原来的执行者变成了指挥者，面向对象是基于面向过程而言的。咱们常常说的面向对象的编程实现（OOP，Object Oriented Programming） 面向对象强调后果，我的了解就是面向对象是将咱们生存中的各种各样的货色封装成为一个对象，其中包含了他的各种属性和各种办法，对外提供这些办法和属性，使得咱们能够通过创立（new）这个对象去调用这些办法和属性，这样即便咱们不晓得各种属性和各种办法是如何封装的咱们也能够应用这些办法和属性。（2）三大特色: 1、封装：封装就是将一个对象的属性和操作联合成一个独立的整体，并尽量暗藏其外部的操作细节。 2、继承：继承就是，子类继承父类的特色和行为，使子类具备父类的一些办法。然而父类中private润饰的办法，不能被子类具备，而且父类中static润饰的办法，不能被子类重写，即使子类中有与父类中同名的静态方法，二者也没有任何关联。 3、多态：多态是同一个行为具备多个不同表现形式或状态的能力。多态就是同一个接口，应用不同的实例而执行不同操作，多态性是对象多种表现形式的体现。当应用多态形式调用办法时，首先查看父类中是否有该办法，如果没有，则编译谬误；如果有，再去调用子类的同名办法。多态的益处：能够使程序有良好的扩大，并能够对所有类的对象进行通用解决。 2.构造方法（1）概念：构造方法是一种非凡的办法，它是一个与类同名且返回值类型为同名类类型的办法。对象的创立就是通过构造方法来实现，其性能次要是实现对象的创立或者对象的初始化。当类实例化一个对象时会主动调用构造方法。构造方法和其余办法一样也能够重载。（2）模式：能够有参也能够无参 ``修饰符 类名([参数]){ 代码……}`` 3.面向对象中的关键字（1）private：是一个权限修饰符，用于润饰成员变量和成员函数，被私有化的成员只能在本类中拜访，想要批改或获取该成员，只能对外提供公共的get和set办法。（2）this和super：this代表本类对象的一个援用对象。构造函数中，this()必须放在第一行。（3）extends：是继承的关键字，示意子类继承父类时应用，子类继承父类的特色和行为，使子类具备父类的一些办法。然而父类中private润饰的办法，不能被子类具备，而且父类中static润饰的办法，不能被子类重写，即使子类中有与父类中同名的静态方法，二者也没有任何关联。这也是面向对象的三大特色之一。（4）static：动态关键字，能够润饰成员变量、成员办法以及动态代码块（随着类的加载而加载，并且只被加载一次，个别用于我的项目的初始化），特点是被润饰的变量及办法会随着类的加载而加载，优于对象加载，只加载一次就会始终存在，不会再开拓新的空间，全局惟一全局共享，能够间接被类名调用，另外动态只能调用动态，非动态能够随便调用，static不能喝this或者super独特应用，因为有static时可能还没有对象。（5）final：final能够润饰类、办法和成员变量，特定是被final润饰的类，不能被继承，被final润饰的办法不能被重写，被final润饰的变量是个常量，值不能被更改。（6）abstract：形象的关键字，用来润饰类或办法，Java中能够定义没有办法体的办法，该办法由其子类来具体的实现。该没有办法体的办法咱们称之为形象办法，含有形象办法的类咱们称之为抽象类。抽象类能够了解为是一个只有办法申明没有办法体的非凡类。特点是抽象类中能够没有形象办法（有子类去实现），如果类中有形象办法，那该类必须定义为一个抽象类，子类继承了抽象类当前，要么还是一个抽象类，要么就把所有形象办法都重写，抽象类不能够被实例化。 4.接口（interface）（1）概念：Java外面因为不容许多重继承，所以如果要实现多个类的性能，则能够通过实现多个接口来实现。 Java接口和Java抽象类代表的就是形象类型，就是咱们须要提出的形象层的具体表现。OOP面向对象的编程，如果要进步程序的复用率，减少程序的可维护性，可扩展性，就必须是面向接口的编程，面向形象的编程，正确地应用接口、抽象类这些太有用的形象类型做为java构造档次上的顶层。（2）特点：1、接口中都是形象办法2、通过interface关键字创立接口3、通过implements让子类来实现4、能够了解成，接口是一个非凡的抽象类5、接口冲破了java的单继承的局限性6、接口和类之间能够多实现，接口和接口之间能够多继承7、接口是对外裸露的规定，是一套开发标准8、接口进步了程序的性能扩大，升高了耦合性9、接口里是没有构造方法的。在创立实现类的对象时默认的super()，是调用的默认Object的无参结构。10、接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：public static final11、接口里的办法，默认就都是形象的，如果你不写明是abstract的，那会主动补齐12、Java中单继承的局限性通过接口能够解决。接口能够多继承也能够多实现，甚至能够继承的同时多实现。

Js是一门弱类型语言 Java、c、c++、c#、php都是强类型语言 在强类型语言中有一个‘类’的概念，是用来实现继承的。 强类型语言：三种个性 1. 多态性：在强类型语言中，一个变量存在多种状态。在不同的上下文代码中，变量的模式能够不同（理解） 2. 继承性：在强类型语言中，会存在类的概念，类有父级和子级关系（相似于js中的函数），子级类能够齐全继承父级类中的所有属性 (1) 继承就是完完全全领有 3. 封装：封装函数 Js在诞生初期没有继承 因为js中没有类 起初人们就创立出了面向对象编程 1. js中的继承 (1) 原型 ① 原型是基于对象呈现的 ② 定义：原型就是某一个对象中__proto__非标准属性指向的一个对象 ③ __proto__非标准属性 是每一个对象中的默认属性，不须要手动编写，主动就会有这个属性，这个属性的属性值就是这个对象的原型 ④ 原型：其实也是一个对象，也会有各种属性，这些属性，会齐全继承给原型的对象 ⑤ 对象.__proto__就是以后对象的原型 (2) 对象的申明形式 ① new关键字申明 ② 字面量申明 ③ 由以上两种办法可知 1) Js中申明对象能够间接申明，也能够通过构造函数来申明 2) 这里，咱们次要探讨一下通过构造函数申明对象 (3) 构造函数 ① 构造函数能够实例化对象，这个实例化的对象有原型 ② 实例化的对象原型也是 对象名.__proto__ ③ 对象名.__proto__(原型)和构造函数之间的关系： 1) 原型中会有一个属性constructor，这个属性的属性值就是对象的构造函数 a. 原型.constructor===构造函数 b. 构造函数.prototype===原型 构造函数和工厂函数构造函数中最初会隐式返回绑定好属性的空对象，如果用户没有写返回值或者返回值是值类型数据，那么，构造函数就会隐式返回。如果用户写了返回值为援用类型，构造函数就不会隐式返回，而是返回用户写入的返回值 对象的创立办法1. 间接创建对象 (1) 长处：简略，明了 (2) 毛病：当须要创立大量对象的时候，会造成大量的工作量=-= 2. 构造函数创建对象 ...

前言这几天通过实现issue对面向对象有了新的意识。 对象援用在接触一个子组件父组件的时候，自组件扭转了对象的值，然而并没有传给父组件，最初在父组件保留失效了，那么，他是如何将值传给父组件的呢。通过潘老师的领导，我意识到对象与变量的不一样。首先，咱们这里父组件通过@input形式传给子组件了part对象。 @Input() part: Part;而自组件扭转part对象的某个属性，父组件里的part对象是跟着变得，换句话说，子组件与父组件为援用的为同一个对象。咱们看一下《Head First Java》对此内容的介绍，这几张图形象的阐明了对象援用的规定。通过这张图，咱们能够假如@input作用相当于 part(子组件part对象) = _part(父组件part对象)这时候咱们就不难理解为什么子组件对象的某一属性扭转而父组件对象属性为什么跟着扭转了。正如第二个图示的那样，咱们子组件与父组件的变量都指向了同一对象。当一者将对象进行扭转时，另一个人再去读取对象，对象曾经扭转了。让咱们用一个demo来验证 public class Dog { public int weight;}class dogTest { @Test void test() { Dog b = new Dog(); Dog c = new Dog(); c = b; System.out.println(c.weight); b.weight = 10; System.out.println(c.weight); }}正如后面所说，如果两个变量指向同一个对象，那么通过其中一个扭转对象的属性，另一个变量也会扭转。 面向对象三大个性之一——封装咱们大一学面向对象编程思维的时候常背的就是面向对象三大个性，然而什么是封装没学明确。其实咱们的我的项目始终在应用封装，比方咱们在后盾加一个字段，通常状况下是在实体类新建一个属性，而后再给他get办法和set办法，这种做法便是封装。 public class Dog { private int weight; public int weight() { return weight; } public void setWeight(int weight) { this.weight = weight; }}咱们留神到，咱们将属性设为公有属性，而通过私有的weight与setWeight办法进行读取与设置。这是为什么呢其实咱们当初还没有体现封装的长处。咱们察看这个类，weight代表狗的分量，分量就应该是一个大于0的值。如果咱们设置weight为私有属性并通过dog.weight传值，咱们就有可能传入一个谬误的值 ...