封装——super关键字

目录

封装：

super关键字

this与super的区别：

---

封装：

概念

封装就是把抽象的数据属性和对数据的操作方法封装在一起，数据被白虎在内部，程序的其他部分只有被授权的操作方法才可以对数据进行操作。

好处

1）隐藏实现细节

2）可以对数据进行验证，保证安全合理

步骤

1）属性私有化

2）公共的（public）set，get方法，用于对属性的判断和赋值

public class test {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(30);
        System.out.println(person.info());
        //如果我们自己使用构造器指定属性
        Person smith = new Person(30);
        System.out.println("====smith的信息======");
        System.out.println(smith.info());
    }
}
class Person {
    private int age; //age 私有化
    public void say(int n) {
    }
    public Person() {
    }
    //有三个属性的构造器
    public Person(int age) {
//        this.age = age;
        //我们可以将set方法写在构造器中，这样仍然可以验证
        setAge(age);
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        //判断
        if (age >= 1 && age <= 120) {//如果是合理范围
            this.age = age;
        } else {
            System.out.println("你设置年龄不对，需要在 (1-120), 给默认年龄18 ");
            this.age = 18;//给一个默认年龄
        }
    }
    //写一个方法，返回属性信息
    public String info() {
        return  " age=" + age;
    }
}

super关键字

1.基本介绍

super 代表父类的引用，用于访问父类的属性、方法、构造器 2.基本语法

1）访问父类的属性，但不能访问父类的private属性

super.属性名；

2）访问父类的方法，但不能访问父类的private方法

super.方法名（参数列表）；

3）访问父类的构造器

super（参数列表）；只能放在构造器的第一句

3.super的便利

1）调用父类的构造器的好出，分工明确，父类属性由父类初始化，子类属性由子类初始化

2）当子类有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super，this，直接访问的效果一样

//调用cal方法
 
package super_;
 
public class Base {
    public void cal() {
        System.out.println("Base 类的 cal() 方法...");
    }
    
}
 
 
//A类中无cal方法
 
 public void sum() {
        System.out.println("B 类的 sum()");
//子类 B 没有 cal 方法，因此我可以使用下面三种方式
//找 cal 方法时(cal() 和 this.cal())，顺序是:
// (1)先找本类，如果有，则调用
// (2)如果没有，则找父类(如果有，并可以调用，则调用)
// (3)如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类
// 如果查找方法的过程中，找到了，但是不能访问， 则报错, cannot access
// 如果查找方法的过程中，没有找到，则提示方法不存在
//cal();
 this.cal(); //等价 cal();
//找 cal 方法(super.call()) 的顺序是直接查找父类，其他的规则一样
//super.cal();
 
//n1 和 this.n1 查找的规则是
//(1) 先找本类，如果有，则调用
//(2) 如果没有，则找父类(如果有，并可以调用，则调用)
//(3) 如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类
// 提示：如果查找属性的过程中，找到了，但是不能访问， 则报错, cannot access
// 如果查找属性的过程中，没有找到，则提示属性不存在
        System.out.println(n1);
        System.out.println(this.n1);///888
//找 n1 (super.n1) 的顺序是直接查找父类属性，其他的规则一样
        System.out.println(super.n1);//999
    }
 
 
package super_;
 
public class Test {
    public static void main(String[] args) {
 
        B b = new B();
        b.sum();
    }
}

this与super的区别：