JAVA抽象类和接口

ambition…

于 2023-08-30 16:09:00 发布

阅读量143

点赞数 2

分类专栏： javaSE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_69468924/article/details/132547616

版权

javaSE 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、JAVA抽象类

1.定义

在打印图形的例子中，父类Shape中的draw方法并没有什么实际工作，绘制图形时都是由Shape类中的子类完成的，像这种没有实际工作的方法可以将它设计为一个抽象方法，包含抽象方法的类称为抽象类。

2.语法

使用abstract修饰的类被称为抽象类，抽象类中使用abstract修饰的方法被称为抽象方法。

abstract class shape{    //抽象类
    float area;
    public abstract void draw();   //抽象方法
    public void getArea(){
        System.out.println(area);
    }
}

注意：①抽象方法不用给出具体的实现体；②抽象类也是类，内部可以包含普通方法和属性，甚至构造方法。

3.特性

（1）抽象类不能直接实例化对象；（2）抽象方法不能是private；（3）抽象方法不能被final和static修饰，因为抽象方法要被子类重写；（4）若子类在继承抽象类时没有重写方法，则子类应也定义为抽象类；（5）抽象类中不一定有抽象方法，但有抽象方法的类一定是抽象类；（6）子类在继承抽象类时也要考虑抽象类的构造方法。

二、JAVA接口

1.定义

接口可以看成是：多个类的公共规范，是一种引用数据类型。

2.语法

将class关键字换成interface关键字就定义了一个接口，接口中的方法都是抽象方法。

interface Ishape{
    public static final int a=0;     //成员变量
    int b=0;   //成员变量
    public abstract void method1();  //成员方法
    public void method2();
    abstract void method3();
    void method4();
}

注意：①接口当中只有抽象方法（无构造方法和代码块），但两个方法除外（被static、default修饰的方法）；②接口当中的抽象方法默认都是public abstract修饰的，可省略；③接口当中的成员变量默认都是public static final 修饰的，不可改变，需赋初值；

3.特性

（1）接口不能进行实例化；（2）类和接口之间的关系可以使用implements进行关联；（3）接口也有对应的字节码文件；（4）接口解决了多继承问题。

4.实例

（1）USB接口

interface USB{       //定义USB接口
    void opendevice();
    void closedevice();
}
class KeyBoard implements USB{     //使用USB接口
    @Override
    public void opendevice() {
        System.out.println("连接usb接口打开键盘");
    }

    @Override
    public void closedevice() {
        System.out.println("拔掉usb关掉键盘");
    }
    public void input(){
        System.out.println("疯狂敲字");
    }
}
class Mouse implements USB{    //使用USB接口
    @Override
    public void opendevice() {
        System.out.println("连接usb接口打开鼠标");
    }

    @Override
    public void closedevice() {
        System.out.println("拔掉usb关掉鼠标");
    }
    public void click(){
        System.out.println("疯狂敲击");
    }
}
class Computer{
    public void open(){
        System.out.println("打开电脑");
    }
    public void close(){
        System.out.println("关闭电脑");
    }
    public void use(USB usb){
        usb.opendevice();
        if(usb instanceof KeyBoard){
            KeyBoard keyboard=(KeyBoard) usb;
            keyboard.input();
        }else if (usb instanceof Mouse) {
            Mouse mouse = (Mouse) usb;
            mouse.click();
        } else {
            System.out.println("转型失败");
        }
        usb.closedevice();
    }
}
public class text {
    public static void main(String[] args) {
        Computer computer=new Computer();
        KeyBoard keyboard=new KeyBoard();
        Mouse mouse=new Mouse();
        computer.open();
        computer.use(keyboard);
        System.out.println("=========================================");
        computer.use(mouse);
        computer.close();
    }
}

结果：

（2）动物接口

abstract class Animal{
    String name;
    public Animal(String name){
        this.name=name;
    }
    abstract void eat();
}
interface IRun{
    void run();
}
interface IFly{
    void fly();
}
interface ISwim{
    void swim();
}
class Dog extends Animal implements IRun{
    public Dog(String name){
        super(name);
    }
    @Override
    void eat() {
        System.out.println(this.name+"吃狗粮！！！");
    }

    @Override
    public void run() {
        System.out.println(this.name+"正在跑！！！");
    }
}
class Duck extends Animal implements IRun,IFly,ISwim{
    public Duck(String name) {
        super(name);
    }

    @Override
    void eat() {
        System.out.println(this.name+"吃鸭粮！！！");
    }

    @Override
    public void run() {
        System.out.println(this.name+"正在跑！！！");
    }

    @Override
    public void fly() {
        System.out.println(this.name+"正在飞！！！");
    }

    @Override
    public void swim() {
        System.out.println(this.name+"正在游泳！！！");
    }
}
public class text {
    public static void Eatting(Animal animal){
        animal.eat();
    }
    public static void Running(IRun run){
        run.run();
    }
    public static void Flying(IFly fly){
        fly.fly();
    }
    public static void Swimming(ISwim swim){
        swim.swim();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("小白");
        Duck duck = new Duck("鸭鸭");
        Eatting(dog);
        Running(dog);
        System.out.println("==========================================");
        Eatting(duck);
        Running(duck);
        Flying(duck);
        Swimming(duck);
    }
}

结果：

5.接口解决了多继承问题

子类只能继承一个父类，但有些特性不是每一个子类都有的，但如果将特性分成几个类写的话子类只能继承一个，所以将特性分成接口类，子类可以联系多个接口类。

6.接口类和接口类的关系

接口类与接口类之间用extends关键字

interface IA{
    void test1();
}
interface IB extends IA{
    void test2();
}
class C implements IB{
    @Override
    public void test1() {
    }
    @Override
    public void test2() {
    }
}

注意：IB接口不仅仅具备了IB自己的功能，而且还具备了IA接口的功能

7.三种方法比较对象的某个属性大小

（1）默认方式比较属性大小

class Student implements Comparable <Student>{
    String name;
    int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    public int compareTo(Student o) {   //重写接口中的方法
        return this.age-o.age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class text {
    public static void main(String[] args) {
        Student[] students=new Student[3];
        students[0]=new Student("笑笑",5);
        students[1]=new Student("淘气",4);
        students[2]=new Student("李华",12);
        System.out.println("排序前:"+ Arrays.toString(students));
        Arrays.sort(students);     //默认方式年龄排序
        System.out.println("排序后:"+ Arrays.toString(students));
    }
}

结果：

（2）比较器比较属性大小

class Student {
    public String name;
    public int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//两个比较器
class AgeComparator implements Comparator<Student>{
    public int compare(Student o1,Student o2){
        return o1.age-o2.age;
    }
}
class NameComparator implements Comparator<Student>{
    public int compare(Student o1,Student o2){
        return o1.name.compareTo(o2.name);
    }
}
public class text {
    public static void main(String[] args) {
        Student[] students=new Student[3];
        students[0]=new Student("笑笑",5);
        students[1]=new Student("淘气",4);
        students[2]=new Student("李华",12);
        System.out.println("排序前:"+ Arrays.toString(students));
        AgeComparator agecomparator = new AgeComparator();
        NameComparator namecomparator = new NameComparator();
        Arrays.sort(students,agecomparator);     //年龄排序
        System.out.println("按年龄排序后:"+ Arrays.toString(students));
        Arrays.sort(students,namecomparator);    //姓名排序
        System.out.println("按姓名排序后:"+ Arrays.toString(students));
    }
}

结果：

（3）冒泡排序

class Student implements Comparable <Student>{
    String name;
    int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    public int compareTo(Student o) {   //重写接口中的方法
        return this.age-o.age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class text {
    public static void MaoPao(Student[] students){
        for(int i=0;i<students.length-1;i++){
            for(int j=0;j<students.length-1-i;j++){
                if((students[j].compareTo(students[j+1])>0)){   //默认方式比较排序
                    Student temp=students[j];
                    students[j]=students[j+1];
                    students[j+1]=temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        Student[] students=new Student[3];
        students[0]=new Student("笑笑",5);
        students[1]=new Student("淘气",4);
        students[2]=new Student("李华",12);
        System.out.println("排序前:"+ Arrays.toString(students));
        MaoPao(students);
        System.out.println("排序后:"+ Arrays.toString(students));
    }
}

结果：