封装，继承，super关键字

封装

• 该露的露，该藏的藏

  ​ 我们的程序设计要追求"高内聚，低耦合"。高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

• 封装（数据的隐藏）

  ​ 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称作信息的隐藏

• 属性私有，get/set

封装的特点：

• 1.提高程序的安全性，保护数据
  2.隐藏代码的实现细节
  3.统一接口
  4.系统可维护增加
  

代码：

package com.oop;
/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加
 */

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("施刚龙");

        System.out.println(s1.getName());//施刚龙

        s1.setAge(21);
        System.out.println(s1.getAge());

    }
}

package com.oop;
//类   private:私有
public class Student {
    //属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄

    //提供一些可以操作这些属性的方法!
    //提供一些public的get和set方法

    //get获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    public int getId(){
        return this.id;
    }
    public void setId(int age){
        this.id = id;
    }

    public char getSex(){
        return this.sex;
    }
    public void setSex(char sex){
        this.sex = sex;

    }

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

继承

• extends关键字
• Java类只有单继承，没有多继承
• 继承关系的两个类：一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends。
• Object类，super关键字，方法的重写
• 被final定义的类不能被继承（记住就可了）

代码：

package com.Demo01;

//Java中，所有的类都默认直接或间接继承Obje类
//Person 人:父类
public class Person {

    //public
    //protected
    //default  默认
    //private
    public int money = 1000000000;

    public void speak(){
        System.out.println("hello大家好");
    }

    public int getMoney(){
        return this.money;
    }
    public void setMoney(int money){
        this.money = money;
    }



}

package com.Demo01;

public class Student extends Person{
}

package com.Demo01;

public class Teacher extends Person{

}

package com.Demo01;

public class Application {
    public static void main(String[] args) {

        Student student = new Student();

        student.speak();
        System.out.println(student.money);//1000000000

        student.setMoney(10000);
        System.out.println(student.getMoney());//10000


        Person person = new Person();

    }
}

super 关键字

注意点：

• super调用父类的构造方法，必须在构造方法的第一个！！！
• super 必须只能出现在子类的方法或者构造方法中
• super和this 不能同时调用构造方法

VS this：(指向自己的引用）

• 代表的对象不同：

  1. this：本身调用者这个对象
  2. super：代表父类对象的应用

• 前提：

  1. this：在没有继承也可以使用
  2. super：只能在继承条件下才可以使用

• 构造方法

  1. this()：调用本类的构造
  2. super()：调用父类的构造

代码：（不会多看!!!）

package com.Demo01;

public class Application {
    public static void main(String[] args) {

        Student student = new Student();//自动调用无参构造
        //Student student = new Student(22);//传入参数调用有参构造方法
        student.test("秦疆");

        student.test1();


    }

package com.Demo01;

public class Student extends Person{

    private String name = "施刚龙";
    public int age;

    public void test(String name){
        System.out.println(name);//秦疆
        System.out.println(this.name);//施刚龙
        System.out.println(super.name);//狂神

    }


    public void print(){
        System.out.println("Student");
    }

    public void test1(){

        print();//Student
        this.print();//Student
        super.print();//Person
        //super.hello();//私有的东西无法继承
    }


    public Student(){
        //默认调用了父类的无参构造，super()可以不写
        super();//调用父类的构造器，必须在子类构造器的第一行
        //this();//调用有参构造方法，传入"hello"
        System.out.println("Student无参构造执行了");
    }

    public Student(int age){//通过this()调用，但this()和super()不能同时调用构造方法
        super(21);
        this.age = age;
        System.out.println(this.age);
        System.out.println("Student有参构造执行了");

        
    }
    
}

package com.Demo01;

//Java中，所有的类都默认直接或间接继承Object类
//Person 人:父类
public class Person {
    protected String name = "狂神";
    public int age;

    public void print(){
        System.out.println("Person");
    }

    //私有的东西无法被继承
    private void hello(){
        System.out.println("Hello");
    }


    public Person(){
        System.out.println("Person无参构造执行了");
    }
    public Person(int age){
        this.age = age;
        System.out.println(this.age);
        System.out.println("Person有参构造执行力");
    }