封装&继承&Super&重写

封装

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

创建一个main方法，在同一个包下创建另一个类Student，里面封装一些方法和属性。如果是private私有属性的话，就不能被其它类调用，但是可以在需要用的类里面通过实例化对象，new一个student，用student.来调用

student里面的方法，通过方法来使用它的私有属性，例如：

package com.oop;
import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("littlebear_s");
        System.out.println(student.getName());
    }
}

package com.oop.demo04;

public class Student {
    private String name;
    private int id;
    private char sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

添加get和set方法快捷键：alt + insert

继承

有个人叫Gris

package com.oop.demo05;

public class Gris extends Person {
}

她老汉叫Person，而且账户里面有10个亿

package com.oop.demo05;

public class Person {
    public int money = 10_0000_0000;
}

她想用：

package com.oop.demo05;

public class Gris extends Person {
    public static void main(String[] args) {
        Gris gris = new Gris();
        System.out.println(gris.money);
    }
}

结果遭她老汉发现了，把钱收起来了

package com.oop.demo05;

public class Person {
    private int money = 10_0000_0000;
}

她就用不到了

package com.oop.demo05;

public class Gris extends Person {
    public static void main(String[] args) {
        Gris gris = new Gris();
        System.out.println(gris.money);
    }
}

查看继承关系快捷键：alt + h

Super

子类可以通过super来调用父类的方法和属性

• Gris要调用Person里面的属性：

  public void test(){
      System.out.println(super.money);
  }
  

• 测试类里面的代码：

  public static void main(String[] args) {    Gris gris = new Gris();    gris.test();}
  

  输出1000000000

一个类只要有有参构造，就一定要加上无参构造

在父类和子类里面各加上无参构造器：

public class Person {    public Person(){        System.out.println("Person无参构造器执行了");    }}

public class Gris extends Person {    public Gris(){//无参构造器        System.out.println("Gris无参构造器执行了");    }}

在测试类里面new一个Gris，输出结果为

//Person无参构造器执行了//Gris无参构造器执行了

说明了，程序在new的时候，先去使用父类的无参构造器，再使用子类的构造器，就相当于在子类的无参构造的第一行代码有一串隐藏代码：

public class Gris extends Person {    public Gris(){//无参构造器        super();//隐藏代码，调用了父类的无参构造器，而且必须在子类构造器的第一行！        System.out.println("Gris无参构造器执行了");    }}

注意

• 如果父类只有有参构造器，没有无参构造器的话，想要在子类里面使用无参就不行，意思是子类必须要跟父类保持一致，所以，这个时候，子类也只能用有参，不能用无参
• super和this不能同时调用构造方法

方法重写

1. 需要有继承关系，子类重写父类的方法！

   • 方法名必须相同
   • 参数列表必须相同
   • 修饰符：范围可以扩大：public>Protect>Default>private
   • 抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大)

2. 重写，子类的方法和父类必须要一致，方法体不同

3. 为什么需要重写：

   • 父类的功能，子类不一定需要，或者不一定满足

   alt + insert ： override

4. 重写跟静态方法没有任何关系，只跟非静态方法有关，不能加static

输出结果为：

A=>test()
A=>test()

封装&继承&Super&重写

原文：https://www.cnblogs.com/littlebear-s/p/14826695.html