java继承能多继承吗 java可以继承多个抽象类吗

转载

mob64ca13fd9f8e 2023-11-27 00:14:20

文章标签 java继承能多继承吗子类父类构造函数 文章分类 Java 后端开发

一继承概述：

1、Java语言中，Java只支持单继承，不支持多继承。即使一个类只能有一个子类(extends) 一个父类(super)，不允许多个，容易有安全隐患。

(1)、比如，同时继承两个类，但是两个类中有连个同名函数。

(2)、但是Java保留了这种机制，并用另一种体现形式来完成表示，叫做多实现。

(3)、Java支持多层继承，也就是一个继承体系，B继承A，C继承B，这样C就既有了A的功能，又有了B的功能，这就是多继承。

2继承的出现（Extends）：

1，提高了代码的复用性。

2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。

注意：

千万不要为了获取其他类的功能，简化代码而继承。

必须是类与类之间有所属关系才可以继承，所属关系，父类、子类(is a)。

二子父类中变量的特点：

如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this。

子类要访问父类中的同名变量，用super。

super的使用和this的使用几乎一致，this代表的本类对象的引用，super代表的是父类对象的引用。

class Fu

{

int num=4;

}

class Zi extends Fu

{

public void show()

{

System.out.println(num);

}

class Object1

{

public static void main(String[] args)

{

Zi z=new Zi();

z.show();

}

三子父类中函数的特点：

1当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样，这种情况是函数的另一个特性：重写（覆盖）。

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

3覆盖：子类覆盖父类，必须保证子类权限大于等于父类，才可以覆盖，否则编译失败。静态只能覆盖静态。

4记住：重载只看同名函数的参数列表；重写子父类方法要一模一样。

class Tel 
 { 
 void show() 
 { 
 System.out.println("numble"); 
 } 
 } 
 class NewTel extends Tel 
 { 
 void show() 
 { 
 super.show() 
 System.out.println("name"); 
 System.out.println("pic"); 
 } 
 }

四子父类中构造函数的特点:

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

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

2）子类一定要访问父类中的构造函数，因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时，要先访问一下父类中的构造函数，如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

class Fu 
 { 
 //Fu类构造函数 
 Fu() 
 { 
 System.out.println("Fu run"); 
 } 
 } 
 class Zi extends Fu 
 { 
 //Zi类构造函数 
 Zi() 
 { 
 System.out.println("zi run"); 
 } 
 } 
 class Object1 
 { 
 public static void main(String[] args) 
 { 
 Zi z=new Zi();

注意：super语句一定要定义在子类构造函数的第一行。

继承弊端：打破了封装性。

子类的实例化过程：

结论：子类的所有的构造函数，默认都会访问父类中空参数的构造函数。

因为子类每一个构造函数内的第一行都有一句隐式super（）；当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

[java] view plain copy 
 class Object1   
 {   
 public static void main(String[] args)   
 {   
 Student s=new Student("zhangsang",20);   
 s.study();   
 }   
 }   
 class Person   
 {   
 String name;   
 int age;   
 Person(String name,int age)   
 {   
 this.name=name;   
 this.age=age;   
 }   
 public void show()   
 {   
 System.out.println(this.name+"..."+this.age);   
 }   
 }   
 class Student extends Person   
 {   
 String name;   
 int age;   
 Student(String name,int age)   
 {   
 super(name,age);   
 }   
 public void study()   
 {   
 super.show();   
 }   
 }

五final——关键字最终值

1、可以修饰类、函数、变量。

2、被 final 修饰的类，不可以被继承，为了并避免被继承，被子类复写功能。

3、被 final修饰的方法。

4、被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。

final int X=3;

5、当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读，

而这个这不需要改变，所以加上final修饰。

6、作为常量，敞亮的书写规范所有字母都大写，如果由多个单词组成，单词间通过 _ 连接。

8、一般是public static final 。。。这么使用。

六抽象类的概述：

抽象：笼统，模糊，看不懂！不具体。

当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。

这时，只抽取功能定义，而不抽取功能主体。

抽象类的特点(abstract)：

1，方法只用声明没有实现时，该方法就是抽象方法，需要被abstract修饰。

抽象方法必须定义在抽象类中。该类也必须被abstract修饰。

2，抽象类不可以被实例化(也就是创建对象的意思)，为什么？因为调用抽象方法没意义。

3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。

否则，这个子类还是抽象类。

4，抽象类和一般类的异同点。

相同点：抽象类和一般类都是用来描述事物的，都在内部定义了成员。

不同点：

1，一般类有足够的信息描述事物。

抽象类描述事物的信息有可能不足。

2，一般类中不能定义抽象方法，只能定义非抽象方法。

抽象类中可定义抽象方法，同时也可以定义非抽象方法。

3，一般类可以被实例化。

抽象类不可以被实例化。

5，抽象类一定是父类吗？

是的。因为需要子类覆盖其方法后才可以对子类实例化。

抽象类练习：

七模版方法设计模式

1、需求：获取一段程序运行的时间

2、原理：获取程序开始和结束的时间并相减

3、获取时间：System.currnetTimeMillis();

4、这种方式，叫模板方法设计模式

5、模板方法设计模式：在定义功能是，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的那部分暴露出去，有该类的子类去完成。

[java] view plain copy 
 class Object1   
 {   
 public static void main(String[] args)   
 {   
 GetTime g=new GetTime();   
 g.getTime();   
 }   
 }   
 abstract class GetTime   
 {   
 public final void getTime()   
 {   
 long time1=System.currentTimeMillis();   
 run();   
 long time2=System.currentTimeMillis();   
 long time3=time1=time2;   
 System.out.println(time3);   
 }   
 public abstract run();   
 }   
 class SubTime extends GetTime   
 {   
 public void run()   
 {   
 for(int x=0;x<</span>4000;x++)   
 {   
 System.out.println("nihao"+x);   
 }   
 }   
 }

八接口

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口 interface。

格式： interface接口名{}

定义接口使用的关键字不是class，是interface。

对于接口当中常见的成员：而且这些成员都有固定的修饰符。

1，全局常量。public static final

2，抽象方法。public abstract

由此得出结义，接口中的成员都是公共的权限，都是public。

类与类之间是继承关系，类与接口之间是实现关系。

实现： implements

[java] view plain copy 
 Interface Inter   
 {   
 public static final int X=3;   
 public abstract void show();   
 }   
 class Test implements Inter   
 {   
 public void show()   
 {   
 System.out.println("nihao");   
 }   
 }   
 class Object1   
 {   
 public static void main(String[] args)   
 {   
 Inter i=new Inter();   
 System.out.println(i.X);   
 System.out.println(Inter.X);   
 System.out.println(Test.X);   
 }   
 }

注意：接口不可以实例化。只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。

否则这个子类也是抽象类。

在Java中不直接支持多继承，因为会出现调用的不确定性。所以Java将多继承机制进行改良，在Java中变成了多实现。

一个类可以实现多个接口。接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。接口的出现避免了单继承的局限性。类与类是继承关系，类与接口是实现关系，接口与接口之间是继承关系，而且接口可以多继承。

注意:接口的出现再次打破了单继承的局限。

九接口的特点：

1，接口是对外暴露的规则。

2，接口是程序的功能扩展。

3，接口的出现降低耦合性。

4，接口可以用来多实现。

5，类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

6，接口与接口之间可以有继承关系。