Encapsulation - Super keyword

Catalog

encapsulation ：

super keyword

this And super The difference between ：

---

encapsulation ：

Concept

Encapsulation is to encapsulate abstract data attributes and operation methods of data , The data is inside by white tiger , Other parts of the program can operate on data only by authorized operation methods .

benefits

1） Hide implementation details

2） You can validate the data , Make sure it's safe and reasonable

step

1） Property privatization

2） Public （public）set,get Method , Used to judge and assign values to attributes

public class test {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(30);
        System.out.println(person.info());
        // If we use constructors to specify properties ourselves 
        Person smith = new Person(30);
        System.out.println("====smith Information about ======");
        System.out.println(smith.info());
    }
}
class Person {
    private int age; //age  Privatization 
    public void say(int n) {
    }
    public Person() {
    }
    // Constructor with three properties 
    public Person(int age) {
//        this.age = age;
        // We can set The method is written in the constructor , This can still verify 
        setAge(age);
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        // Judge 
        if (age >= 1 && age <= 120) {// If it's a reasonable range 
            this.age = age;
        } else {
            System.out.println(" You set the wrong age , Need to be in  (1-120),  Give the default age 18 ");
            this.age = 18;// Give a default age 
        }
    }
    // Write a method , Return attribute information 
    public String info() {
        return  " age=" + age;
    }
}

super keyword

1. Basic introduction

super The reference representing the parent class , Used to access the properties of the parent class 、 Method 、 Constructors 2. Basic grammar

1） Access the properties of the parent class , But not visit Of the parent class private attribute

super. Property name ;

2） Methods to access the parent class , But you can't access the parent's private Method

super. Method name （ parameter list ）;

3） Access the constructor of the parent class

super（ parameter list ）; Only in the first sentence of the constructor

3.super Convenience

1） Call the constructor of the parent class , A clear division of responsibilities , The parent class property is initialized by the parent class , Subclass properties are initialized by subclasses

2） When a subclass has members in the parent class （ Properties and methods ） When you have two names , To access members of the parent class , Must pass super. If there are no duplicate names , Use super,this, Direct access has the same effect

// call cal Method 
 
package super_;
 
public class Base {
    public void cal() {
        System.out.println("Base  Class  cal()  Method ...");
    }
    
}
 
 
//A None in class cal Method 
 
 public void sum() {
        System.out.println("B  Class  sum()");
// Subclass  B  No,  cal  Method , So I can use the following three ways 
// look for  cal  When the method is used (cal()  and  this.cal()), The order is :
// (1) Find this class first , If there is , Call 
// (2) without , Then find the parent class ( If there is , And can call , Call )
// (3) If the parent class doesn't have , Then continue to find the parent of the parent class , The whole rule , It's the same , until  Object  class 
//  If in the process of finding a method , eureka , But there is no access ,  False report , cannot access
//  If in the process of finding a method , Can't find , The prompt method does not exist 
//cal();
 this.cal(); // Equivalent  cal();
// look for  cal  Method (super.call())  The order is to find the parent class directly , The other rules are the same 
//super.cal();
 
//n1  and  this.n1  The rule of search is 
//(1)  Find this class first , If there is , Call 
//(2)  without , Then find the parent class ( If there is , And can call , Call )
//(3)  If the parent class doesn't have , Then continue to find the parent of the parent class , The whole rule , It's the same , until  Object  class 
//  Tips ： If in the process of finding properties , eureka , But there is no access ,  False report , cannot access
//  If in the process of finding properties , Can't find , The prompt property does not exist 
        System.out.println(n1);
        System.out.println(this.n1);///888
// look for  n1 (super.n1)  The order is to find the parent class attribute directly , The other rules are the same 
        System.out.println(super.n1);//999
    }
 
 
package super_;
 
public class Test {
    public static void main(String[] args) {
 
        B b = new B();
        b.sum();
    }
}

this And super The difference between ：