Java面向对象编程之类的继承详解

时间:2022-02-02 15:25:46

本文实例讲述了Java面向对象编程之类的继承。分享给大家供大家参考,具体如下:

继承:特殊类拥有一般类的全部属性与行为。

继承好处:

1.提高了代码的复用性

2.让类与类之前产生了关系,有了这个关系才有多态的特性。继承是类和类之前的关系。

注意事项:

1.java只支持单继承,不支持多继承。因为多继承有安全隐患:当多个父类定义相同的函数,但是功能不同时,子类不知道运行哪一个。

2.子类继承父类时,继承了父类的所有方法和属性,可直接使用。

3,java支持多层继承,即:孙-子-父的关系

语法:

?
1
2
3
[类修饰符] class 子类名 extends 父类名{
  语句;
}

例如:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Pserson
{
  int age;
  String name;
  public void speak()
  {
    System.out.println("Hello World!");
  }
}
//继承Person类,继承了父类所有方法和属性
class Student extends Pserson
{
  public void study()
  {
    System.out.println("Good Study!");
  }
}
//继承Person类,继承了父类所有方法和属性
class Worker extends Pserson
{
  public void work()
  {
    System.out.println("Good work!");
  }
}

如何使用一个继承体系中的功能(查阅api文档):

查阅父类的功能,创建子类对象使用功能

在继承过程中经常遇到这三种场景:

1)同名变量

1.如果子类出现非私有的同名成员变量时,子类访问本类的变量,用this;子类访问父类中的同名变量,用super。
2.this代表本类对象的引用
3.super代表父类对象的引用(用法和this相同)

2)同名函数

1.如果子类出现和父类一模一样的函数时(函数名和参数都相同),当子类对象调用该函数,会运行子类函数内容。,父类的函数会被覆盖(也叫重写)。

2.重写定义:当子类继承父类,沿袭了父类的功能,到子类中。但子类虽具备该功能,但功能的内容和父类不一致,这时,没有必须要定义新功能,而是使用覆盖特性,保留父类的功能定义,并重写功能内容。

3.重写(覆盖)注意事项:

<1>子类覆盖父类,必须保证子类的权限大于等于父类的权限,才能继承,否则编译失败。(public>不写修辞关键词>private)
<2>静态只能覆盖静态
<3>重载:只看同名函数的参数列表 重写:子父类方法要一模一样(函数名和参数列表)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Fu
{
  //public void show()  当父类为show()时,会和子类函数一模一样,父类的show函数会被重写
  public void show(String name) //父类的show函数和子类不一样(参数列表不一样),因此父类的show函数不会被重写
  {
    System.out.println(name);
  }
}
class Zi extends Fu
{
  public void show()
  {
    System.out.println("zi");
  }
}
class Jicheng
{
  public static void main(String[] args)
  {
    Zi z1=new Zi();
    z1.show("nihao");//会调用父类的show函数
  }
}

3)构造函数

1.在对子类对象进行初始化时,父类的构造函数也会运行,因为子类的构造函数的第一行默认有一条隐式语句super()

2.super()会访问父类中空参数的构造函数,而且子类中所有的构造函数第一行默认都是super()

3.子类一定要访问父类构造函数原因

<1>因为父类中的数据子类可以直接获取,所以子类在创建是,先看看父类如何对这些数据进行初始化的,所以子类在对象初始化时,默认先访问父类的构造函数。
<2>若要访问父类制定的构造函数或者父类没有空参数的构造函数时,可以通过手动定义super语句的方式来制定。
<3>当然子类的构造函数第一行也可以手动指定this语句来访问本类的构造函数,但子类中至少有一个构造函数会访问父类的构造函数

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Fu
{
  String name;
  int age;
  Fu(){System.out.println("Hello Fu");}
  Fu(String name)
  {
    System.out.println(name);
  }
  Fu(String name,int age)
  {
    this.name=name;
    this.age=age;
    System.out.println("name: "+name+",age: "+age);
  }
}
class Zi extends Fu
{
  //Zi(){System.out.println("Hello Zi");}  默认先会调用父类的无参构造函数
  Zi()
  {
    super("zhangsan",20);//手动用super语句指定父类的构造函数,来获取父类非私有的信息
    System.out.println(name+"::"+age);
  }
}
class Test
{
  public static void main(String[] args)
  {
    Zi z1=new Zi();
  }
}

构造函数异常例子:

写出程序结果

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Super
{
  int i=0;
  public Super(String s)
  {
    i=1;
  }
}
class Demo extends Super
{
  public Demo(String s)
  {
    i=2;
  }
  public static void main(String[] args)
  {
    Demo d=new Demo("yes");
    System.out.println(d.i);
  }
}
//编译失败,因为父类中缺少空参数的构造函数。
//或者子类应该通过super语句指定要调用的父类中的构造函数。

重写和重载例子:

?
1
2
3
4
class Demo
{
   int show(int a,int b){return 0;}
}

下面那些函数可以存在于Demo的子类中。

A.public int show(int a,int b){return 0;}//可以,覆盖。
B.private int show(int a,int b){return 0;}//不可以,权限不够。
C.private int show(int a,long b){return 0;}//可以,和父类不是一个函数。没有覆盖,相当于重载。
D.public short show(int a,int b){return 0;}//不可以,因为该函数不可以和给定函数出现在同一类中,或者子父类中。
E.static int show(int a,int b){return 0;}//不可以,静态只能覆盖静态。<br><br>因此子类允许重写和重载。

希望本文所述对大家java程序设计有所帮助。

原文链接:http://www.cnblogs.com/paulwinflo/p/7992942.html