Shulou(Shulou.com)06/02 Report--

This article mainly introduces "the introduction and usage of object-oriented in programming language". In daily operation, I believe that many people have doubts about the introduction and usage of object-oriented in programming language. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the doubts about "introduction and use of object-oriented in programming language". Next, please follow the editor to study!

object-oriented

What is object-oriented?

Object-oriented (Object Oriented) is a software development method. Object-oriented concepts and applications have gone beyond programming and software development, and extended to fields such as database system, interactive interface, application structure, application platform, distributed system, network management structure, CAD technology, artificial intelligence and so on. Object-oriented is a method of understanding and abstracting the real world, and it is the product of the development of computer programming technology to a certain stage. Compared with the process-oriented method, object-oriented method organizes the relevant data and methods as a whole, carries on the system modeling from a higher level, and is closer to the natural operation mode of things. Baidu Encyclopedia

According to the above explanation, it is difficult for beginners to understand what object-oriented is, probably make a simple explanation, because the concept of object-oriented is very large, so if you have any comments or suggestions, please contact me.

Object-oriented is a methodology, using this methodology, software developers can better carry out development work.

Object-oriented is a methodology different from process-oriented. For process-oriented, see point 2.

The Chinese meaning of Object is "goal", "object", etc., object-oriented, that is, thinking from an Object point of view.

Object-oriented languages are all high-level languages, and the mainstream languages include Java\ C++\ Python\ Objective-C\ JavaScript\ Python\ PHP, etc. (regardless of ranking)

In object-oriented, a thing in the real world is an object, each with different attributes (shapes, colors, etc.) and different behaviors (functions). Use programming languages to describe these properties and behaviors as an abstract object, and different programming languages have different expressions.

Process oriented

Process-oriented (Procedure Oriented) is a process-centered programming idea. These are all about programming with the primary goal of what is happening, unlike object-oriented who is affected. The obvious differences between object-oriented and object-oriented are encapsulation, inheritance and class. Baidu Encyclopedia

1. Related concepts 1. Object

Some people in    say that girlfriends / boyfriends are partners. Obviously, this statement is correct. Because, everyone has some attributes, such as name, sex, height, age, ID number and so on; there are also some behaviors, such as walking, eating, working and so on.

   everything is an object. People often describe a thing by some names, shapes and many features, such as being a person, walking upright, using tools, etc., then this process is a process of describing a thing in a natural language. In object-oriented programming, a similar language can also be used to describe a thing, then this thing represents a person, take JavaScript code as an example:

   girlfriend is born by mother-in-law, so the object in programming is also created. The above method is the process of creating an object in JavaScript.

Object oriented programming (OOP)

As a new method, the essence of object-oriented programming (Object Oriented Programming) is the abstract thinking process and object-oriented method embodied in modeling. Models are used to reflect the characteristics of things in the real world. Any model can not reflect all the specific characteristics of objective things, but can only abstract the characteristics and changing laws of things, and describe the characteristics of the object more generally, centrally and profoundly within its scope. The abstraction achieved through the establishment of models is the deepening of people's understanding of the object. Baidu Encyclopedia

   generally speaking, we use programming language to describe a thing in the real world as objects in the programming world, and then use these objects to build a higher-level world, that is, object-oriented programming.

   We describe what is a student, what is a teacher, and what is a course, which can form a course management system; similarly, we describe goods, describe users, describe orders, and form an online mall.

Second, the three major features of object-oriented

Encapsulation

Encapsulate the properties and behavior of an object into an indivisible independent entity, and expose what can be accessed by the outside world through a protected interface, that is, the property is private and the method is public.

The content above    is too official, encapsulated, with a computer analogy, including motherboard, CPU, memory, hard disk, graphics card and so on, which can not be operated directly. Then we can also access and operate this computer through input and output devices such as keyboard, mouse, monitor and so on.

   we cannot directly access the packaged content, which is private to the computer and cannot be accessed. Of course, we can operate this computer through input and output devices. This part is open to the public and you can access it.

   sounds like a computer shell that encapsulates its core components and then plugs into the keyboard and mouse through some sockets for you to operate. Yes, this is encapsulation.

Class Computer {String cpu; int memory; String gpu; String hardDisk public void powerOn () {/ / boot} public void powerOff () {/ / shutdown}}

Inherit

The subclass inherits the parent class, which can make the subclass have the methods and properties of the parent class, and can be called without overriding the methods of the parent class. Subclasses can also override the methods of the parent class so that the methods of the parent class have different functions. Subclasses can append new methods to make subclasses more functional.

   although the son does not inherit the father's inheritance, but similarly, the son can own the father's assets. The subclass inherits the parent class and has the methods and properties of the parent class.

The inheritance of    in programming is caused by abstract reasons. For example, English teachers and math teachers, physics teachers, can inherit the parent class of "teacher". While teachers belong to an abstract concept in this process, then the three teachers all have the function of teaching, and they all have professional certificates, professional titles and other attributes. This feature will also lead to the next object-oriented feature-polymorphism.

   but the difference is that physics teachers can fix electricity meters, English teachers can communicate with foreigners, and math teachers can also use mathematical methods to solve problems in life. Obviously, when they are all teachers, each teacher has his or her own superpower.

Class Teacher {String title;// title String subject;// course void teach () {/ / Teaching}} class EnglishTeacher extends Teacher {private String englishLevel / / English level void teach () {System.out.println ("I am teaching English")} void talkToForeigners () {/ / talking to foreigners}}

Polymorphisms

Different objects can react differently to the same operation and produce different execution results. You can call methods in an implementation derived class through a pointer to the base class.

   teachers can teach, so different teachers teach different content, math teachers teach us math, English teachers teach us English, and physics teachers teach us physics.

   here of course we need to call the teaching method of the parent class (teacher), but because different subclasses override the method of the parent class, different results will be produced when the method of the parent class is called.

   upward modeling is the cornerstone of polymorphisms. For example, we can write Teacher teacher = new MathTeacher () to achieve upward modeling. When we call the teacher.teach () method, we will call the math teacher's teach () method.

About abstraction

Abstraction refers to the thinking process of extracting and summarizing their common aspects, essential attributes and relations from concrete things, while abandoning individual and non-essential aspects, attributes and relations.

   abstraction is not listed in the three major object-oriented features, relatively speaking, I think this is the basic object-oriented method, all object-oriented features are based on abstraction before the object can be constructed.

   We will use abstract thinking as much as possible in the programming process, turning one or a class of real-world things into objects in programming using object-oriented languages.

   for example, just now we abstracted three different teachers into teachers. in fact, we can merge teachers into school staff, school staff into social workers, and social workers into human beings. Of course, the more abstract an object is, the fewer properties and methods it has, thinking that it has less in common.

Three and six principles

Opening and closing principle

The open-close principle states that "objects (classes, modules, functions, etc.) in the software should be open to extensions, but closed to modifications." this means that an entity is allowed to change its behavior without changing its source code. This feature is particularly valuable in a production environment where changing source code requires code review, unit testing, and such processes to ensure the quality of product use. Baidu Encyclopedia-opening and closing principle

It should be open to extensions, but it's hard to understand that changes are closed, but take a look at an example:

/ *

Mapper base class

* * @ author Calvin * @ date 2019-11-07 * @ since * / public abstract class BaseMapper {/ * * add or save * @ param entity * / public void saveOrUpdate (BaseEntity entity) {String id = entity.getId (); BaseEntity exists = null; if (StringUtils.isNotEmpty (id) & & (exists = this.findById (id)) = = null) {this.save (entity) } else {this.update (entity);}} / * according to ID lookup, abstract method * @ param id * @ return * / abstract BaseEntity findById (String id); / * * add * @ param entity * / abstract void save (BaseEntity entity) / * * modify * @ param entity * / abstract void update (BaseEntity entity);}

By defining a baseMapper, there will be a saveOrUpdate method in the new Mapper, we just need to make it implement BaseMapper and make its corresponding Bean inherit BaseEntity, so that we can scale horizontally.

Class UserMapper extends BaseMappper {@ Override public User findById (String id) {/ / select * from user where id = # {id}} @ Override public void save (User user) {/ / insert into user. } @ Override public void update (User user) {/ / update user set.... Where id = # {user.id}

There are three other constraints:

First, limit the boundary of the extension through the interface or abstract class constraint extension, and do not allow public methods that do not exist in the interface or abstract class.

Second, parameter types and reference objects try to use interfaces or abstract classes instead of implementing classes

Third, the abstraction layer should be stable as far as possible, and once determined, modification is not allowed.

Found a post, I think it is a mastery: https://www.liangzl.com/get-article-detail-133084.html

Interface isolation

The client should not rely on interfaces it does not need; the dependency of one class on another should be based on the smallest interface. Baidu Encyclopedia-Interface isolation principle

That is, if a class implements an interface with three methods, and the class itself only needs to use two of them, then it violates the principle of interface isolation.

Interface Interface1 {void function1 (); void function2 (); void function3 ();} class An implements Interface1 {@ Override public void function1 () {/ / needed} @ Override public void function2 () {/ / needed} @ Override public void function3 () {/ / unneeded}

At this point, the interface needs to be modified, which is generally divided into different interfaces according to the function or its field.

Interface Interface1 {void function1 (); void function2 ();} interface Interface2 {void function3 ();}

After splitting into two interfaces, Class An only implements Interface1, and there is no need to implement Interface2. The code is brief, even if it simply follows the interface isolation.

Points to note in interface isolation:

The interface should be highly cohesive. What is high cohesion? High cohesion is to improve the processing power of interfaces, classes, and modules, and reduce external interaction, such as a person who tells your subordinates to "steal a XX file from Obama's office" and then hears your subordinates reply firmly, "OK, guaranteed!" And then you actually put the XX file on your desk a month later, and the act of completing the task immediately without any conditions is a sign of high cohesion. Specific to the principle of interface isolation is to require as little as possible to publish the public method in the interface, the interface is an external commitment, the less commitment is beneficial to the development of the system, the less the risk of change, but also conducive to reduce costs.

Custom service. There must be coupling between the modules in a system or system. If there is coupling, the interface will access each other (not necessarily the Interface defined in Java, it may be a class or a simple data exchange). When we design, we need to customize the service for each visitor (that is, the client). What is a custom service? Provide excellent service for an individual alone. When we do system design, we also need to consider the definition between systems or modules to use custom services, the adoption of custom services must have a requirement: only provide the methods needed by the visitor, only expose to the calling class the methods it needs, and hide the methods it does not need. Only by focusing on providing customized services for a module can minimum dependencies be established.

The interface should be as small as possible, but with limits. It is an indisputable fact that the smaller the design granularity of the interface is, the more flexible the system is, but this leads to too many interfaces, complicates the design structure, increases the difficulty of development, and reduces maintainability, which is not expected by a project or product. So it must be moderate.

This part is reproduced from: https://blog.csdn.net/u012361379/article/details/88101102

Single responsibility

It specifies that a class should have only one reason for change. Baidu Encyclopedia-single responsibility principle

There can only be one reason why a class here can change. Here, it refers to changes caused by business scenarios and other reasons, not changes while the code is running. The explanation is a little vague, so that the author did not understand it very well a long time ago.

Class UserMapper {User findOne (String id) {/ / TODO} User insertOne (User user) {/ / TODO} void updateById (User user) {/ / TODO} User generateUser (String username, String password) {User user = new User (); user.setId (UUID.generateUUID (). ToString ()); user.setUsername (username); user.setPassword (password) InsertOne (user)}}

This is a counterexample. In this class, there is a method to generate students and a method to insert a new query, which depends on the addition.

At this point, whether there is a change in the method of generating the student or in the way of inserting the student, it may lead to a change in another method (so that this class).

Modify the code

Class UserMapper {User findOne (String id) {/ / TODO} User insertOne (User user) {/ / TODO} void updateById (User user) {/ / TODO}} class UserGenerator {UserMapper userMapper; UserGenerator (UserMapper userMapper) {this.userMapper = userMapper } User generateUser (String username, String password) {User user = new User (); user.setId (UUID.generateUUID (). ToString ()); user.setUsername (username); user.setPassword (password); userMapper.insertOne (user)}}

Interior replacement

Wherever a base class can appear, a subclass must appear. Baidu Encyclopedia-Internal replacement principle

The    Richter substitution principle is the basis of many other design patterns. It is particularly closely related to the principle of openness and closure. If you violate the principle of Richter scale substitution, it will not conform to the principle of openness and closure. It's the same Teacher code:

Public TeacherTest {public static void main (String [] args) {Teacher teacher = new MathTeacher (); teacher.teach (); MathTeacher mathTeacher = new MathTeacher (); mathTeacher.teach ();}}

The execution results of the two    test methods will be exactly the same.

One: subclasses can implement the abstract methods of the parent class, but they cannot override the non-abstract methods of the parent class. [core concept]

Second, you can add your own unique methods to the subclass.

Third, the precondition is enlarged, and when the subclass overloads the implemented method of the parent class, the scope of the precondition (formal parameter) of the method should be more relaxed than that of the parent class.

Fourth, the postcondition is reduced, and when the subclass implements the abstract method of the parent class, the range of the postcondition (return value) of the method should be more stringent or the same than that of the parent class.

   this part of the original link: https://blog.csdn.net/hongxiancheng/article/details/83049746

Dependency inversion

Programs rely on abstract interfaces, not on concrete implementations. High-level modules should not rely on low-level modules, both should rely on their abstractions; abstractions should not rely on details; details should rely on abstractions. To put it simply, it requires programming the abstraction, not the implementation, which reduces the coupling between the customer and the implementation module.

Anyone who has known SpringMVC must know this:

Public interface UserService {User create (HashMap args);} @ Mapperpublic interface UserMapper {void insert (User user);} public class UserServiceImpl implements UserService {@ Autowride private UserMapper userMapper; public User create (HashMap args) {User user = UserParser.fromMap (args); userMapper.insert (user);}}

This is a typical dependency inversion. The caller does not care about the specific implementation of UserMapper, but can complete its own business logic by relying on this interface.

The principle of dependency inversion assumes that all concrete classes will change.

To avoid direct calls to classes, dependency inversion may cause the project to produce more classes

Interface-oriented programming will make better use of the principle of dependency inversion.

6. Dietmi's rule

The Law of Demeter is also known as the Least Knowledge Principle LKP, which means that an object should know as little as possible about other objects and not talk to strangers. Baidu encyclopedia-Ditte rice rule

A girl.

Public class Girl {private BoyFriend boyFriend; public void getBoyFriend () {return this.boyFriend ();}}

The girl's boyfriend.

Public class BoyFriend {public void receiveMessage (String message) {/ / response}}

The girl's best friend.

Public class BosomFriend {private Girl girl; BosomFriend (Girl girl) {this.girl = girl;} public void talk () {String message = "I am so cold!"; BoyFriend boyFriend = girl.getBoyFriend (); boyFriend.receiveMessage (message);}}

At this point, your best friend directly told your boyfriend that she was cold, obviously violating Dietmi's rule, so what should you do? any future correspondence from them must go through you.

Public class Girl {private BoyFriend boyFriend; public void getBoyFriend () {return this.boyFriend () } / / expose the way you talk to your boyfriend public void talkToBoyFriend (String message) {if (StringUtils.isNotEmpty (message)) {/ / filter what you say boyFriend.receiveMessage (message) } else {/ / of course you can't tell your boyfriend}

In the future, they can communicate through you, so as to avoid their private communication. When girlfriends no longer rely on boyfriends, they follow Dietmi's principle.

Public class BosomFriend {private Girl girl; BosomFriend (Girl girl) {this.girl = girl;} public void talk () {String message = "I am so cold!"; girl.talkToBoyFriend (message);}}

Minimize the interaction between objects, thereby reducing the coupling between classes. In short, it must be done: low coupling, high cohesion.

When designing a system, don't let one class depend on too many other classes, but minimize the dependencies.

IV. Summary

1. This paper briefly introduces object-oriented and its core concepts.

2. The object-oriented features are demonstrated simply through the code.

3. Through demo, the five principles of object-oriented SOLID and Dietmi's rule are introduced in detail.

At this point, the study of "the introduction and use of object-oriented in programming languages" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.