Java是单继承，只能继承一个父类，但是可以实现多个接口
继承的子类不能直接访问父类中的私有属性，只能通过get和set方法来访问
在继承的操作中，子类对象在实例化之前必须首先调用父类中的构造方法后再调用子类自己的构造方法。
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
33
34
35
36
37
38
39
40
41
42
43
44
| class person{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class student extends person{
private String school;
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
}
public class extends_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
student person_1 = new student();
person_1.setName("张三");
person_1.setAge(10);
person_1.setSchool("涵三中");
System.out.println("姓名:"+person_1.getName()+"\n"+"年龄:"+person_1.getAge()+"\n"+"学校:"+person_1.getSchool());
}
}
|
方法的覆写
方法的覆写就是指子类定义了与父类中同名的方法，但是在方法覆写时候必须考虑到权限，即被子类覆写的方法不能拥有比父类方法更加严格的访问权限。
访问权限：private default public private<default<public
如果在父类中使用public定义的方法，则子类的访问权限必须是public，否则无法编译
如果将父类的一个方法定义成private访问权限，在子类中将此方法声明位default访问权限，这不算是覆写
调用父类的属性时，直接使用super.XXX
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
| class person{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//方法：print
void print(){ //定义一个默认访问权限的方法
System.out.println("Person---->void print()");
}
}
class student extends person{
private String school;
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
//方法：print
public void print(){ //覆写父类中的方法，扩大了权限
System.out.println("student---->void print()");
}
}
public class extends_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
student person_1 = new student();
person_1.setName("张三");
person_1.setAge(10);
person_1.setSchool("涵三中");
System.out.println("姓名:"+person_1.getName()+"\n"+"年龄:"+person_1.getAge()+"\n"+"学校:"+person_1.getSchool());
new student().print();
}
}
|
继承的应用
定义一个整型数组类，要求包含构造方法，增加数据及输出数据成员方法，并利用数组实现动态内存分配。在此基础上定义出以下两个子类。
<1>排序类：实现排序
<2>反转类：实现数据反向存放
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
| class Array{
private int temp[]; //定义一个整形数组，此数字的大小由传入的len决定
private int foot; //定义数组的当前元素下标
public Array(int len){ //数组的大小由len决定,构造方法
if(len>0){ //判断传入的长度是否大于0
this.temp = new int[len]; //根据传入的大小开辟空间
}else{
this.temp = new int[1]; //否则只开辟长度为1的空间
}
}
public boolean add(int i){
if(this.foot < this.temp.length){ //判断数组是否已经满了
this.temp[foot] = i; //没有存满则继续添加
foot++; //修改下标
return true; //添加成功
}else{
return false; //添加失败，已经存满了
}
}
public int[] getArray(){ //得到全部的数组
return this.temp;
}
}
class array_Sort extends Array{
public array_Sort(int len) {
super(len);
// TODO 自动生成的构造函数存根
}
public int[] getArray(){ //覆写父类中的方法
java.util.Arrays.sort(super.getArray()); //排序操作
return super.getArray(); //使用父类中的方法输出数组
}
public void print_array_Sort(){ //输出排序之后的数组
for(int i=0;i<this.getArray().length;i++){ //调用getArray()方法
System.out.println(this.getArray()[i]);
}
}
}
class array_Reverse extends Array{
public array_Reverse(int len) {
super(len);
// TODO 自动生成的构造函数存根
}
public int[] getArray(){ //覆写父类中的方法
int temp_Reverse[] = new int[super.getArray().length];
for(int i=0;i<temp_Reverse.length;i++){
temp_Reverse[i] = super.getArray()[temp_Reverse.length-1-i];
}
return temp_Reverse; //使用父类中的方法输出数组
}
public void print_array_Reverse(){ //输出之后的数组
for(int i=0;i<this.getArray().length;i++){ //调用getArray()方法
System.out.println(this.getArray()[i]);
}
}
}
public class array_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
array_Sort array_1 = new array_Sort(5);
array_1.add(10);
array_1.add(9);
array_1.add(8);
array_1.add(7);
array_1.add(6);
array_1.print_array_Sort();
array_Reverse array_2 = new array_Reverse(5);
array_2.add(10);
array_2.add(9);
array_2.add(8);
array_2.add(7);
array_2.add(6);
array_2.print_array_Reverse();
}
}
|
