Java继承的基本概念及其限制 总结

Posted jachinmeng

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java继承的基本概念及其限制 总结相关的知识,希望对你有一定的参考价值。

一、 继承的基本概念及其限制

继承:就是扩展已有类的功能,在继承中分为子类和父类,父类有时候也称为超类(super class),子类有时候称为派生类。

 继承的基本语法为:class子类 extends 父类 {}

继承的限制:1)在java中不允许多重继承,一个子类只能继承一个父类,不能继承多个父类;2)java中允许多层继承;3)在继承中子类不能访问父类中的私有成员,只能继承公共操作。但是私有成员可以通过公共方法得到访问。

二、  this关键字和super关键字的区别

this在java中变现出以下的概念:

1)  调用类中的属性:this.属性

2)  调用类中的方法:this.方法()

3)  调用类中的构造方法:this()

4)  表示当前对象:this

所有的构造方法应该是在对象操作之前最早调用的,所以用this调用类中其他构造方法的时候,该代码必须放在构造方法中的首行。需要注意:在使用this调用构造方法的时候必须至少有一个构造方法没有使用this()调用的,而此方法将作为程序的出口,一般情况下这个出口定义为无参构造方法。

 

No

比较点

this

super

1

属性

this.属性表示的是本类中的属性,如果在子类中查找不到则到父类中继续查找

Super.属性表示直接查找的父类的属性

2

方法

This.方法()是调用本类中的方法,如果在子类中找不到则到父类中查找

Super.方法()表示直接查找父类的方法

3

构造方法

可以调用本类中的其他构造方法,但是必须有一个构造方法不使用this()调用

从子类调用父类的构造方法,子类不管怎么编码,必须调用父类的构造方法

调用构造时,必须放在构造方法首行

必须放在子类构造方法首行

4

特殊点

表示当前对象

无此概念

No

比较点

重载

覆写

1

英文单词

overload

Override

2

概念

方法名称相同,参数不同(参数或个数)

方法名称、参数、返回值都完全相同

3

注意点

-

访问权限不能变小

4

范围

在同一个类中发生

在继承类中发生

No

比较点

抽象类

接口

1

组成

抽象方法、普通方法、常量、变量、构造方法、全局常量

抽象方法、全局常量

2

定义

Abstract

Interface

3

子类

子类通过extends关键字来继承抽象方法

子类通过implements来实现接口

4

限制

一个子类只能继承一个抽象类

一个子类可以实现多个接口

5

关系

一个抽象类可以实现多个接口

一个接口不能继承一个抽象类只能实现多个接口

一个抽象类中可以由多个接口

一个接口中也可以由多个抽象类

6

设计模式

模板模式

工厂模式、代理模式

两个结合起来可以实现适配器模式

7

实例化

都是通过对象多态性,通过子类进行对象的实例化操作

8

实现限制

存在单继承限制

不存在此限制

9

特性

-

可以作为标准、一种能力

三、 重载和覆写的区别

四、子类的初始化过程

子类在实例化的时候,首先调用的永远都是父类的构造方法。构造方法的作用是为类的属性进行初始化。在实例化子类之前,先将父类实例化。在实际的代码中,如果子类的构造方法中没有显示的调用父类的构造方法,会默认的添加上super()方法用来调用父类的无参构造方法。如果此时父类中没有无参的构造方法,程序编译将出现错误。这时,要么显示的为子类构造函数中添加super(参数)来调用父类中带参数的构造方法,或者为父类添加无参的构造方法。

五、 一个开发原则

在程序开发中要记住一个原则:一个类不要去继承一个已经实现好的类,要么去继承抽象类,要么去实现接口。

六、 一个重要题目

现在要求定义一个数组类(Array),该类中包含一个整型数组,但是该整型数组的大小事动态分配的。即:所有的大小由程序决定,并且实现下面两个子类:

u  反转类:可以将数组的内容反转排列

u  排序类:可以对数组进行排序的操作

 

class Array{
private int[] temp = null ; // 声明一个整型数组
private int foot ; // 定义增加记录的脚标
public Array(int len){
if(len>0){
this.temp = new int[len] ; // 如果传过来的数据大于0,可以开辟
}else{
this.temp = new int[1] ; // 最少维持1个数组大小
}
}
public boolean add(int t){ // 增加元素
if(this.foot<this.temp.length){ // 还有空间,可以增加
this.temp[this.foot] = t ;
this.foot++ ;
return true ;
}else{
return false ;// 不能增加
}
}
public int[] getArray(){
return this.temp ;
}
};
class SortArray extends Array{ // 排序类
public SortArray(int len){ // 在子类的构造方法中必须明确的调用父类的构造方法
super(len) ;
}
public int[] getArray(){
java.util.Arrays.sort(super.getArray()) ; // 排序
return super.getArray() ; // 返回排序后的结果
}
};
public class ExecDemo01{
public static void main(String args[]){
SortArray arr = new SortArray(5) ; // 开辟5个大小的整型数组
System.out.println(arr.add(11)) ;
System.out.println(arr.add(2)) ;
System.out.println(arr.add(33)) ;
System.out.println(arr.add(4)) ;
System.out.println(arr.add(0)) ;
System.out.println(arr.add(6)) ;
print(arr.getArray()) ;
}
public static void print(int temp[]){ // 打印数组
for(int x:temp){
System.out.print(x + "、") ;
}
}
};

class ReverseArray extends Array{ // 排序类
public ReverseArray(int len){ // 在子类的构造方法中必须明确的调用父类的构造方法
super(len) ;
}
public int[] getArray(){
int x[] = new int[super.getArray().length] ; // 以父类中的数组大小进行开辟
int count = x.length - 1 ;
for(int i=0;i<super.getArray().length;i++){
x[count] = super.getArray()[i] ;
count-- ;
}
return x ;
}
};
public class ExecDemo01{
public static void main(String args[]){
ReverseArray arr = new ReverseArray(5) ; // 开辟5个大小的整型数组
System.out.println(arr.add(11)) ;
System.out.println(arr.add(2)) ;
System.out.println(arr.add(33)) ;
System.out.println(arr.add(4)) ;
System.out.println(arr.add(0)) ;
System.out.println(arr.add(6)) ;
print(arr.getArray()) ;
}
public static void print(int temp[]){ // 打印数组
for(int x:temp){
System.out.print(x + "、") ;
}
}
};

在本道程序中融合了以下的知识点:

                   1、   继承的基本概念:扩充了类的功能

                   2、   方法的覆写的作用

                   3、   引用传递

                   4、   数组的排序、foreach输出


七、  final关键字(重点)

final关键字可以用来做以下声明:

1)  声明类:由final声明的类不能有子类;

2)  声明方法:由final声明的方法不能被子类覆写;

3)  声明变量:由final声明的变量就成为常量,常量的内容不能改变

在java中用final声明的变量为常量,这个常量的标示符一般全部用大写字母表示。

在java中也存在一个很重要的概念:全局变量,用public static final来声明。

八、 抽象类和接口的基本概念和应用

1、抽象类:包含一个抽象方法的类为抽象方法,抽象方法是只声明而没有实现的方法,所有的抽象方法必须用abstract关键字声明,所有的抽象类也必须用abstract关键字声明。

对抽象类来讲,抽象类是不能直接实例化的,但是可以声明,如果要想使用抽象类,则必须依靠其子类,抽象类是必须要被子类继承的,继承抽象类的子类要实现抽象类中的所有抽象方法。

  抽象类是不能用final关键字来声明的,因为抽象类必须被子类继承,而final声明的类不能有子类;

  抽象类是可以有构造方法的,但是这个构造方法不能直接调用,是交给子类去调用的,实际上子类的实例化过程,永远是先调用父类的构造方法。而且,抽象类中的属性如果想初始化,则必须依赖其构造方法。

2.接口:接口是一个特殊的类,在java中接口是由抽象方法和全局变量组成的,用interface定义一个接口,子类通过implements来实现一个接口。

一个类虽然只能继承一个父类,但是可以同时实现多个接口。

3、对象多态性

   多态性是整个java中最重要的一个概念,因为有多态性的存在,程序的灵活性才能实现。多态性是面向对象的最后一个特征:

1)  方法重载和方法覆写其实就是多态性的一种体现;

2)  真正的多态性包括一种叫做对象多态性的概念:

|- 对象的多态性主要是指,子类和父类的对象之间的相互转化;

   |-向上转型:父类父类对象 =子类实例   à自动完成

   |-向下转型:子类子类对象 =(子类)父类对象 à强制完成

        Java提供了instanceof方法来判断一个对象是否属于一个类

          对象 instanceof类 à返回boolean类型的结果值,true或者false.

  为了保证对象的向下转型的操作能够成功,最好在转型之前使用instanceof来判断一下是否属于该类;

  在继承关系中,父类的设计是很重要的,如果父类设计的比较好,代码编辑起来会很方便。

抽象类最大的用处就是模板设计。

九、             抽象类和接口的区别(绝对重点)

10、 object类

      。toString():在对象打印时调用;

      。equals():完成对象的比较工作。

 
















































































以上是关于Java继承的基本概念及其限制 总结的主要内容,如果未能解决你的问题,请参考以下文章

:Java之接口基本概念和接口实现多继承

PDCA的基本概念及其应用

继承的基本概念

Java 泛型的作用及其基本概念

Java笔记

Servlet基本概念及其部署