如何避免JAVA单继承的限制

转载

编程梦想编织者 2024-09-09 20:18:32

文章标签 如何避免JAVA单继承的限制 java python 开发语言父类 文章分类 Java 后端开发

继承

Java是单继承的，意味着一个类只能从另一个类继承（被继承的类叫做父类【基类，base class】，继承的类叫做子类），Java 中的继承使extends 关键字。单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口，从而克服单继承的缺点。

如果子类使用 super()显式调用父类的某个构造方法，那么在执行的时候就会寻找与 super()所对应的构造方法而不会再去寻找父类的不带参数的构造方法。与this 一样，super 也必须要作为构造方法的第一条执行语句，前面不能有其他可执行语句。

当生成子类对象时，Java 默认首先调用父类的不带参数的构造方法，然后执行该构造方法，生成父类的对象。接下来，再去调用子类的构造方法，生成子类的对象。要想生成子类的对象，首先需要生成父类的对象，没有父类对象就没有子类对象。比如说：没有父亲，就没有孩子。

如何避免JAVA单继承的限制_如何避免JAVA单继承的限制

代码例子：

父类中定义车的引擎数和颜色，方便子类继承:

package com.dannor.study;

public class CarFather {
	public String engineNum;
	public String carColor;

	// 车都有自己的引擎数和颜色
	public CarFather() {
		// 这里的不带参数的沟槽方法必须写
		this.engineNum = engineNum;
		this.carColor = carColor;
		System.out.println("father");
	}

	public String getEngineNum() {
		return engineNum;
	}

	public void setEngineNum(String engineNum) {
		this.engineNum = engineNum;
	}

	public String getCarColor() {
		return carColor;
	}

	public void setCarColor(String carColor) {
		this.carColor = carColor;
	}

	public void run() {
		System.out.println("车跑的方法");
	}
}

子类继承父类，增加自己名字的属性

package com.dannor.study;

public class CarSon extends CarFather {
	private String name;

	public CarSon(String name) {
		this.name = name;//定义自己特有的名字
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public static void main(String[] args) {
		CarSon cs = new CarSon("小轿车");
		System.out.println(cs.name);
		cs.run();
	}
}

输出：

father
小轿车
车跑的方法

多态

多态（Polymorphism）：我们说子类就是父类（玫瑰是花，男人是人），因此多态的意思就是：父类型的引用可以指向子类的对象。所以多态意味着父类型的引用可以指向子类型的对象。

Parent p = new Child();当使用多态方式调用方法时，首先检查父类中是否有sing()方法，如果没有则编译错误；如果有，再去调用子类的sing()方法。

一共有两种类型的强制类型转换：
a) 向上类型转换（upcast ）：比如说将Cat 类型转换为Animal 类型，即将子类型
转换为父类型。对于向上类型转换，不需要显式指定。
b) 向下类型转换（downcast ）：比如将Animal 类型转换为Cat 类型。即将父类型
转换为子类型。对于向下类型转换，必须要显式指定（必须要使用强制类型
转换）。

多态的优势：

比如你要做个篮子放水果，你当然不希望造这样的篮子--苹果篮子，橘子篮子，梨篮子，正常人都会想，麻烦啊，我就造个篮子，什么都能放，干嘛造那么多啊？

回归程序：你造个篮子 basket（）；参数是水果 fruit，这样你调用的时候就可以这样 basket（fruit f）；然后往里放苹果啊，梨啊，什么都行，只要是水果类的子类

多态：所谓多态，就是父类型的引用可以指向子类型的对象，或者接口类型的引用可以指向实现该接口的类的实例。关于接口与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方式完全一样。

抽象

使用了abstract 关键字所修饰的类叫做抽象类。抽象类无法实例化，也就是说，不能new 出来一个抽象类的对象（实例）。

抽象方法（abstract method ）：使用abstract 关键字所修饰的方法叫做抽象方法。抽象方法需要定义在抽象类中。
如果一个类包含了抽象方法，那么这个类一定是抽象类。
如果某个类是抽象类，那么该类可以包含具体方法（有声明、有实现）。
如果一个类中包含了抽象方法，那么这个类一定要声明成 abstract class，也就是说，该类一定是抽象类；反之，如果某个类是抽象类，那么该类既可以包含抽象方法，也可以包含具体方法。
无论何种情况，只要一个类是抽象类，那么这个类就无法实例化。
在子类继承父类（父类是个抽象类）的情况下，那么该子类必须要实现父类中所定义的所有抽象方法；否则，该子类需要声明成一个abstract class 。

abstract 类

public abstract class Car {
	public abstract void run();
	public void run2() {
	System.out.println("run2");
	}
}

继承abstract

public class CarA extends Car{
	public static void main(String[] args) {
		new CarA().run2();
		new CarA().run();
	}

	@Override
	public void run() {
		System.out.println("run");
	}
}

接口

接口（interface ）：接口的地位等同于 class ，接口中的所有方法都是抽象方法。在声明接口中的方法时，可以使用abstract 关键字，也可以不使用。通常情况下，都会省略掉abstract 关键字。
可以将接口看作是特殊的抽象类（抽象类中可以有具体方法，也可以有抽象方法，而接口中只能有抽象方法，不能有具体方法）。
类可以实现接口。实现使用关键字 implements 表示，代表了某个类实现了某个接口。
一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法。如果该类是个抽象类，那么就无需实现接口中的方法了。
Java 是单继承的，也就是说某个类只能有唯一一个父类；一个类可以实现多个接口，多个接口之间使用逗号分隔。

定义接口类Door

public interface Door {
	void open();
	void close();
}

实现接口

public class AlarmDoor implements Door {


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


	public void close() {
		// TODO Auto-generated method stub
		System.out.println("close");
	}
	public static void main(String[] args) {
		new AlarmDoor().close();
		new AlarmDoor().open();
	}
}