面向对象高级之接口

精选原创

卑鄙的外乡人 2024-07-27 18:04:04 博主文章分类：java ©著作权

文章标签 System ide 默认方法 文章分类 代码人生

©著作权归作者所有：来自51CTO博客作者卑鄙的外乡人的原创作品，请联系作者获取转载授权，否则将追究法律责任

1.接口：关键字interface

格式：public interface 接口名{

//成员变量（常量）

//成员方法（抽象方法）

}

public class Main {
    public static void main(String[] args){
    System.out.println(A.SCHOOL_NAME);
  //  A a = new A();//报错，A类没有构造函数
    }
}

public interface A {//这里的A是接口名，接口可以有方法和成员变量，但不能有构造器
    String SCHOOL_NAME = "ABC School";//成员变量，常量

    void test();

//    public A() {//不能有构造器
//
//    }

}

接口不能创建对象，接口是用来被类实现的，实现接口的类称为实现类。

一个类可以实现多个接口，实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义为抽象类。

public interface B {
    void testb1();
    void testb2();

}

public interface C {
    void testc1();
    void testc2();

}

//实现类
public class D implements B,C {//必须重写所有父类的方法

    @Override
    public void testb1() {

    }

    @Override
    public void testb2() {

    }

    @Override
    public void testc1() {

    }

    @Override
    public void testc2() {

    }
}

2.接口的好处

（1）弥补了单继承的不足，一个类可以实现多个接口。

public class Main {
    public void main(String[] args){
    System.out.println(A.SCHOOL_NAME);
  //  A a = new A();//报错，A类没有构造函数

        student s = new W();
        Q q = new W();//加上implements Q,R后，可以实例化W类，并且可以调用Q和R接口的默认方法
        q.say();//可以调用Q接口的默认方法
        R r = new W();
        r.speak();
    }

    class student{

    }
    class W extends student implements Q,R{
        @Override
        public void say() {

        }
        @Override
        public void speak() {

        }

    }
    interface Q{
        void say();

    }
    interface R{
        void speak();

    }
}

（2）让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现。一个类可以实现多个接口，一个接口也可以被多个类实现。

public class Main {
    public void main(String[] args){
    System.out.println(A.SCHOOL_NAME);
  //  A a = new A();//报错，A类没有构造函数

        student s = new W();
        Q q = new W();//加上implements Q,R后，可以实例化W类，并且可以调用Q和R接口的默认方法
        q.say();//可以调用Q接口的默认方法
        R r = new W();
        r.speak();

        Q t = new T();
        t.say();//切换到T类，可以调用Q接口的默认方法
    }

    class student{

    }
    class T implements Q{
        @Override
        public void say() {

        }

    }
    class W extends student implements Q,R{
        @Override
        public void say() {

        }
        @Override
        public void speak() {

        }

    }
    interface Q{
        void say();

    }
    interface R{
        void speak();

    }
}

案例：

面向对象高级之接口_默认方法

运行

public class test {
    public static void main(String[] args) {
        ClassManager cm = new ClassManager();
        cm.printInfo();
        cm.printAverageScore();
    }
}

方案一与方案二的切换

package com.lzk.test;

import java.util.ArrayList;
public class ClassManager {
    private ArrayList<Student> students = new ArrayList<Student>();
    private StudentOperator studentOperator = new StudentOperatorImpl2();//学生操作接口的实现类.修改方案一和方案二的实现类
    public ClassManager() {
        students.add(new Student("John", '男',100));
        students.add(new Student("Mary", '女', 90));
        students.add(new Student("Tom", '男', 80));
        students.add(new Student("Jerry", '女', 70));
    }
    public void printInfo() {
        studentOperator.printInfo(students);//调用学生操作接口的printInfo方法

    }
    public void printAverageScore(){
        studentOperator.printAverageScore(students);//调用学生操作接口的printAverageScore方法

    }
}

构造器

public class Student {

        private String name;
        private char gender;
        private double score;

    public String getName() {
        return name;
    }

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

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public Student() {
    }

    public Student(String name, char gender, double score) {
        this.name = name;
        this.gender = gender;
        this.score = score;
    }
}

接口

import java.util.ArrayList;
public interface StudentOperator{
    void printInfo(ArrayList<Student> students);
    void printAverageScore(ArrayList<Student> students);
}

方案一

public class StudentOperatorImpl1 implements StudentOperator {

        @Override
        public void printInfo(ArrayList<Student> students) {
            System.out.println("Student Information:");

            for (Student student : students) {
                System.out.println(student.getName() + " " + student.getGender() + " " + student.getScore());
            }
        }
        @Override
        public void printAverageScore(ArrayList<Student> students) {
            double sum = 0;
            int count = 0;
            for(Student student : students){
                sum += student.getScore();
                count++;
            }
            double average = sum / count;
            System.out.println("Average Score: " + average);
        }

    }

方案二

package com.lzk.test;

import java.util.ArrayList;

public class StudentOperatorImpl2 implements StudentOperator {

    @Override
    public void printInfo(ArrayList<Student> students) {
        System.out.println("Student Information:");
        int count1 = 0;
        int count2 = 0;
        for (Student student : students) {
            System.out.println(student.getName() + " " + student.getGender() + " " + student.getScore());
            if (student.getGender() == '男') {
                count1++;
            } else {
                count2++;
            }
        }
        System.out.println("Male Students: " + count1);
        System.out.println("Female Students: " + count2);

    }
    @Override
    public void printAverageScore(ArrayList<Student> students) {
        double sum = 0;
        int count = 0;
        double max = students.get(0).getScore();
        double min = students.get(0).getScore();
        for(Student student : students){
            sum += student.getScore();
            count++;
            if(student.getScore() > max){
                max = student.getScore();
            }
            if(student.getScore() < min){
                min = student.getScore();
            }
        }
        System.out.println("max score: " + max);
        System.out.println("min score: " + min);
        double average = (sum-min-max)/(count-2);
        System.out.println("without Min and Max Average Score: " + average);
    }

}

3.新增三种方法

test

public class test {
    public static void main(String[] args) {
        B b = new B();
        b.test1();
        A.test3();
    }
}

public interface A {
    default void test1() {// 接口默认方法,默认被public修饰，想要调用需要使用实现类的对象调用
        System.out.println("默认方法");
        test2();
    }
    private void test2() {//可以在A类中被其他方法调用
        System.out.println("私有方法");
    }
    static void test3() {//静态方法，可以直接通过类名调用
        System.out.println("静态方法");
    }
}

public class B implements A {
}

5.接口的多继承

interface A{
    void test1();
}

interface B{
    void test2();
}

interface C extends A,B{}// C继承多个接口

class D implements C{// D实现C接口

    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

6.接口使用注意事项

（1）一个接口继承多个接口，如果多个接口存在方法签名冲突，此时不支持多继承。

interface A{
    void test1();
}

interface B{
    String test1();
}

interface C extends A,B{//报错
    
}

（2）一个类实现多个接口，如果多个接口存在方法签名冲突，此时不支持多实现。

interface A{
        void test1();
    }

    interface B{
        String test1();
    }

//    interface C extends A,B{//报错
//
//    }
    class C implements A,B {//报错
    }

（3）一个类继承父类，同时实现接口，父类与接口有同名的默认方法，实现类会优先使用父类。

package com.lzk.test;

public class test {
    public static void main(String[] args) {
        Z z = new Z();
        z.run();

    }
}
//        interface A {
//            void test1();
//        }
//
//        interface B {
//            String test1();
//        }

//    interface C extends A,B{//报错
//
//    }
//    class C implements A,B {//报错
//    }
        class F {
            public void run() {
                System.out.println("1");
            }
        }
        interface G {
        default void run() {
            System.out.println("2");
            }
        }
        class Z extends F implements G {

        }

（4）一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。

interface IT1 {
     default void test1() {
        System.out.println("test1");
    }
}

interface IT2 {
    default void test1() {
        System.out.println("test2");

    }
}
class X implements IT1, IT2 {

    @Override
    public void test1() {
        IT1.super.test1();//或者重写自己的一个方法
    }
}