四、JAVA类的继承、super关键字、this和super的区别、重写与重载的区别

1. 继承

1.1 概念

继承是面向对象最显著的一个特性。

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类。

这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。

提高复用性：只要继承父类，就能有一样的功能

class A extends c{  //原来的eat()拿走了   }

class B extends c{  //原来的eat()拿走了  }

class c{
    public void eat(){
       syso("eat");
    }
}

1.2 特点

1、 使用extends关键字

2、 相当于子类把父类的功能复制了一份

3、 java只支持单继承

4、 继承可以传递（爷爷，儿子，孙子的关系）

5、 不能继承父类的私有成员

6、 继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展

1.3 案例

public class TTT {
       public static void main(String[] args) {
              Zi zi = new Zi();
              zi.speak();
              System.out.println(zi.skin);
              System.out.println(zi.addr);
       }
}

class Fu{
       String skin="黄种人";
       String addr="大成都";
       public void speak(){
              System.out.println("Fu...speak()");
       }
}
 
//通过extends和父类发生继承关系
//所有父类的功能，子类都可以继承过来，注意不能是private的
class Zi extends Fu{
       //什么都不写，能不能把父亲的内容复制一份出来
}

1.4 方法的重写

1、 继承后，子类就拥有了父类的功能

2、 那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能

3、 子类中方法签名与父类完全一样(包括方法的返回值，方法名和参数列表，完全一致)时，会发生覆盖/复写操作，相当于修改功能

注意：

1、父类中的私有方法不能被重写

2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限

2. super关键字

1、 通过super关键字可以使用父类的内容

2、 super代表父类的一个引用对象

3、 如果用，必须出现在调用位置的第一行

2.1 成员变量的使用

局部的，成员的，父类的。

public class Test {                         
       public static void main(String[] args) {
              Sub2 s= new Sub2();
              s.show();
       }
}

class Fu2{
       int num=20;
}
 
class Sub2 extends Fu2{
       int num;
       public void show(){
              int num=9;
              System.out.println(num);//变量的就近原则
              System.out.println(this.num);//调用本类的成员变量，相当于Sub2.num
              System.out.println(super.num);//调用父类的成员变量
       }
}

2.2 成员方法的使用

继承方法，特有方法，重写方法

public class Test {

       public static void main(String[] args) {
              Sub3 s=new Sub3();
              s.testShow();//调用普通方法，
              s.eat();//调用重写方法，子类已经重写了父类的方法，从此再用，就是儿子的实现方式
       }
}

class Fu3{
       public void show(){
              System.out.println("Fu...show()");
       }

       public void eat(){
              System.out.println("爸爸吃肉");
       }
}

class Sub3 extends Fu3{
       //普通方法
       public void testShow(){
              super.show();//调用父类的eat()
       }

       //重写方法
       //方法签名完全一致的情况就是发生了重写
       public void eat(){
              System.out.println("儿子吃肉");
       }
}

2.3 构造方法的使用

1、 子类创建对象时，默认会去访问父类的无参构造方法

2、 在构造方法的第一行，都有一条默认的语句：super();

3、 父类没有无参构造时，可以用super调用父类的其他构造

public class Test {
       public static void main(String[] args) {
             Sub4 s = new Sub4();//创建子类对象，在调用子类无参构造前，会先去调用父类的无参构造
       }
}

class Fu4{
       public Fu4(){
              System.out.println("Fu4.Fu4()");
       }

       public Fu4(String name){
              System.out.println("Fu.."+name);
       }
}

class Sub4 extends Fu4{
       public Sub4(){
//           super();//默认就存在的，而且在第一行
              super("zhangsan");//调用父类中含参的构造方法
              System.out.println("Sub4.Sub4()");
       }

       public Sub4(String name){
              this();//调用本类的无参构造
              System.out.println("Sub.."+name);
       }
}

3. this和super的区别

1、 this代表本类对象的引用，super代表父类对象的引用。

2、 this用于区分局部变量和成员变量

3、 super用于区分本类变量和父类变量

4、 this.成员变量 this.成员方法() this(【参数】)代表调用本类内容

5、 super.成员变量 super.成员方法() super(【参数】)，代表调用父类内容

6、 this和super不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行，同时出现的话，到底第一行放谁呢。。

4. 重写与重载的区别（Overload和Override的区别）

1、重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同

2、重写：是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型

3、重写是父类与子类之间多态性的一种表现

4、重载是一类中多态性的一种表现