Object oriented foundation of java

Object oriented overview

First, what is object-oriented?

Object oriented is relative to process oriented. It refers to organizing relevant data and methods into a whole, and modeling the system from a higher level, so as to be closer to the natural operation mode of things.
Transformation from process oriented to object-oriented thinking:
Process oriented focuses on the process of execution, and object-oriented focuses on the objects with functions.
Process oriented to object-oriented is the change of programmer's thought from executor to commander.

for instance:

Q:
How many steps does it take to put an elephant in the fridge?
answer:
Process oriented answer:
Step 3: 1 Open the refrigerator door, 2 Put the elephant in, 3 Close the refrigerator door
Object oriented answer:
Step 2: 1 Recruit a worker (object) who can operate the refrigerator, 2 Command workers to load elephants
reflection:
If the question is changed to: put 100 How many steps are there for elephants to close into the refrigerator in turn?
Process oriented answer: it needs to be omitted here N Word...
Object oriented answer or 2 Step:
1 Recruit a worker (object) who can operate the refrigerator, 2 Command the workers to load the elephants in turn.
So simply put, process oriented is a step-by-step process. Object oriented is a process of writing repetitive things into an assembly method and calling this method with an object.

Relationship between class and object

The relationship between the two

Class represents a product of commonness, which is a comprehensive feature, while object is a product of individuality and an individual feature.
(similar to the concept of drawings and real objects in life.)
A class can only be used through an object, and all operations of the object are defined in the class.
Class consists of properties and methods:
Attribute: it is equivalent to the characteristics of people {String, int, double...}
Method: it is equivalent to people's behaviors one by one, such as talking, eating, singing and sleeping (void say() {...})

Creation of classes and objects

Class definition format

class Class name {
Member properties
Member method
}

Where attributes and methods

Attribute definition format:
Data type property name ;(String name;)
Format of attribute definition and assignment:
Data type property name = initialize value ; (String name = "Zhang San"
Method definition format:
Permission modifier return value type Method name ( Formal parameter list ){
/ / method body
        return Return value;
}
package last302;

public class Bleiyuduixiangchuanjian1 {

	public static void main(String[] args) {
		
		//Format for creating objects:
		Person p =new Person();
		
		//Object attribute assignment
		//Format: object name Attribute name = value;
		p.name="Zhao Xinkun";
		p.age=22;
		p.sex='male';
		p.say();
		
		int s =p.sum(1124,813);
		System.out.println(s);
	}

}
/**
 * A class is a drawing
 * */
//Write create class
class Person{
	//Properties -- properties
	String name;
	int age;
	char sex;
	
	
	//Method behavior
		/**
		 * Define format:
		 * Return value type method name (formal parameter table){
		 * Method body
		 * return Return value;
		 * }
		 * 
		 * 
		 * Call format:
		 * Object name Method name (actual parameter list);
		 * 
		 * */
	//Null return value method
	void say(){
		System.out.println("My name is:"+name+"My age is:"+age+"My gender is:"+sex);
	};
	
	//Method with return value type
	int sum(int x,int y) {
		int z =x+y;
		return z;
	};
}

objects creating

If a class wants to really operate, it must rely on objects. The definition format of objects is as follows :
Class name object name = new Class name () ;
If you want to access a property or method (definition of a method) in a class, you can rely on the following syntax form:
Accessing properties in a class: object attribute ;
Call method in class: object method ( Actual parameter list);         
package last302;

public class Cduixiangchuangjianbuchong {

	public static void main(String[] args) {
		Book b1 = new Book();
		Book b2 = new Book();
		b1.name = "Golden Apple";
		b1.info = "It tells the hard journey of fruit farmers planting golden apples.";
		b2.name = "Silver Apple";
		b2.info = "It tells the hard journey of fruit farmers planting silver apples.";
	
		b1.say();
    	b2.say();
		
	}
}
	class Book{
		String name;
		String info;
		
		void say() {
			System.out.println("The name of the book is:"+"Introduction to the book:"+info);
		}
	}

Object creation memory

This involves the knowledge of stack, heap and method area. Please understand it by yourself. Thank you.

package last302;

public class Dduixiangchaungjianneicun {

	public static void main(String[] args) {
		Boook b1 = new Boook();
		b1.name = "The Plum in the Golden Vase";
		b1.info = "Educational books";
		b1.say();
		
		Boook b2 = b1;
		b2.name = "Hey, hey, hey";
		b1.say();
		
	}
}

class Boook{
	String name;
	String info;
	
	void say(){
		System.out.println("title:"+name+",Introduction:"+info);
	}
}
package last302;

public class Eduixiangchuanjianneicun03 {

	public static void main(String[] args) {
		red b1 = new red();
		b1.name = "The Plum in the Golden Vase";
		b1.info = "Hey, hey, hey";
		
		red b2 = new red();
		b2.name = "Water Margin";
		b2.info = "The story of Liangshan hero";
		
		b2 = b1;
		b2.name = "Journey to the West";
		b1.say();
		
		//The main explanation here is about the details of stack, heap and method area, as well as the mechanism of GC garbage collection
	}

}

class red{
	String name;
	String info;
	
	void say() {
		System.out.println("title"+name+",Introduction:"+info);
	}
}

Construction method

Review the creation of objects

Person p = new Person();
On the right Person Parentheses that appear after , It's actually calling the constructor !

summary

effect:
Used for object initialization.
Execution time:
When creating objects , Automatic call
characteristic:
be-all Java There will be at least one constructor in the class
If there is no explicit writing construction method in a class , The compiler will automatically generate a parameterless constructor , There is no code in the constructor!
If you write any constructor yourself , The compiler will no longer automatically generate parameterless constructors.

Define format

It is basically the same as the ordinary method , The difference is : The method name must be the same as the class name , No declaration of return value type !
//case
public class Demo3{
        public static void main(String[] args){
                Person p = new Person();
                p = new Person();
                p = new Person();
                p = new Person();
        }
}
class Person{
        public Person(){
                System.out.println("Object creation,This method calls");
        }
}
package last302;

public class Fgouzaofangfa {

	public static void main(String[] args) {
		System.out.println("1");
		Person2 p1 = new Person2("I'm Zhang San");
		System.out.println("2");
		//p1.name = "Zhang San";
		p1.age = 18;
		p1.say();
		
		

	}

}

class Person2{
	//Here, when we do not set a construction method, the system will automatically claim a parameterless construction method
	String name;
	int age;
	//Now let's set up a construction method with parameters and try it
	Person2(String n){
		//System.out.println("I executed");
		name = n;
	}
	
	void say(){
		System.out.println("self-introduction I am"+name+"My age is:"+age);
	}
}

be careful:

It is recommended to customize the parameterless construction method and do not rely on the compiler to avoid errors.
When there are non constant member variables in the class, it is recommended to provide two versions of construction methods, one is the nonparametric construction method, and the other is the construction method with all attributes as parameters.
When no member of the class is a constant or no member of the class is recommended.

Overloading of methods

Heavy load condition:

Same method name , Parameter type or parameter length is different , Method overloading can be completed !
Method overloading is independent of the return value !
Overloading of methods , Can let us under different needs , Call methods by passing different parameters to complete specific functions.
package last302;

public class Gfnagfadechongzai {

	public static void main(String[] args) {
		Math b1 = new Math() ;
		int num = b1.sum(100, 120);
		System.out.println(num);
		
		double num2 = b1.sum(100.11, 120.22);
		System.out.println(num);

	}

}
/**
 * Overloading of methods
 * First of all, the naming of classes should be standardized to see the meaning
 * 
 * 
 * Methods defined in a class are allowed to be overloaded (the same method name)
 * 
 * 1.Same method name
 * 2.Parameter list length or parameter list type (different order of parameter types)
 * 
 * Note: it is independent of the return value type*/

class Math{
	
	int sum(int x, int y){
		int z = x +y;
		return z;
	}
	
	double sum(double x, double y){
		double z = x +y;
		return z;
	}
	
	double sum(double y ,int x) {
		double z = x + y;
		return z;
	}
}

Construction method overload

A class , There can be multiple construction methods :
The overload of the construction method can be completed if the length or type of the parameter list is different.
Overloading of construction methods , It allows us to create objects under different requirements , Call different methods to complete the initialization of the object !
package last302;

public class Hgouzaofangfadechongzai {

	
	/**
	 * There can be multiple construction methods for a class:
	 *  If the length or type of the parameter list is different, the overload of the construction method can be completed
	 * We can call different methods to complete the initialization of objects under different needs of creating objects!
	 * */
	public static void main(String[] args) {
		Person3 z = new Person3("Zhang San",18);
		z.say();
		
		Person3 x = new Person3("Zhao Si");
		x.say();
		
	}

}

class  Person3 {
	
	
	Person3(String name2,int age2){
		name = name2;
		age = age2;
	}
	
	Person3(String name2){
		name = name2;
		
	}
	
	
	String name;
	int age;
	
	
	
	void say() {
		System.out.println("name is" +name+"age is"+age);
	}
}

Anonymous object

An object without an object name is an anonymous object.
Anonymous objects can only be used once. Because there is no object reference, they will be called garbage and wait to be used G·C Recycling.
Objects used only once can be completed by anonymous objects, which will be often used in future development.
package last302;

public class Inimingduixiang {
//An anonymous object is an object without a name
	public static void main(String[] args) {
	
		//According to the usual habit, we will declare and call objects in this way
		/**
		 *Math2 m = new Math2();
		 *int num = m.sum(100, 200);
		 * System.out.println(num);
		 * */
		
		//Now write a new, nameless object and call the method directly
		int num = new Math2().sum(100, 200);
		System.out.println(num);
	}

}


//First write a class
class Math2{
	
	int sum(int x,int y) {
		return x+y;
	}
}

misunderstanding

package last302;

public class Jnimingduixiang2 {

	public static void main(String[] args) {
		
		
		//Misunderstanding of creating objects
		new Person4().name = "Zhang San";
		new Person4().age = 18;
		new Person4().say();
		
	 //This is not right, because creating it in this way is equivalent to creating three different spaces in heap memory
		
		
	}

}
class Person4{
	String name;
	int age;
	
	void say() {
		System.out.println("introduce oneself to:"+name+"Age is"+age);
	}
	
	
}

Keywords: Java Back-end OOP

Added by mister_t101 on Thu, 24 Feb 2022 02:36:03 +0200