感谢大家的支持,你们的支持就是我的动力，如果对您有所帮助，请转发并收藏，谢谢！
一、继承
继承是所有OOP语言不可缺少的部分，在java中使用extends关键字来表示继承关系。当创建一个类时，总是在继承，如果没有明确指出要继承的类，就总是隐式地从根类Object进行继承。
基本语法：
class 子类 extends 父类{}
演示代码：
class Person {
public Person() {
}
}
class Man extends Person {
public Man() {
}
}
类Man继承于Person类，这样一来的话，Person类称为父类（超类），Man类称为子类（派生类）。如果两个类存在继承关系，则子类会自动继承父类的方法和变量，在子类中可以调用父类的方法和变量。在java中，只允许单继承，也就是说 一个类最多只能显示地继承于一个父类。但是一个类却可以被多个类继承，也就是说一个类可以拥有多个子类。
1.子类继承父类的成员变量
当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。具体的原则如下：
1）能够继承父类的public和protected成员变量；不能够继承父类的private成员变量；
2）对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；
3）对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。
演示代码：
class Person{
private String name;
private int age;
public void setName(String name){
this .name = name;
}
public void setAge( int age){
this .age = age;
}
public String getName(){
return this .name;
}
public int getAge(){
return this .age;
}
}
class Student extends Person{ //Student类继承了Person类
//此类没有定义任何的操作方法
}
public class TestDemo{
public static void main(String args[]){
Student stu = new Student(); // 实例化 子类
stu.setName(“沐兮沐楚”); //Person类定义
stu.setAge(20); //Person类定义
System. out .println(“姓名:” + stu.getName() + “,年龄:” + stu.getAge());
}
}
2.子类继承父类的方法并扩充
同样地，子类也并不是完全继承父类的所有方法，但可以继续扩充。
1）能够继承父类的public和protected成员方法；不能够继承父类的private成员方法；
2）对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；
3）对于子类可以继承的父类成员方法，如果在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。
注意：隐藏和覆盖是不同的。隐藏是针对成员变量和静态方法的，而覆盖是针对普通方法的。
演示代码：
class Person{
private String name;
private int age;
public void setName(String name){
this .name = name;
}
public void setAge( int age){
this .age = age;
}
public String getName(){
return this .name;
}
public int getAge(){
return this .age;
}
}
class Student extends Person{ //Student类继承了Person类
private String school; //子类扩充的属性
public void setSchool(String school){ //扩充的方法
this .school = school;
}
public String getSchool(){ //扩充的方法
return this .school;
}
}
public class TestDemo{
public static void main(String args[]){
Student stu = new Student(); //实例化子类
stu.setName(“沐兮沐楚”); //Person类定义
stu.setAge(20); //Person类定义
stu.setSchool(“清华大学”);
System. out .println(“姓名:” + stu.getName() + “,年龄:” + stu.getAge() + “,学校:” + stu.getSchool());
}
}
3. 构造器
子类是不能够继承父类的构造器，但是要注意的是，如果父类的构造器都是带有参数的，则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。看下面这个例子就清楚了：
代码演示：
class Shape {
protected String name;
public Shape(){
name = “沐兮沐楚”;
}
public Shape(String name) {
this.name = name;
}
}
class Circle extends Shape {
private double radius;
public Circle() {
radius = 0;
}
public Circle(double radius) {
this.radius = radius;
}
public Circle(double radius,String name) {
this.radius = radius;
this.name = name;
}
}
这样的代码是没有问题的，如果把父类的无参构造器去掉，则下面的代码必然会出错：
class Shape {
protected String name;
// public Shape(){
// name = “沐兮沐楚”;
// }
public Shape(String name) {
this.name = name;
}
}
改成下面这样就行了：
class Shape {
protected String name;
// public Shape(){
// name = “沐兮沐楚”;
// }
public Shape(String name) {
this.name = name;
}
}
class Circle extends Shape {
private double radius;
public Circle() {
super(“沐兮沐楚”);
radius = 0;
}
public Circle(double radius) {
super(“沐兮沐楚”);
this.radius = radius;
}
public Circle(double radius,String name) {
super(“沐兮沐楚”);
this.radius = radius;
this.name = name;
}
}
4.继承的限制
限制一 :一个子类只能够继承一个父类,存在单继承局限;
演示代码：
class A{}
class B{}
class C extends A,B{}//错误：一个子类继承了两个父类
限制二 :在子类继承时,实际上会继承父类中的所有操作(属性,方法),但是需要注意的是,对于所有的非私有(no private)操作属于显式继承(可以直接利用对象操作),而所有的私有操作属于隐式继承(间接完成)
演示代码：
class Shape {
private String name = “沐兮沐楚”;
}
class Circle extends Shape {
public void print(){
System.out.println(name); //错误：The field Shape.name is not visible
}
}
限制三 :在继承关系中,如果要实例化子类对象,会默认先调用父类构造,为父类中的属性初始化,之后再调用子类构造,为子类中的属性初始化,即默认情况下,子类会找到父类中的无参 构造方法 .
演示代码：
class A{
public A(){
System. out .println(“*********父类无参构造***********”);
}
}
class B extends A{
public B(){
System. out .println(“———-子类无参构造—————–“);
}
}
public class TestDemo{
public static void main(String args[]){
B b = new B(); //实例化子类对象
}
}
5.super
super主要有两种用法：
1）super.成员变量、super.成员方法;
2）super(parameter1,parameter2….)
第一种用法主要用来在子类中调用父类的同名成员变量或者方法；
第二种主要用在子类的构造器中显示地调用父类的构造器。
注意：如果是用在子类构造器中，则必须是子类构造器的第一个语句。
1.子类构造方法中隐含了一个super()
演示代码：
class B extends A{
public B(){
super();
System.out.println(“———-子类无参构造—————–“);
}
}
2. 默认情况下，子类调用的是父类中的无参构造方法，而如果这个时候父类没有无参构造，则子类必须通过super()调用指定参数的构造方法。
演示代码：
class A{
public A(String msg){
System. out .println(“*********父类无参构造***********”);
System. out .println(“msg = ” + msg);
}
}
class B extends A{
public B(){
super (“沐兮沐楚”);
System. out .println(“———-子类无参构造—————–“);
}
}
public class TestDemo{
public static void main(String args[]){
B b = new B(); //实例化子类对象
}
}
二、覆写
1.覆写概念
既然现在出现了继承的关系，那么就存在了子类和父类的联系，而在子类之中有可能定义和父类完全相同的方法或属性的名称，这个时候就称为覆写了。
2.方法的覆写
当子类定义了和父类在方法名称、返回值类型、参数类型及个数完全相同的方法的时候，称为方法的覆写。
演示代码（没有覆写的操作）：
class A {
public void print() {
System.out.println(“沐兮沐楚”);
}
}
class B extends A {
}
public class TestDemo {
public static void main(String args[]) {
B b = new B();
b.print(); // 方法从父类继承而来
}
}
这时实例化的是子类对象，但是在子类中没有print()方法，那么就使用从父类中继承而来的pritn()方法。
演示代码（实现覆写）：
class A {
public void print() {
System.out.println(“沐兮沐楚”);
}
}
class B extends A {
public void print() {// 方法名称、参数类型及个数、返回值全相同
System.out.println(“沐兮沐楚，你好。”);
}
}
public class TestDemo {
public static void main(String args[]) {
B b = new B();
b.print(); // 方法从父类继承而来
}
}
3.当一个类中的方法被覆写后，如果实例化的是这个子类对象，则调用的方法就是被覆写过的方法。
在进行方法覆写的时候有一点需要注意： 被子类所覆写的方法不能拥有比父类更严格的访问控制权限。
如果此时父类之中的方法是default权限，那么子类覆写的时候只能是default或public权限，而如果父类的方法是public，那么子类之中方法的访问权限只能是public。
当一个子类覆写了一个父类方法的时候，子类要想调用父类的被覆写过的方法，要在方法前要加上“super”：
演示代码：
class A {
public void print() {
System.out.println(“沐兮沐楚”);
}
}
class B extends A {
public void print() {// 方法名称、参数类型及个数、返回值全相同
super.print();
System.out.println(“沐兮沐楚，你好。”);
}
}
public class TestDemo {
public static void main(String args[]) {
B b = new B();
b.print(); // 方法从父类继承而来
}
}
4.一定要记住操作范围：
（1）this.方法()：先从本类查找是否存在指定的方法，如果没有找到，则调用父类操作；
（2）super.方法()：直接由子类调用父类之中的指定方法，不再找子类。
三、this和super区别
四、方法重载与覆写的区别
