亲宝软件园·资讯

展开

Java 抽象类与接口

Pretend.. 人气:0

一、抽象类

在Java中,如果一个类被abstract修饰称为抽象类,抽象类中被abstract修饰的方法称为抽象方法,抽象方法不用给出方法体。

1、抽象类的语法

//抽象类:被abstract修饰的类
public abstract class Shape{
   //抽象方法:被abstract修饰的方法,没有方法体
   public abstract void drew();
   //抽象类中也可以增加普通方法和属性
   public double getArea(){
      return area;
   }
}

【注】抽象类也可以包括普通的方法和属性,甚至构造方法

2、抽象类的特性

3、抽象类的作用

抽象类本身不能被实例化,要想使用,只能创建该抽象类的子类,然后通过子类重写抽象类中的抽象方法。使用抽象类相当于多了一层编译器的检验。

有些情况下实际工作不应该由父类完成,而应由子类完成,如果误用为父类,父类为抽象类时就会在实例化时报错。

二、接口

1、接口的概念

接口就是公共的行为规范标准,大家在实现的时候,只要符合规范标准,就可以通用。在Java中,接口可以看成:多个类的公共规范,是一种引用数据类型。使用关键字interface。

public interface 接口名称{
    // 抽象方法
    public abstract void method1(); // public abstract 是固定搭配,可以不写
    public void method2();
    abstract void method3();
    void method4();
// 注意:在接口中上述写法都是抽象方法,
}

【注】

2、接口使用

接口不能直接使用,需要有一个类来实现该接口,实现接口中所有的抽象方法

public class  类名称 implements 接口名称{

     //……

}

【注】子类与父类之间是extends继承关系,类与接口之间是implements实现关系

3、接口特性

4、实现多个接口

Java中,类与类是单继承的关系,一个子类只能有一个父类,即Java不支持多继承。但是一个类可以实现多个接口。

class Animal{
    protected String name;
    public Animal(String name){
        this.name=name;
    }
}
interface IFlying{
    void fly();
}
interface IRunning{
    void run();
}
interface ISwimming{
    void swim();
}
class Duck extends Animal implements IFlying,IRunning,ISwimming{
    public Duck(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println("Duck正在飞!");
    }
    @Override
    public void run() {
        System.out.println("Duck正在跑!");
    }
    @Override
    public void swim() {
        System.out.println("Duck正在游泳!");
    }
}

【注】一个类可以实现多个接口,每个接口中的抽象方法都要实现。(使用ctrl+i快速实现接口)

5、接口间的继承

在Java中,类与类之间是单继承,一个类可以实现多个接口,接口与接口之间可以多继承。用接口可以达到多继承的的目的。

interface Animal extends IRunning,IFlying{
    //……
} 

接口继承接口,达到复用的效果,使用关键字extends。

6、常用的接口

(1)Comparable接口

import java.util.Arrays;
class Student implements Comparable{
    private String name;
    private int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override  //重写toString方法
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override  //重写Comparable中的compareTo方法
    public int compareTo(Object o) {
        Student x=(Student)o;
        if(this.age>x.age){
            return -1;
        }if(this.age<x.age){
            return 1;
        }else{
            return 0;
        }
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student[] students=new Student[3];
        students[0]=new Student("zhangsan",18);
        students[1]=new Student("lisi",22);
        students[2]=new Student("liming",21);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

当我们对students进行排序时,编译器不能确定通过什么排序,此时会报错,需要重写Comparable接口中的compareTo方法。

(2)Cloneable接口

Object类中存在一个clone方法,掉哦用这个方法可以创建一个对象的拷贝。要想合法调用clone方法,必须先实现Cloneable接口。否则会抛出CloneNotSupportedException异常。

class Person implements Cloneable{
    private String name;
 
    public Person(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class TestDemo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1=new Person("zhangsan");
        Person person2=(Person)person1.clone();
 
    }
}

Cloneable为空接口。空接口:标记接口。证明当前类是可以被克隆的。此时克隆的对象提供了副本,修改其中的信息不会对原信息产生影响。Cloneable拷贝出的对象是一份“浅拷贝”。

三、Object类

Object类是Java默认提供的一个类。Java里面除了Object类,所有的类都是存在继承关系的。默认继承Object父类。如果要打印对象中的内容,可以直接重写Object类中的toString方法。

【注】使用Object可以接受所有类的对象

对象比较equals()方法

在Java中,==进行比较时:

//Object类中的equals方法
public boolean equals(Object obj){
    return (this==obj);//使用引用中的地址直接来比较
}

【注】比较对象中内容是否相同时,一定要重写equals方法

加载全部内容

相关教程
猜你喜欢
用户评论