Create object memory analysis and inheritance

package com.rgf.oop.Demo04;

public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name=" Wangcai ";
        dog.age=3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
       
    }
}

package com.rgf.oop.Demo04;

public class Pet {
    public String name;
    public int age;
    // No arguments structure 
    public void shout(){
        System.out.println(" Let out a cry ");
    }
}

We use these two pieces of code to analyze the memory at the moment ：

Memory is divided into stacks and heaps , There is also a method area in the pile .

The first step is , We will reduce the Application Some code information of this class is put into memory , That is, load... In the method area in the heap Application class , This class has main() Method , And some strings , We generally call it a constant . There is usually a constant pool , There are some constants . for example ： Constant pool ： Wangcai

Then we carry out main Method time ,main The method is at the bottom of the stack , We execute main Method time , We want to new One class , It's called Pet, We're going to create this class Pet, This class has name and age These two fields , There's another way called shout( ). We have Pet After this class , We carry out new In this class , We enter Pet This class .new The generated object name is in the stack （ Reference variable name ）, And the real object is in the heap .

In the pile, what we new Class Pet, There will be a memory address , We assume that 0x0001, That is, the memory address of the object . And there is a default name=null,age=0, There's another way shout(), This method is new What is called is the method area in the heap Pet Of shout() Method .

After completing the above, we succeeded new Come out with an object , Then we'll assign values to these objects

And the method area in the heap also has a static method area static, The methods in this are loaded together with the class , All objects can use this static method .

In the stack ,main() Method is pushed into the bottom of the stack , Then we call other methods , After other methods are called ,main() Method pop up , Program end .

Summary of classes and objects ：

package com.rgf.oop.Application;

public class Application {
    /*
    1. Classes and objects 
     Class is a template ： abstract , Object is a concrete instance 
    2. Method 
     Definition 、 call 
    3. References to objects 
     Reference type ： Basic types （8）
     Objects are manipulated by reference ： Stack （ Reference object ）-----> Pile up （ Real object , Address ）
    4. attribute ： Field Field  Member variables 
     Default initialization ：
     Numbers ：  0  0.0
    char:u0000
    boolea:false
     quote ：null
     Definition of attribute :
     Modifier    Attribute types   Property name = Property value ！
    5. Method ： Define and call 
    6 . Object creation and use ：
    （1） You have to use new Keywords create objects , Constructors Person rgf=new Person();
    （2） Object properties    rgf.name;
    (3) Object method     rgf.sleep();
    7. class ：
     Static properties     attribute 
     Dynamic behavior     Method 
   encapsulation 、 Inherit 、 polymorphic 
    
     */
}

encapsulation ： The dew of the dew , What should be hidden

Our programming should pursue “ High cohesion , Low coupling ”. High cohesion means that the internal data operation details of a class are completed by themselves , External interference is not allowed ;

Low coupling ： Only a few methods are exposed for external use .

encapsulation （ Data hiding ）

Usually , Direct access to the actual representation of data in an object should be prohibited , It should be accessed through the operation interface , This is called information hiding .

Just remember this sentence ： Property private ,get/set

The concrete embodiment of encapsulation thought ：

package com.rgf.oop.Demo05;
/*
1. Improve the security of the program , Protection data .
2. Hide the implementation details of the code 
3. Unified interface 
4. Improve the maintainability of the system 
 */
public class Application {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.getId();
        stu1.getAge();
        // stay java in , If you judge whether the two methods of a class are the same ,
        //  There are two main references , Method name and parameter list , If the method name is the same , The method must be the same ,
        // If the parameter list is the same , Then it must be the same way .
        stu1.setName("rgf");
        stu1.setId(5);
        stu1.setAge(5);
        //stu1.setAge(999); // illegal 
        System.out.println(stu1.getAge()); //println Method overloading 
        System.out.println(stu1.getName());
        System.out.println(stu1.getId());
    }
}

package com.rgf.oop.Demo05;
// class   private: Private access 
public class Student {

    // Property private 
    private String name; // name 
    private int id; // Student number 
    private char sex;// Gender 
    private int age;// Age 

    // Provide some methods to manipulate this property ！
    // Provide some public Of get、set Method .

    //get  Get this data 
    public String getName() {
        return this.name;
    }

    public int getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {
            this.age = 3;
        } else {
            this.age = age;
        }
    }

        //set  Set a value for this data 
        public void setName (String name){
            this.name = name;
        }

        public void setId ( int id){
            this.id = id;

        }
    }

The operation interface is as follows ：

  We can take advantage of IDEA Conduct set and get Method implementation ：

1. Right click , choice Generate.

 2. Click on Generate after , Click on Getter and Setter.

 3. Select the... You want to create get perhaps set Properties of method .