继承

 

一、继承的概念

(一) 继承的概念

①继承机制是面向对象程序设计不可缺少的关键概念，是实现软件可重用的根基，是提高软件系统的可扩展性与可维护性的主要途径;

②所谓继承是指一个类的定义可以基于另外一个已经存在的类，即子类基于父类，从而实现父类代码的重用，子类能吸收已有类的数据属性和行为，并能扩展新的能力;

(二)继承的形式

【访问权限修饰符】【修饰符】子类名  extends  父类名{子类体}

public class Shape {

public void draw(){}}

public class Circle extends Shape{

public double getDiameter(){

return 0.0; }}

(三)继承的作用

①继承的作用：代码复用

1.子类对象可以直接调用父类的属性和方法

public class Shape {

public void draw(){}}

public class Circle extends Shape{

public double getDiameter(){

return 0.0; }}

二、构造方法与继承

(一)继承中构造方法的调用

①子类构造方法总是先调用父类构造方法

②默认情况下，调用父类无参构造方法

③可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法

(二)子类调用父类构造方法的原因

Java 语言中，要求子类有责任保证它所继承的父类尽快进入到一个稳定、完整的状态中。如果没有这个约束，那么子类的某个继承自父类的方法可能会使用到父类中的一些变量，而这些变量并没有进行初始化，从而产生一些难以预料的后果。

(三)子类构造方法的执行详解

①必须将调用父类构造方法的这条语句放在子类构造方法的第一条语句位置。如果第一条语句没有调用父类的构造方法，系统将会自动地在这个位置上插入一条调用父类默认构造方法的语句,即super();

②由于默认的构造方法不带参数，所以，如果在父类中定义了带参数的构造方法，而没有定义不带参数的构造方法将会出现编译错误。这也正是建议大家在定义带参数的构造方法时，一定要定义一个不带参数的构造方法的原因所在;

③父类中那些带参数的构造方法，子类将不会自动地调用它们，必须人工地将调用它们的语句写入子类的构造方法中

三、this关键字

（一）this关键字用途

①this关键字代表自身，在程序中主要的用途；

②使用this关键字在自身构造方法内部引用其它构造方法；

③使用this关键字代表自身类的对象

1.直接使用this；

2.使用this关键字引用成员变量；

3.使用this关键字引用成员方法

注意：this关键字必须放在非静态方法里面

（二）this引用成员变量

①在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

public class ReferenceVariable {

private int a;

public ReferenceVariable(int a){

this.a = a;}

public int getA(){

return a;

public void setA(int a){

this.a = a;}

（三）this引用构造方法

①在一个类的构造方法内部，也可以使用this关键字引用其它的构造方法，这样可以降低代码的重复，也可以使所有的构造方法保持统一，这样方便以后的代码修改和维护，也方便代码的阅读。

public class ReferenceConstructor {

int a;

public ReferenceConstructor(){

this(0);}

public ReferenceConstructor(int a){

this.a = a; }}

（四）this引用成员方法

①在一个类的内部，成员方法之间的互相调用时也可以使用“this.方法名(参数)”来进行引用；

public class ReferenceObject {

ReferenceObject instance;

public void hello(){     System.out.println("helloWorld"); }

public void sayHello(){

     this.hello();}}

（五）this代表自身对象

①在一个类的内部，也可以使用this代表自身类的对象，或者换句话说，每个类内部都有一个隐含的成员变量，该成员变量的类型是该类的类型，该成员变量的名称是this；

public class ReferenceObject {

ReferenceObject instance;

public ReferenceObject(){

instance = this; }

public void test(){

System.out.println(this); }}

四、super关键字

(一)super关键字用途

①在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法体的第一行;

②当子类方法体中的局部变量或者子类的成员变量与父类成员变量同名时，即子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量;

③当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（方法体可以不同），此时，用“super.方法名（参数列表）”的方式访问父类的方法；

④与this的区别，this通常指代当前对象，super通常指代父类

(二)子类构造方法中要调用父类构造方法

①在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法体的第一行；

class Base {

Base() {

System.out.println("Base"); }}

public class Checket extends Base {

Checket() {

super();//调用父类的构造方法，一定要放在方法的首个语句

System.out.println("Checket"); }

public static void main(String argv[]) {

Checket c = new Checket(); }}

(三)super调用父类成员变量或方法

①子类中的成员变量或方法与父类中的成员变量或方法同名。因为子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或方法就隐藏了父类的成员变量或方法，但是我们如果想要使用父类中的这个成员变量或方法，就需要用到super;

class Country {

String name;

 

void value() {

name = "China"; }}

class City extends Country {

String name;

void value() {

name = "Dalian";

super.value();//不调用此方法时，super.name返回的是父类的成员变量的值null

System.out.println(name);

System.out.println(super.name);}

public static void main(String[] args) {

City c=new City();

c.value(); }}

（四）this和super

①this通常指代当前对象，super通常指代父类对象；

class Person {

public static void prt(String s) {

    System.out.println(s);}

Person() {

prt("A Person.");

}

Person(String name) {

    prt("A person name is:" + name)；}}  

public class Chinese extends Person {

    Chinese() {

super(); // 调用父类无形参构造方法（1）

prt("A chinese.");// (4)  }

    Chinese(String name) {

super(name);// 调用父类具有相同形参的构造方法（2）

prt("his name is:" + name);  }

    Chinese(String name, int age) {

this(name);// 调用当前具有相同形参的构造方法（3）

prt("his age is:" + age); }

    public static void main(String[] args) {

Chinese cn = new Chinese();

cn = new Chinese("kevin");

cn = new Chinese("kevin", 22);}}   

五、方法覆盖定义及原则

(一)方法覆盖的定义

①子类可以重写父类中某一个方法，称为方法覆盖，也称方法重写，是继承中非常重要的知识点。如果子类需要修改从父类继承到的方法的方法体，就可以使用方法覆盖;

②方法覆盖的原则;

1.同名

2.同参

3.同返回值

4.访问权限不能缩小

(二)方法覆盖-代码示例

父类

public class Animal{

             String name;

        Integer age;       

                public Animal() {}   

        public Animal(String name, Integer age) {

            this.name = name;

            this.age = age; }       

        void run(){

          System.out.println("一只"+this.age+"岁的"+ this.name + "在奔跑!~~");        }

        void sound(){

           System.out.println("一只"+this.age+"岁的"+ this.name + "在吼叫!~~");}

 

(三)方法覆盖-代码示例

子类

public class Tiger extends Animal{

      String color;

         public Tiger(String name,Integer age,String color){   

        super(name,age);

        this.color = color;

    void hunt(){

        System.out.println("一只"+this.color+"的"+ this.name + "在捕猎!~~"); }

    void sound(){

        System.out.print("我是一只老虎~");

        super.sound();} }

（四）方法覆盖-代码示例

测试类

public class Tester {

    public static void main(String[] args) {    

        Tiger t = new Tiger("东北虎",1,"白色");

        t.sound();   }}

运行结果：我是一只老虎~一只1岁的东北虎在吼叫

一、final修饰符

①final修饰属性、局部变量，值不能被修改；

②final修饰类，不能被继承；

③final修饰方法，不能被子类覆盖;

 

转载于:https://www.cnblogs.com/alone-/p/7647410.html