赞
踩
欢迎大家来这次博客-----抽象类和接口。
在Java中我们都是通过类来描述对象,但反过来并不是所有的类都是用来描述对象的。当一个类中没有足够的信息来描述一个具体对象,我们就将该类称为抽象类。
如上图中的Shape类,我们想通过Shape类中的draw()方法来实现画各种图形,但由于Shape类不是具体的图形,所以Shape类中的draw()方法也无法实现画各种图形,所以我们将Shape类设置成抽象类。
代码演示
- abstract class Shape{
- public abstract void draw();
- }
- class Triangle extends Shape{
- @Override
- public void draw() {
- System.out.println("画一个三角形");
- }
- }
- class Cycle extends Shape{
- @Override
- public void draw() {
- System.out.println("画一个圆");
- }
- }
- class Rect extends Shape{
- @Override
- public void draw() {
- System.out.println("画一个矩形");
- }
- }
- public class Test {
- public static void main(String[] args) {
- Shape[] shapes={new Triangle(), new Cycle(), new Rect()};
- for(Shape shape:shapes){
- shape.draw();
- }
- }
- }
代码演示
- abstract class Animal{
- public abstract void Bark();
- }
- class Dog extends Animal{
- @Override
- public void Bark() {
- System.out.println("小狗在汪汪叫");
- }
- }
- class Cat extends Animal{
- @Override
- public void Bark() {
- System.out.println("小猫在喵喵叫");
- }
- }
- public class Test {
- public static void func(Animal animal){
- animal.Bark();
- }
- public static void main(String[] args) {
- Dog dog=new Dog();
- func(dog);
- Cat cat=new Cat();
- func(cat);
- }
- }
注意,如以上代码有些地方看不懂,后面回一 一介绍。
在Java中,当一个类被关键字abstract修饰,该类就被称为抽象类,抽象类中如果有方法被abstract修饰,则该方法就被称为抽象方法,抽象方法不需要具体实现。
- //抽象类
- abstract class Animal{
- //抽象方法
- public abstract void Bark();
- }
注意事项:
抽象类中也可以包含普通的方法,甚至也可以包含构造方法。
1. 抽象类不能实例化对象
2. 抽象方法不能被private修饰。
3. 抽象方法不能被final和static修饰,因为子类要重写抽象方法。
4. 抽象类必须被继承,继承抽象类的子类必须重写抽象类中的抽象方法。否则子类也是抽象类,必须用abstract修饰。
5. 抽象类中不一定有抽象方法,但有抽象方法的类一定是抽象类。
6. 抽象类中可以有构造方法,供子类创建对象时,初始化父类的成员变量。
抽象类本身是不能实例化的,要想使用抽象类,必须需要继承的子类重写抽象类中的抽象方法。
有人这时候就很疑惑,普通类不是也能被继承吗?
确实如此,但是使用抽象类多了一层编译器的校验。
如上面的代码,我们完成的操作都是由子类去完成的,但是如果交由父类去完成,普通编译器是不会报错的,但使用了抽象类,父类在实例化的时候就会报错,起到一个提醒的作用。
在生活中,接口比比皆是,如插座,USB插口。
接口通俗来说就是一种固定行为规范,只要你的操作符合规范,就能使用接口。
在Java中,接口可以看作为多个类的行为规范,是一种引用数据类型。
关键字interface 接口名字
举例,如下图,
1.接口是一种引用数据类型,但是不能直接new关键字来创建对象。
2.接口中的每一个方法都是默认由public abstract 修饰的,也就是说接口中的方法不能被其他关键字修饰。(可以不写修饰接口中方法的关键字,编译器默认为public abstract)
3. 接口中的方法不能在接口中实现,只能在使用接口的类中实现。(有特殊情况)
4. 如果接口中的方法被default或者static修饰,可以有具体实现。
5. 重写接口中的方法时,不能使用默认的访问权限。
6. 接口中可以含有变量,但会默认为被 public static final 修饰。
7. 接口中不能含有静态代码块和构造方法
8.如果类中没有重写接口中所有的抽象方法,则该类要用abstract修饰。
9.接口虽然不是类,但接口编译完成后的字节码文件的后缀也是 .java 。
接口不能直接使用,必须要有一个 “实现类” 来重写接口中的抽象方法,通过这个实现类来使用接口。
如果一个类想使用一个接口,要用到implements关键字。
语法格式
- public class 类名称 implements 接口名称{
- // ...
- }
注意:父类与子类之间的关系为extends,类与接口之间的关系为implements。
- interface USB{
- void close();
- void open();
- }
- class Mouse implements USB{
- @Override
- public void close() {
- System.out.println("关闭鼠标");
- }
- public void open(){
- System.out.println("打开鼠标");
- }
- public void click(){
- System.out.println("点击鼠标");
- }
- }
- class KeyBoard implements USB{
- public void close(){
- System.out.println("关闭键盘");
- }
-
- @Override
- public void open() {
- System.out.println("开启键盘");
- }
- public void input(){
- System.out.println("输入功能");
- }
- }
- class Computer implements USB{
- @Override
- public void close() {
- System.out.println("关闭电脑");
- }
- public void open(){
- System.out.println("打开电脑");
- }
- public void use(USB usb){
- usb.open();
- if(usb instanceof Mouse){
- ((Mouse) usb).click();
- }else{
- ((KeyBoard)usb).input();
- }
- usb.close();
- }
-
- }
- public class Test {
- public static void main(String[] args) {
- Computer computer=new Computer();
- computer.open();
- USB usb1=new Mouse();
- computer.use(usb1);
- System.out.println("=======");
- USB usb2=new KeyBoard();
- computer.use(usb2);
- computer.close();
- }
- }
一个类不能同时继承多个类,但是一个类可以同时使用多个接口。
举个例子:用Java来描述鸭子会飞,会游泳和会跑。
我们可以将会飞,会游泳,会跑设置为三个接口。
ISwimming接口
- public interface ISwimming {
- void swim();
- }
IRunning接口
- public interface IRunning {
- void run();
- }
IFly接口
- public interface IFly {
- void fly();
- }
Duck类
- public class Duck extends Animal implements IFly,IRunning,ISwimming{
- public Duck(String name){
- super(name);
- }
-
- @Override
- public void fly() {
- System.out.println(this.name+"会飞");
- }
-
- @Override
- public void run() {
- System.out.println(this.name+"会跑");
- }
-
- @Override
- public void swim() {
- System.out.println(this.name+"会游泳");
- }
- }
测试类
- public class Test {
- public static void main(String[] args) {
- Duck duck=new Duck("小鸭");
- duck.fly();
- duck.run();
- duck.swim();
- }
- }
使用接口的好处就是可以让程序员忘记类的限制,只需要关注该类有没有此接口对应的功能。
- class Robot implements IRunning{
- @Override
- public void run() {
- System.out.println("机器人再跑1");
- }
- }
- public class Test {
- public static void func(IRunning running){
- running.run();
- }
- public static void main(String[] args) {
- Duck duck=new Duck("小鸭");
- func(duck);
- Robot robot=new Robot();
- func(robot);
- }
- }
如以上代码,我们给func函数穿的参数可以是Duck类,也可以是Robot类,只要这两个类具备跑的能力就行了。
在Java中,类与类之间只允许单继承,不允许多继承。但是对于接口来说,接口之间既可以单继承,也可以多继承。
接口之间的继承也是用到extends关键字。
代码演示
- interface Double extends IRunning,ISwimming{
- }
- class Dog implements Double{
- @Override
- public void run() {
- System.out.println("狗会跑");
- }
-
- @Override
- public void swim() {
- System.out.println("狗会游泳");
- }
- }
- public class Test {
- public static void main(String[] args) {
- Dog dog=new Dog();
- dog.run();
- dog.swim();
- }
- }
到此,抽象类和接口的基础内容就介绍完了,感谢观看。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。