The structure of Java class

itread01 2020-11-06 20:10:22
structure java class


# Class and object There are five main structures in a class , The following is a detailed introduction to these five structures . ## 1. Object oriented and process oriented - Process oriented : The emphasis is on functional behavior , Take the function as the smallest unit , Think about how to do it . - Object oriented : Emphasis on functional objects , By category / The object is the smallest unit , Consider who will do it .-- Materialism ( Matter determines consciousness ) ## 2. The relationship between class and object - Class : A description of a class of things , It is abstract. 、 A conceptual definition - thing : It's every individual of the kind that actually exists , Therefore, it is also called an example (instance) > Object oriented programming focuses on class design , A design class is a member of a design class . The relationship between the two : thing , It's by class new It came out , Derived from . ## 3. The rules of object oriented thought implementation 1. Create classes , Design class members 2. Create object of class 3. Through objects . Properties or thing . Method calls the structure of the object Add : How to use several concepts - Properties = Member variable = field = Domain 、 Hurdles - Method = Member method = Function = method - Create object of class = Instantiation of class = Instantiate class ## 4. Object creation and object memory parsing Typical code : ``` Person p1 = new Person(); Person p2 = new Person(); Person p3 = p1;// No new object created , Object entities sharing a heap space . /* Explain : * If multiple objects of a class are created , Each object has a set of class properties independently .( Not static Of ) * It means : If we change the properties of an object a, Does not affect another object property a Value . */ ``` Memory parsing : ![](https://img2020.cnblogs.com/blog/1542615/202011/1542615-20201106115834589-1196099766.png) ![](https://img2020.cnblogs.com/blog/1542615/202011/1542615-20201106115845182-715246505.png) ## 5. JVM Memory structure After compiling the source code , Generate one or more bit group code files . We use JVM The loaders and literal translators of the classes in are used to interpret and execute the generated bit group code file . It means , The class corresponding to the bit group code file needs to be loaded into memory , It's about memory parsing . ![](https://img2020.cnblogs.com/blog/1542615/202011/1542615-20201106115856535-1399604251.png) Virtual machine stack : This is the stack structure mentioned usually . We store the local variables in the stack structure Virtual machine heap : We will new Come out of the structure ( such as : Array 、 thing ) Load in pair space . Add : Properties of the object ( Not static Of ) Load in heap space . Method area : Class loading information 、 Constant pool 、 Static fields ## 6. Anonymous objects : The objects we create , Not explicitly assigned to a variable name . It's an anonymous object Features : Anonymous objects can only be called once . ``` new Phone().sendEmail(); new Phone().playGame(); new Phone().price = 1999; new Phone().showPrice();//0.0 ``` Application scenario : ``` PhoneMall mall = new PhoneMall(); // The use of anonymous objects mall.show(new Phone()); among , class PhoneMall{ public void show(Phone phone){ phone.sendEmail(); phone.playGame(); } } ``` ## 7. " Everything is an object " stay Java In the category of language , We will all be able to 、 Structure and so on are encapsulated in the class , By instantiating a class , To call the specific functional structure - Scanner,String etc. - Archives :File - Internet resources :URL involves Java Language and front end HTML、 When the back-end database interacts , The structure of the front and rear ends is in Java Level interaction , They are embodied as classes 、 thing . # One of the structures of a class : Properties ## 1. Properties vs Regional variables ### 1.1 The same thing : - Define the format of the variable : Data type Variable name = Variable value - Declare first , After using - Variables have their corresponding scopes ### 1.2 The difference is : #### 1.2.1 Different positions declared in a class - Properties : Defined directly in a pair of classes {} Inside - Regional variables : Declare in method 、 Method parameter 、 Within the code block 、 Constructor parameters 、 Variables inside the constructor . #### 1.2.2 About the difference in license modifiers - Properties : You can declare properties , Specify its permission , Use permission modifier . - Common license modifiers :private、public、 Presupposition 、protected ---> Encapsulation - at present , When declaring properties , Just use the default . - Regional variables : Permission modifiers cannot be used . #### 1.2.3 Default initialization value : - Properties : Properties of class , According to its type , All default initialization values . - integer (byte、short、int、long:0) - Floating point (float、double:0.0) - Character type (char:0 ( or '\u0000')) - Brin type (boolean:false) - Reference type ( Class 、 Array 、 Interface :null) - Regional variables : There is no default initialization value . > It means , Before we call a local variable , Be sure to assign values explicitly . In particular : When a parameter is called , Let's assign a value . #### 1.2.4 The location of the load in memory : - Properties : Load into heap space ( Not static) - Regional variables : Load into stack space ## 2. The classification of variables : Mode one : By data type : ![](https://img2020.cnblogs.com/blog/1542615/202011/1542615-20201106120157651-1542879220.png) Mode two : According to the position declared in the class : ![](https://img2020.cnblogs.com/blog/1542615/202011/1542615-20201106120201707-1625918082.png) # Class structure two : Method Define : Describe the functions that a class should have . ## 1. Method example : ### 1.1 JDK The method in : - Math Class :sqrt() random() ... - Scanner Class :`nextXxx()` ... - Arrays Class :`sort()` `binarySearch()` `toString()` `equals()` ... ### 1.2 Custom method : ``` public void eat(){ System.out.printly(" I want to eat !!!"); } public String getNation(String nation){ System.out.printly(" The current location is " + nation); } ``` ### 1.3 Declaration of methods : ``` License modifier Return value type Method name ( Parameter list ){ Method body } ``` > ** Be careful :**static、final、abstract To modify the way , I'll talk about it later . ## 2. Description of the method : ### 2.1 About license modifiers : Java Prescribed 4 Kind of license modifier :private、public、 Presupposition 、protected Please check the article for details 《 Three features of object oriented are discussed in detail 》 ### 2.2 Return value type : #### 2.2.1 Return value vs No return value - If the method has a return value , When the method is declared , Specifies the type of return value . At the same time , In the method , Need to use return Keyword to return a variable or constant of a specified type :return Information . - If the method does not return a value , When the method is declared , Use void To represent . Usually , In methods that do not return values , No need to use return. If used , Only use return; End this method . #### 2.2.2 Should the method define the return value ? 1. Title requirements 2. Specific analysis of specific problems ### 2.3 Method naming conventions - Belonging to an identifier , Follow the rules and regulations for identifying symbols ,“ See the name and know the meaning ” - The method name should follow the small hump name aaaBbbCcc - It is better to use English words for method names , Don't use pinyin or abbreviations - For more specification requirements, please refer to [《Java Development Manual 》](https://www.cnblogs.com/blknemo/p/13686416.html) ### 2.4 About formal parameter list Methods can be declared 0 One ,1 One , Or multiple parameters . You can also use deformable parameters , But deformable parameters have to be put last , For details, please check out part 5 of this chapter . Format :` Data type 1 Formal parameter 1, Data type 2 Formal parameter 2 .....` #### When defining methods , Should a formal parameter be defined ? 1. Title requirements 2. Specific analysis of specific problems ### 2.5 Method body It's the embodiment of the function in the method , Branching through loops 、 Conditional judgment and other statements complete complex logical relations . Methods can call other methods , You can call directly in the same kind , Call through instantiated objects of classes in different classes . > Be careful : You cannot define a new method in a method ## 3. Use of methods - Methods in the same class can call properties or methods of the current class directly , Call through instantiated objects of classes in different classes . - special : Method A I call myself again --- Recursive method .( Self calling ) For the use of recursive methods, please refer to Part 7 of this chapter . ## 4. Method overload ### 4.1 The concept of overload In the same class , Allow more than one method with the same name , As long as they have different arguments or argument types . **" Two are the same but different ":** - identical : Same class 、 Same method name - The argument list is different : The number of arguments is different , The argument types are different ### 4.2 Examples of overload are : ``` // One example is :Arrays Class overload sort() / binarySearch();PrintStream Medium println() // Example 2 : // As follows 4 Methods constitute overload public void getSum(int i,int j){ System.out.println("1"); } public void getSum(double d1,double d2){ System.out.println("2"); } public void getSum(String s ,int i){ System.out.println("3"); } public void getSum(int i,String s){ System.out.println("4"); } ``` Examples that do not constitute overload : ``` // As follows 3 This method can't match the above 4 Methods constitute overload public int getSum(int i,int j){ return 0; } public void getSum(int m,int n){ } private void getSum(int i,int j){ } ``` ### 4.3 Overload method judgment ** How to judge whether to constitute method overload ?** Judge strictly by definition : Two are the same but different . With the permission modifier of the method 、 Return value type 、 A formal parameter changes a number of names 、 It doesn't matter whether the method or the body ! ** How to determine the call of a method in a class :** ① Method name ---> ② Argument list ## 5. Variable number parameter method ### 5.1 Instructions for use - JDK 5.0 What's new - JDK 5.0 before : Methods are defined by array parameters , Pass in multiple variables of the same type `public static void test(int a, String[] books);` - JDK 5.0 Later : Using variable number of formal parameters to define the method , Pass in multiple variables of the same type `public static void test(int a, String ... books);` ** Specific use :** - Variable number parameter format :` Data type ... Variable name ` - When calling a method with variable parameters , The number of arguments passed in can be :0 One ,1 One ,2 One ,..... - The variable number parameter method is the same as the method name in this class , Different methods of formal parameter constitute overload - The variable number parameter method is the same as the method name in this class , There is no overload between arrays of the same parameter type . In other words , The two cannot coexist . - Variable number of formal parameters in the formal parameters of the method ,** Must be declared at the end **. - Variable number of formal parameters in the formal parameters of the method ***, At most one deformable parameter can be declared ***. ### 5.2 Examples ``` public void show(int i){ } public void show(String s){ System.out.println("show(String)"); } public void show(String ... strs){ System.out.println("show(String ... strs)"); for(int i = 0;i < strs.length;i++){ System.out.println(strs[i]); } } // Cannot exist with the previous method // public void show(String[] strs){ // // } // When calling : Deformable participating arrays are similar to test.show("hello"); test.show("hello","world"); test.show(); test.show(new String[]{"AA","BB","CC"}); ``` ## 6. Java The value passing mechanism of ### 6.1 An example of assignment to a variable in a method : ``` System.out.println("*********** Basic data type :****************"); int m = 10; int n = m; System.out.println("m = " + m + ", n = " + n); n = 20; System.out.println("m = " + m + ", n = " + n); System.out.println("*********** Reference type :****************"); Order o1 = new Order(); o1.orderId = 1001; Order o2 = o1;// After assignment ,o1 and o2 Has the same address value , Both point to the same object entity in heap space . System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId); o2.orderId = 1002; System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId); ``` > Rules : If the variable is a primitive data type , In this case, the data value stored in the variable is assigned . If the variable is a reference data type , In this case, the value assigned is the address value of the data stored in the variable . ### 6.2 The concept of arguments for methods Formal parameter : Method definition , The arguments in parentheses of the declaration Real reference : Method call , The data actually passed to the formal parameter ### 6.3 Java Middle argument passing mechanism : Value Passing Mechanism ** Rules :** - If the argument is *** Basic data type ***, At this time, the actual parameter is assigned to the parameter as the data value stored by the parameter . - If the argument is *** Reference type ***, At this time, the actual parameter is assigned to the formal parameter the address value of the data stored in the argument . ** Promotion :** - If the variable is a primitive data type , In this case, the data value stored in the variable is assigned . - If the variable is a reference data type , In this case, the value assigned is the address value of the data stored in the variable . ### 6.4 Memory parsing : Key points of memory parsing drawing : 1. Memory structure : Stack ( Regional variables )、 Pile up (new Come out of the structure : thing ( Not static Member variable )、 Array 2. Variables : Member variable vs Regional variables ( Within the method 、 Method parameter 、 Inside the constructor 、 Constructor parameters 、 Within the code block ) One example is ![](https://img2020.cnblogs.com/blog/1542615/202011/1542615-20201106122511599-1785687939.png) Example 2 ![](https://img2020.cnblogs.com/blog/1542615/202011/1542615-20201106122515428-426403607.png) ## 7. Recursive method Recursive method : A method calls itself within itself . > Method recursion contains an implicit loop , It repeats a piece of code , But this kind of repeated execution does not need loop control . Recursion must be in a known direction , Otherwise this kind of recursion becomes infinite recursion , It's like a dead circle . Examples of recursive methods : ``` // example 1: Calculation 1-n The sum of the natural numbers between public int getSum(int n) {// 3 if (n == 1) { return 1; } else { return n + getSum(n - 1); } } // example 2: Calculation 1-n The product of natural numbers between :n! public int getSum1(int n) { if (n == 1) { return 1; } else { return n * getSum1(n - 1); } } // example 3: We know a sequence of numbers :f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n), // among n Is greater than 0 The integer of , seek f(10) Value . public int f(int n){ if(n == 0){ return 1; }else if(n == 1){ return 4; }else{ // return f(n + 2) - 2 * f(n + 1); return 2*f(n - 1) + f(n - 2); } } // example 4: Fibonacci series // example 5: The Hanoi Tower problem // example 6: Quick line up ``` ## 8. Method rewriting ### 8.1 What is a method rewrite (override or overwrite)? After the subclass inherits the parent , Methods with the same name and same parameter in the parent class can be used , Overlay operation . ### 8.2 The application of rewriting : After rewriting , When subclass objects are created , When a method with the same name and same parameter in a child parent class is called through a subclass object , What is actually executed is the method of subclass overriding the parent class . ### 8.3 Example of rewriting : ``` // The parent class class Circle{ public double findArea(){}// Find the area } // Subclass class Cylinder extends Circle{ public double findArea(){}// Find the surface area } ********************************************** // The parent class class Account{ public boolean withdraw(double amt){} } // Subclass class CheckAccount extends Account{ public boolean withdraw(double amt){} } ``` ### 8.4 Rewriting of rules : Declaration of methods : ``` License modifier Return value type Method name ( Parameter list ) throws The type of exception { // Method body } ``` By convention : Subclasses are called overriding methods , The method in the parent class is called the overridden method 1. The method name and formal parameter list of the method overridden by the subclass are the same as the method name and formal parameter list of the method overridden by the parent class 2. The permission modifier of a method overridden by a subclass is not less than that of a method overridden by a parent class > Special circumstances : A child class cannot override a parent class declared as private The way to license 3. Return value type : - The return value type of the method whose parent class is overridden is void, The return value type of the method overridden by the subclass can only be void - The return value type of the method whose parent class is overridden is A Type , The return value type of the method overridden by the subclass can be A Class or A Subclasses of classes - The return value type of the method whose parent is overridden is the basic data type ( such as :double), The return value type of the method overridden by the subclass must be the same basic data type ( It has to be double) 4. The exception type thrown by a method overridden by a subclass is not as large as that thrown by a method overridden by a parent class ( When it comes to exception handling ) > Methods with the same name and parameters in the subclass and parent class are declared as non static Of ( Consider rewriting , Everything should be declared as static Of ( It's not rewriting ). > > In development, the child and parent classes are generally consistent ### 8.5 Interview questions : ** Distinguish between method override and overload ?** The concept of both : - Method rewriting : After the subclass inherits the parent , Methods with the same name and same parameter in the parent class can be used , Overlay operation . - Method overload : In the same class , Allow more than one method with the same name , As long as they have different arguments or argument types . Specific rules for overloading and rewriting : - Overload : Two are the same but different , - Rewrite : All the same , As like as two peas , Coverage Pleomorphism : - Overload : It doesn't show pleomorphism . - Rewrite : It shows pleomorphism . From the point of view of compilation and execution : - Overload , Multiple methods with the same name are allowed , And these methods have different arguments . The compiler uses different argument tables depending on the method , Modify the name of the method with the same name . For compilers , These methods of the same name become different methods . Their call address is bound at compile time .Java Overload can include both parent and child classes , That is, the subclass can overload the methods of different arguments with the same name of the parent class . - So for overload , Before the method call , The compiler has determined the method to call , This is called “ Tie up early ” or “ Static binding ”; - And for many types , Just wait until the method calls , Explain the actuator to determine the specific method to call , This is called “ Late tie ” or “ Dynamic binding ”. > To quote Bruce Eckel And then :“ Don't be silly , If it's not late binding , It's not multiform .” # The third structure of a class : Constructors ## 1. Constructors ( Or construction method ):Constructor The role of constructors :( As long as an artifact is created, it has to use a constructor ) 1. Create objects 2. Initialize the information of the object ## 2. Instructions for use : - If there is no explicit definition of class constructor , By default, the system provides an empty parameter constructor - Define the format of the constructor : License modifier Class name ( Parameter list ){ } - Defined in a class *** Multiple constructors ***, Overload each other - Once we explicitly define the constructor of a class , The system will no longer provide the default empty parameter constructor - In a class ,** There will be at least one constructor **. ## 3. An example of a constructor is : ``` // Constructors are not the same as methods public Person(){ System.out.println("Person()....."); } public Person(String n){ name = n; } public Person(String n,int a){ name = n; age = a; } ``` The default permission of the constructor is the same as that of the class ## 4. Attribute assignment order Summary : The order in which attributes are assigned 1. ① Default initialization 2. ② Explicitly initialize 3. ③ Initialization in the constructor 4. ④ Through " thing . Method " or " thing . Properties " The way , Assignment The sequence of the above operations :① - ② - ③ - ④ ## 5. JavaBean The concept of So called JavaBean, It refers to the following standards Java Class : - Classes are public - One *** No ginseng *** The public constructor of - Properties , And the corresponding get、set Method # Class structure four : Code block Code block ( Initialization block )( Importance is more important than attribute 、 Method 、 The constructor is worse ) ## 1. What code blocks do : Used to initialize classes 、 Object information ## 2. Classification : If the code block uses modifiers , Only use static Classification : Static blocks of code vs Non static code blocks ## 3. Static blocks of code vs Non static code blocks differ ** Static blocks of code :** - Internal output statements - Execute with class loading , And only once - effect : Initialization class information - If more than one static code block is defined in a class , It is executed in the order of declaration - Execution of static blocks takes precedence over execution of non static blocks - Only static properties can be called within a static code block 、 Static methods , You can't call non static structures ** Non static code blocks :** - Internal output statements - Execute with the creation of an object - Every time you create an object , Just execute a non static code block once - effect : You can create objects , Initialize the properties of the object - If more than one non static code block is defined in a class , It is executed in the order of declaration - Static properties can be called within a non static code block 、 Static methods , Or non static properties 、 Non static methods > Be careful : When instantiating subclass objects , The parent class is involved 、 Static code blocks in subclasses 、 Non static code blocks 、 The order in which constructors are loaded : By father and son , Static first . ** Order of execution :** Static blocks of code → Non static code blocks → Constructors 1. Call the parent static block first , Static code blocks are called as classes are loaded ; 2. Then call the subclass static code block ; 3. Call the parent non static code block again , Non static code blocks are called as objects are created ; 4. Then call the constructor of the parent class ; 5. Then call the non static code block of the subclass ; 6. Then call the constructor of the subclass . One example is ``` class Root{ static{ System.out.println("Root Static initialization block of "); } { System.out.println("Root Normal initialization block of "); } public Root(){ System.out.println("Root The argument free constructor of "); } } class Mid extends Root{ static{ System.out.println("Mid Static initialization block of "); } { System.out.println("Mid Normal initialization block of "); } public Mid(){ System.out.println("Mid The argument free constructor of "); } public Mid(String msg){ // Through this Call overloaded constructors in the same class this(); System.out.println("Mid The argument constructor of , Its citation value is :" + msg); } } class Leaf extends Mid{ static{ System.out.println("Leaf Static initialization block of "); } { System.out.println("Leaf Normal initialization block of "); } public Leaf(){ // Through super Call the constructor with a string argument in the parent class super(" Call the parent constructor "); System.out.println("Leaf Constructor of "); } } public class LeafTest{ public static void main(String[] args){ new Leaf(); //new Leaf(); } } ``` Execution results : ``` Root Static initialization block of Mid Static initialization block of Leaf Static initialization block of Root Normal initialization block of Root The argument free constructor of Mid Normal initialization block of Mid The argument free constructor of Mid The argument constructor of , Its citation value is : Call the parent constructor Leaf Normal initialization block of Leaf Constructor of ``` --- Example 2 ``` class Father { static { System.out.println("11111111111"); } { System.out.println("22222222222"); } public Father() { System.out.println("33333333333"); } } public class Son extends Father { static { System.out.println("44444444444"); } { System.out.println("55555555555"); } public Son() { System.out.println("66666666666"); } public static void main(String[] args) { // By father and son Static first System.out.println("77777777777"); System.out.println("************************"); new Son(); System.out.println("************************"); new Son(); System.out.println("************************"); new Father(); } } ``` Execution results : ``` 77777777777 ************************ 11111111111 44444444444 22222222222 33333333333 55555555555 66666666666 ************************ 22222222222 33333333333 55555555555 66666666666 ************************ 22222222222 33333333333 ``` ## 4. Property assignment order 1. ① Default initialization 2. ② Explicitly initialize / ⑤ Assign a value to a code block 3. ③ Initialization in the constructor 4. ④ When you have an object , It can be done by " thing . Properties " or " thing . Method " The way , Assign The order of execution :① - ② / ⑤ - ③ - ④ # Class structure five : Inner class Inner class : The fifth member of the class ## 1. Definition of inner class : Java Allows a class to be A Declare in another class B in , Then the class A It's the inner class , Class B It's called an outer class . ## 2. Classification of internal classes : Member inner class ( Static state 、 Non static ) Regional inner class ( Within the method 、 Within the code block 、 Inside the constructor ) ## 3. Understanding of the inner class of a member : One side , As a member of an external class : - Calling the structure of an external class - Can be static Embellish - Can be 4 Different license modifications On the other hand , As a class : - Properties can be defined within a class 、 Method 、 Constructors, etc - Can be final Embellish , This class cannot be inherited . Between the lines , Don't use final, Can be inherited - Can be abstract Embellish ## 4. Member inner class : ### 4.1 How to create an object of a member's inner class ?( Static , Non static ) ``` // Create static Dog Instances of inner classes ( Static member inner class ): Person.Dog dog = new Person.Dog(); // Create non static Bird Instances of inner classes ( Non static member inner class ): // Person.Bird bird = new Person.Bird();// Wrong Person p = new Person(); Person.Bird bird = p.new Bird(); ``` ### 4.2 How to call the structure of an external class in a member's inner class ? ``` class Person{ String name = " Xiao Ming "; public void eat(){ } // Non static member inner class class Bird{ String name = " Cuckoo "; public void display(String name){ System.out.println(name);// The formal parameters of the method System.out.println(this.name);// Properties of inner classes System.out.println(Person.this.name);// Properties of external classes //Person.this.eat(); } } } ``` ## 5. Use of regional inner classes : ``` // Return an implementation of Comparable Object of the class of the interface public Comparable getComparable(){ // Build an implementation Comparable Interface class : Regional inner class // Mode one : // class MyComparable implements Comparable{ // // @Override // public int compareTo(Object o) { // return 0; // } // // } // // return new MyComparable(); // Mode two : return new Comparable(){ @Override public int compareTo(Object o) { return 0; } }; } ``` Be careful : In the method of a regional inner class ( such as :show If you call a method declared by a culture inner class ( such as :method) Regional variables in ( such as :num) And then , This local variable is required to be declared as final Of . reason : Local inner classes also generate bit group code files , When calling the culture variable of the class it belongs to , Because there are two classes , So you can't modify the properties of the class , So the class sets the property to final Provides a copy of the inner class call , Internal classes cannot be modified . - jdk 7 And previous versions : Requires that this local variable be declared explicitly as final Of - jdk 8 And later versions : It can be omitted final Announcement of > Summary : Member inner classes and culture inner classes , After compiling , Will generate a bit group code file . Bit group code file name format : Member inner class :` Outer classes $ Internal class name .class` Regional inner class :` Outer classes $ Numbers Inner class
版权声明
本文为[itread01]所创,转载请带上原文链接,感谢

  1. 【计算机网络 12(1),尚学堂马士兵Java视频教程
  2. 【程序猿历程,史上最全的Java面试题集锦在这里
  3. 【程序猿历程(1),Javaweb视频教程百度云
  4. Notes on MySQL 45 lectures (1-7)
  5. [computer network 12 (1), Shang Xuetang Ma soldier java video tutorial
  6. The most complete collection of Java interview questions in history is here
  7. [process of program ape (1), JavaWeb video tutorial, baidu cloud
  8. Notes on MySQL 45 lectures (1-7)
  9. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  10. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  11. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  12. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  13. 【递归,Java传智播客笔记
  14. [recursion, Java intelligence podcast notes
  15. [adhere to painting for 386 days] the beginning of spring of 24 solar terms
  16. K8S系列第八篇(Service、EndPoints以及高可用kubeadm部署)
  17. K8s Series Part 8 (service, endpoints and high availability kubeadm deployment)
  18. 【重识 HTML (3),350道Java面试真题分享
  19. 【重识 HTML (2),Java并发编程必会的多线程你竟然还不会
  20. 【重识 HTML (1),二本Java小菜鸟4面字节跳动被秒成渣渣
  21. [re recognize HTML (3) and share 350 real Java interview questions
  22. [re recognize HTML (2). Multithreading is a must for Java Concurrent Programming. How dare you not
  23. [re recognize HTML (1), two Java rookies' 4-sided bytes beat and become slag in seconds
  24. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  25. RPC 1: how to develop RPC framework from scratch
  26. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  27. RPC 1: how to develop RPC framework from scratch
  28. 一次性捋清楚吧,对乱糟糟的,Spring事务扩展机制
  29. 一文彻底弄懂如何选择抽象类还是接口,连续四年百度Java岗必问面试题
  30. Redis常用命令
  31. 一双拖鞋引发的血案,狂神说Java系列笔记
  32. 一、mysql基础安装
  33. 一位程序员的独白:尽管我一生坎坷,Java框架面试基础
  34. Clear it all at once. For the messy, spring transaction extension mechanism
  35. A thorough understanding of how to choose abstract classes or interfaces, baidu Java post must ask interview questions for four consecutive years
  36. Redis common commands
  37. A pair of slippers triggered the murder, crazy God said java series notes
  38. 1、 MySQL basic installation
  39. Monologue of a programmer: despite my ups and downs in my life, Java framework is the foundation of interview
  40. 【大厂面试】三面三问Spring循环依赖,请一定要把这篇看完(建议收藏)
  41. 一线互联网企业中,springboot入门项目
  42. 一篇文带你入门SSM框架Spring开发,帮你快速拿Offer
  43. 【面试资料】Java全集、微服务、大数据、数据结构与算法、机器学习知识最全总结,283页pdf
  44. 【leetcode刷题】24.数组中重复的数字——Java版
  45. 【leetcode刷题】23.对称二叉树——Java版
  46. 【leetcode刷题】22.二叉树的中序遍历——Java版
  47. 【leetcode刷题】21.三数之和——Java版
  48. 【leetcode刷题】20.最长回文子串——Java版
  49. 【leetcode刷题】19.回文链表——Java版
  50. 【leetcode刷题】18.反转链表——Java版
  51. 【leetcode刷题】17.相交链表——Java&python版
  52. 【leetcode刷题】16.环形链表——Java版
  53. 【leetcode刷题】15.汉明距离——Java版
  54. 【leetcode刷题】14.找到所有数组中消失的数字——Java版
  55. 【leetcode刷题】13.比特位计数——Java版
  56. oracle控制用户权限命令
  57. 三年Java开发,继阿里,鲁班二期Java架构师
  58. Oracle必须要启动的服务
  59. 万字长文!深入剖析HashMap,Java基础笔试题大全带答案
  60. 一问Kafka就心慌?我却凭着这份,图灵学院vip课程百度云