Java继承
方法重写是Java语言多态的特性，必须满足以下条件
- 在子类中，方法名称与父类方法名称完全相同
- 方法的参数个数和类型完全相同，返回类型完全相同
- 方法的访问修饰符访问级别不低于父类同名方法的访问级别
- 在方法上添加@override注释，如果报错说明不是重写
方法重写限制
- final修饰的父类方法在子类中不能被重写
- static修饰的父类方法在子类中不能被重写，只能覆盖
super关键字
super关键字和this类似，super修饰的是父类的对象，如super();调用的是父类的默认无参构造器
Java抽象类
抽象类特点
- 抽象类通常应包含抽象方法，也可以包含非抽象方法
- 抽象类不能使用final关键字修饰
- 抽象类自身不能够实例化
- 抽象类就是用来被继承的
抽象类的继承
- 子类必须实现父类所有的抽象方法
- 如果子类已经override实现父类的抽象方法，间接子类可以不用实现该方法。
适配器
- 定义一个适配器，类名+Adapator。比如MamalAdapator。继承给父类所有的方法一个空的实现。后面实例的类继承这个适配器，就可以选择性的重写实现部分父类的方法而不会报错。
- 抽象类只提供一个抽象方法然后供子类去继承和重写override，然后特别是override的这个功能，可以做到比如Dog.eat，Cat.eat，不同的类，有不同的方法实现，但是方法名称都相同，给开发提供了极大的灵活性，后面的程序员接手开发的时候，比如需要再新增Tiger.eat,只需要再写一个Tiger类继承父类再override他的eat方法就可以了。
public class Test {
public static void main(String[] args) {
//用父类的类型去new一个子类
Counter cou = new Add();
//用父类的类型去调用子类的addition方法并实现
System.out.println("3+9的和是"+cou.addition(3,9));
}
}
//定义一个抽象的父类Counter
public abstract class Counter {
//定义一个抽象方法addition
public abstract int addition(int num1, int num2);
public Counter(){
System.out.println("调用Counter父类构造器");
}
}
public class Add extends Counter{
int num1 = 0;
int num2 = 0;
//重写父类中的加法并实现加法
@Override
public int addition(int num1, int num2) {
this.num1 = num1;
this.num2 = num2;
return num1+num2;
}
public Add(){
System.out.println("调用Add子类构造器");
}
}-----------------------------------------------分割线--------------------------------------------------------------
package tool.test;
import tool.abstracts.Construct;
import tool.abstracts.Tool;
import tool.abstracts.Traffic;
import tool.imp.Car;
import tool.imp.Hammer;
public class Test {
public static void main(String[] args) {
//实例化顶级工具类对象,调用其中功能方法
Tool tool1 = new Traffic() {
@Override
public void constructTool() {
}
};
tool1.trafficTool();
Tool tool2 = new Construct() {
@Override
public void trafficTool() {
}
};
tool2.constructTool();
//实例化特殊工具类对象,调用其中功能方法
Traffic traffic = new Car();
traffic.trafficTool();
Construct construct = new Hammer();
construct.constructTool();
}
}
package tool.abstracts;
//定义一个tool抽象类
public abstract class Tool {
//定义一个交通工具抽象方法
public abstract void trafficTool();
//定义一个建筑工具抽象方法
public abstract void constructTool();
}
package tool.abstracts;
//定义一个交通工具抽象类继承自工具类
public abstract class Traffic extends Tool {
public void trafficTool(){
System.out.println("我是所有交通工具的集合");
};
}
package tool.abstracts;
//定义一个建筑工具抽象类继承自工具类
public abstract class Construct extends Tool {
public void constructTool(){
System.out.println("我是所有建筑工具的集合");
};
}
package tool.adaptor;
import tool.abstracts.Construct;
//定义一个Construct的适配器
public class ConstructAdaptor extends Construct {
//对交通工具方法进行一个重写和空实现
@Override
public void trafficTool() {
}
//对建筑工具方法进行一个重写和空实现
@Override
public void constructTool() {
}
}
package tool.adaptor;
import tool.abstracts.Traffic;
//定义一个Traffic的适配器
public class TrafficAdaptor extends Traffic {
//对交通工具方法进行一个重写和空实现
@Override
public void trafficTool() {
System.out.println("我是所有交通工具的集合");
}
//对建筑工具方法进行一个重写和空实现
@Override
public void constructTool() {
}
}
package tool.imp;
import tool.adaptor.TrafficAdaptor;
//定义一个普通类并具体实现交通工具方法
public class Car extends TrafficAdaptor {
@Override
public void trafficTool() {
System.out.println("我是交通工具汽车");
}
}
package tool.imp;
import tool.adaptor.ConstructAdaptor;
//定义一个普通类并具体实现建筑工具方法
public class Hammer extends ConstructAdaptor {
@Override
public void constructTool(){
System.out.println("我是建筑工具锤子");
}
}-----------------------------------分割线-----------------------------------
package test;
import abstracts.Tool;
import imp.*;
//定义一个主类Test
public class Test {
public static void main(String[] args) {
//实例化Person类
Person per = new Person();
//通过多态的方式，以父类的类型实例化各个子类
Tool car = new Car();
Tool plane = new Plane();
Tool print = new Printer();
Tool laptop = new Laptop();
//调用对应的子类去具体实现抽象方法
per.useTool(car);
per.useTool(plane);
per.useTool(print);
per.useTool(laptop);
}
}
package abstracts;
//定义一个抽象的工具类作为父类
public abstract class Tool {
//定义一个旅行的抽象方法
public abstract void travel();
//定义一个打印的抽象方法
public abstract void print();
//定义一个学习的抽象方法
public abstract void study();
}
package adaptor;
import abstracts.Tool;
//定义一个适配器，继承工具类并提供3个方法的空实现
public class ToolAdaptor extends Tool {
@Override
public void travel() {
}
@Override
public void print() {
}
@Override
public void study() {
}
}
package imp;
import adaptor.ToolAdaptor;
//定义一个汽车类继承父类的适配器，重写并具体实现旅行的这个抽象方法
public class Car extends ToolAdaptor {
@Override
public void travel() {
System.out.println("使用汽车旅行");
}
}
package imp;
import adaptor.ToolAdaptor;
//定义一个飞机类继承父类的适配器，重写并具体实现旅行的这个抽象方法
public class Plane extends ToolAdaptor {
@Override
public void travel(){
System.out.println("使用飞机旅行");
}
}
package imp;
import adaptor.ToolAdaptor;
//定义一个笔记本电脑类继承父类的适配器，重写并具体实现学习的这个抽象方法
public class Laptop extends ToolAdaptor {
@Override
public void study(){
System.out.println("使用笔记本电脑学习Java");
}
}
package imp;
import adaptor.ToolAdaptor;
//定义一个打印机类继承父类的适配器，重写并具体实现打印的这个抽象方法
public class Printer extends ToolAdaptor {
@Override
public void print() {
System.out.println("使用打印机打印文件");
}
}
package imp;
import abstracts.Tool;
//定义一个Person类
public class Person {
//定义一个使用工具的方法，接收tool抽象类的类型，并调用tool抽象类的三个抽象方法
public void useTool(Tool tool){
tool.travel();
tool.print();
tool.study();
}
}以上就是Java抽象类、继承及多态和适配器的实现的详细内容，更多关于java抽象类继承多态的资料请关注编程网其它相关文章！
