接口(续)和Object类

文章目录

  • 一.接口
    • 1.实现多个接口
    • 2.接口之间的继承
    • 3.接口中的静态方法和默认方法
      • ①.静态方法
      • ②.默认方法
    • 4.接口的使用实例
      • 对象数组排序
        • (1).Comparable 自然排序
        • (2).Comparator 定制排序
  • 二.Object
    • 1.equals方法
    • 2.toString()方法

一.接口

1.实现多个接口

在Java中不支持多继承,但是一个类可以实现多个接口。就像鸭子,可以飞,跑,游,我们可以用三个接口实现;对于多个接口的实现,须用implements关键字,而接口之间,用逗号隔开。

例1:

interface IFlying{
    void Flying();
}
interface IRunning{
    void Running();
}
interface ISwimming{
    void swimming();
}
class Duck  implements IFlying,IRunning,ISwimming{
    public String name;
    public Duck (String name){
       this.name = name;
    }
    @Override
    public void Flying() {
        System.out.println(this.name+"天上飞");
    }
    @Override
    public void Running() {
        System.out.println(this.name+"地上跑");
    }
    @Override
    public void swimming() {
        System.out.println(this.name+"水里游");
    }
}
public class Test {
    public static void main(String[] args) {
      Duck d = new Duck("白糖");
      d.Flying();
      d.Running();
      d.swimming();
    }
}

执行结果:

白糖天上飞
白糖地上跑
白糖水里游

这就是一个类实现多个接口,它们接口中的抽象方法必须要全部实现

2.接口之间的继承

与类的继承不同的是,一个接口可以有一个以上的父接口,它们之间用逗号分隔,形成父接口列表。新接口将继承所有父接口中的常量、抽象方法和默认方法,但不能继承父接口中的静态方法,也不能被实现类所继承。

例2:

interface IRunning{
    void Running();
}
interface ISwimming{
    void swimming();
}
interface IAmphibian extends ISwimming,IRunning{

}
class Duck  implements IAmphibian{
    public String name;
    public Duck (String name){
       this.name = name;
    }

    @Override
    public void Running() {
        System.out.println(this.name+"地上跑");
    }

    @Override
    public void swimming() {
        System.out.println(this.name+"水里游");
    }
}

接口间的继承相当于把多个接口合并在一起.

3.接口中的静态方法和默认方法

①.静态方法

接口中的静态方法不能被子接口继承,也不能被实现该接口的类继承。对接口中静态方法的访问,可以通过接口名直接进行访问,即用“接口名.静态方法名()”的形式进行调用。

②.默认方法

接口中的默认方法用default修饰符来定义,默认方法可以被子接口或被实现该接口的类所继承,接口中的默认方法有方法体,须通过接口实现类的实例进行访问,即通过“对象名.默认方法名()”的形式进行访问。

例3:在接口中定义默认方法和抽象方法,和静态方法

interface Face{
    final static double  PI = 3.14;//定义常量
    //定义默认方法--计算面积
    public default double area(int r){
        return r*r*PI;
    }
    //定义抽象方法
    double volume(int r,double h);
    //定义静态方法
    public static String show(){
        return "我是静态方法";
    }
}
public class Test implements Face{
  //实现接口的方法
    @Override
    public double volume(int r, double h) {
        return area(r)*h;
    }

    public static void main(String[] args) {
        System.out.println(Face.show());
        Test t = new Test();
        System.out.println("圆柱的体积 = "+t.volume(1, 2.0));
    }
}

结果如下:

我是静态方法
圆柱的体积 = 6.28

4.接口的使用实例

对象数组排序

自定义的学生类要具备可以比较的功能,就需要接口来实现,介绍Comparable,Comparator两种比较机制

(1).Comparable 自然排序

Comparable 接口只包括一个函数,它的定义如下

public interface Comparable<T> {
    public int compareTo(T o);
}

Comparable具体的比较规则是按照 compareTo 方法中的规则进行。这种顺序称为 自然顺序。
compareTo 方法的返回值有三种情况:

  • s1.compareTo(s2) >0 即 s1 > s2;
  • s1.compareTo(s2) <0 即 s1 < s2;
  • s1.compareTo(s2) =0 即 s1 = s2;
    也可以重写compareTo的方法
    例4
class Sturdnt implements Comparable<Sturdnt>{
    public String name;
    public  int score;
    public Sturdnt(String name,int score){
        this.name = name;
        this.score = score;
    }
    @Override
    public int compareTo(Sturdnt o) {
        return this.score - o.score;
    }
}
public class Test {
    public static void main(String[] args) {
        Sturdnt s1 = new Sturdnt("大飞",89);
        Sturdnt s2 = new Sturdnt("白糖",90);
        if(s1.compareTo(s2) > 0){
            System.out.println("s1 > s2");
        } else if (s1.compareTo(s2) < 0) {
            System.out.println("s1 > s2");
        }else {
            System.out.println("s1 > s2");
        }
    }
}

(2).Comparator 定制排序

Comparator可以在类的外部使用,然后把该接口实现类的匿名对象当作参数传给排序方法中。可以拥有多个接口实现类,实现按照不同属性进行排序
如例5:

class Sturdnt {
    public String name;
    public  int score;
    public Sturdnt(String name,int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Sturdnt{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

}
class ScoreComparator implements Comparator<Sturdnt>{

    @Override
    public int compare(Sturdnt o1, Sturdnt o2) {
        return o1.score -o2.score;
    }
}
class NameComparator implements  Comparator<Sturdnt>{
    @Override
    public int compare(Sturdnt o1, Sturdnt o2) {
        return o1.name.compareTo(o2.name);
    }

}

public class Test1 {
    public static void main(String[] args) {
        Sturdnt[] sturdnts = new Sturdnt[3];
        sturdnts[0] = new Sturdnt("大飞",89);
        sturdnts[1] = new Sturdnt("白糖",90);
        sturdnts[2] = new Sturdnt("武松",99);
        ScoreComparator scoreComparator = new ScoreComparator();
        Arrays.sort(sturdnts,scoreComparator);
        System.out.println(Arrays.toString(sturdnts));
        NameComparator nameComparator = new NameComparator();
        Arrays.sort(sturdnts,nameComparator);
        System.out.println(Arrays.toString(sturdnts));
    }
}


输出结果:

[Sturdnt{name=‘大飞’, score=89}, Sturdnt{name=‘白糖’, score=90}, Sturdnt{name=‘武松’, score=99}]
[Sturdnt{name=‘大飞’, score=89}, Sturdnt{name=‘武松’, score=99}, Sturdnt{name=‘白糖’, score=90}]

二.Object

所有的类都是直接或间接地继承Object类而得到的。即如果某个类没有使用extends关键字,则该类默认为java.lang.Object类的子类。所以说Object类是所有类的源,也就是所有类的对象都可以使用Object的引用进行接收。
例:使用Object接收所有类的对象

class Student{}
public class Text {
    public static void func(Object obj){
        System.out.println(obj);
    }
    public static void main(String[] args) {
        func(new Student());
    }
}

执行结果:

Student@1b6d3586
介绍几个方法:

1.equals方法

在Java中,“==”运算符用于比较两个变量本身的值,即两个对象在内存中的首地址,而equals()方法则是比较两个字符串中所包含的内容是否相同;如果要比较对象中内容,必须重写Object中的equals方法,因为equals方法默认也是按照地址比较的
例1:

class Student{
        public int score;
        public String name;
        public Student(String name,int score){
            this.name = name;
            this.score = score;
        }
    public boolean equals(Object obj) {
        if (obj == null) {
            return false ;
        }
        if(this == obj) {
            return true ;
        }
        // 不是Person类对象
        if (!(obj instanceof Student)) {
            return false ;
        }
       Student student = (Student) obj ; // 向下转型,比较属性值
        return this.name.equals(student.name) && this.score==student.score ;
    }
}
public class Text {
    public static void main(String[] args) {
      Student s1 = new Student("白糖",100);
      Student s2 = new Student("白糖",100);
        System.out.println(s1.equals(s2));
    }
}

执行结果:true

注: 比较对象中内容是否相同的时候,一定要重写equals方法。

2.toString()方法

toString()方法的功能是将调用该方法的对象的内容转换成字符串,并返回其内容,但返回的是一些没有意义且看不懂的字符串,所以可以直接重写Object类中toString()方法

class Student{
        public int score;
        public String name;
        public Student(String name,int score){
            this.name = name;
            this.score = score;
        }
        public String toString() {
        return "Student{" +
                "score=" + score +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Text {

    public static void main(String[] args) {
      Student s1 = new Student("白糖",100); 
      System.out.println(s1);
    }
}

执行结果:

Student{score=100, name=‘白糖’}

你可能感兴趣的:(JavaSE,java,算法)