抽象类和接口以及Comparable内部比较器

一.抽象类

抽象类：定义共性功能，继承抽象类，那么抽象类中的抽象方法必须全部实现。

1.抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中
2.抽象类不可以直接创建对象（原因：调用抽象方法没有意义）
3.只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。不然子类也要是抽象类。

  4.抽象类一定是父类

  5.抽象类中可以不定义抽象方法（意义：静态方法可以直接让子类去使用）

  6.关键字不可以和private,final一起用。（final声明的类不允许有子类，private私有的不允许覆写）

  7.抽象类中可以没有抽象方法

 代码1：

public abstract class Animal {
    public abstract void eat();
    public abstract void sleep();
}

class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("dog eat");
    }

    @Override
    public void sleep() {
        System.out.println("dog sleep");
    }
}

//只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。不然子类也要是抽象类
abstract class Cat extends Animal{

    public abstract void catchMouse();

}


class LittleCat extends Cat{

    @Override
    public void eat() {
        System.out.println("little cat eat");
    }

    @Override
    public void sleep() {
        System.out.println("little cat sleep");
    }

    @Override
    public void catchMouse() {
        System.out.println("little cat catch");
    }
}

代码2：

package com.atguigu.day10;

public abstract class Animal {
    String name;
    int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void eat();
    public abstract void sleep();

    @Override
    public String toString() {
        return "name:"+name+" age:"+age;
    }
}

class Dog extends Animal{

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("dog eat");
    }

    @Override
    public void sleep() {
        System.out.println("dog sleep");
    }
}

//只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。不然子类也要是抽象类
abstract class Cat extends Animal{

    public abstract void catchMouse();

}


class LittleCat extends Cat{

    @Override
    public void eat() {
        System.out.println("little cat eat");
    }

    @Override
    public void sleep() {
        System.out.println("little cat sleep");
    }

    @Override
    public void catchMouse() {
        System.out.println("little cat catch");
    }
}

main

package com.atguigu.day10;

public class Test {

    public static void main(String args[]) {

        Dog dog1= new Dog();
        dog1.name="lin1";
        dog1.age=23;
        System.out.println(dog1);
        Dog dog2= new Dog("lin2",14);
        System.out.println(dog2);
    }
}

输出

name:lin1 age:23
name:lin2 age:14

二.接口

接口：用于拓展性

1.包含了功能声明的特殊类。
2.定义格式：public interface 接口名{}    使用格式：class A implements 接口名{}
3.接口中可以定义成员变量，但变量只能是最终变量，并且是静态的。默认修饰符：public static final。
4.接口中可以定义方法，但只能是抽象方法。接口中的方法默认被public abstract修饰

5.接口中没有构造方法，不可以创建对对象。 
6.子类必须覆盖掉接口中所有的抽象方法，子类才可以实例化。 
7.多个接口之间可以使用extends进行多继承，如果一个类继承了，实现了多个接口的接口，不仅要实现此接口的抽象方法，也要实现继承接口的抽象方法
8.类可以实现多个接口

 代码：

public interface Fly {
    int num=20;
    void fly();
}

interface Eats{
    void eat();
}

class Superman implements Fly{

    @Override
    public void fly() {
        System.out.println("super man fly");
    }
}

class Bird implements Fly,Eats{

    @Override
    public void fly() {
        System.out.println("bird fly");
    }

    @Override
    public void eat() {
        System.out.println("bird eat");
    }
}

main

public class Test {

    public static void main(String args[]) {

        Superman s1 = new Superman();
        s1.fly();
        Bird b1 = new Bird();
        b1.fly();
        b1.eat();

        //接口的多态
        Fly f1 = new Bird();
        f1.fly();
        //接口中的成员变量被public static final修饰
        System.out.println(Fly.num);
    }
}

输出

super man fly
bird fly
bird eat
bird fly
20

 代码2：

public interface Fly {
    int num=20;
    void fly();
    //jdk8提供的，jdk8以后在接口中可以使用此方法，给继承接口的类按需选择使用
    public default void addOil(){
        System.out.println("add oil");
    }
    //也可以有静态方法
    public static void show(){
        System.out.println("fly show");
    }
}

interface Eats{
    void eat();
}

class Superman implements Fly{

    @Override
    public void fly() {
        System.out.println("super man fly");
    }

    @Override
    public void addOil() {
        System.out.println("super man add oil");
    }
}

class Bird implements Fly,Eats{

    @Override
    public void fly() {
        System.out.println("bird fly");
    }

    @Override
    public void eat() {
        System.out.println("bird eat");
    }
}

main：

package com.atguigu.day10;

public class Test {

    public static void main(String args[]) {
        Superman s1 = new Superman();
        s1.fly();
        //s1按需选择使用addOil
        s1.addOil();
        Bird b1 = new Bird();
        b1.fly();
        b1.eat();


        //接口的多态
        Fly f1 = new Bird();
        f1.fly();
        //接口中的成员变量被public static final修饰
        System.out.println(Fly.num);
        //静态方法
        Fly.show();

    }
}

输出

super man fly
super man add oil
bird fly
bird eat
bird fly
20
fly show

 三.接口特殊情况

package com.atguigu.day10;

 interface Study {
    public default void study(){
        System.out.println("just study");
    }
}

interface HardStudy {
    public default void study(){
        System.out.println("just sing");
    }
}

class Students implements Study,HardStudy{

    @Override
    public void study() {
        System.out.println("self study");
        //可以在重写的方法中通过接口名.super.方法名调用
        Study.super.study();
        HardStudy.super.study();
    }
}

main

package com.atguigu.day10;

public class Test {

    public static void main(String args[]) {
        Students st1 = new Students();
        st1.study();

    }
}

输出

self study
just study
just sing

 四.comparable接口

目前对象.compareTo(需要比较的对象)

Comparable接口的声明以及作用，可以看到它可以使继承他的类进行比较大小，只需要调用实现类的compareTo方法即可

实现比较大小:

如果返回值等于零:o1=o2
返回值大于零则o1>o2
返回值小于于零则o1<o2

代码：

package com.atguigu.day10;

class P implements Comparable<P> {

    String name;
    int age;
    public P(String name,int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int compareTo(P o) {
        return this.age-o.age;
    }
}

main

public class ComparableTest {

    public static void main(String[] args) {
        P[] personList = new P[4];
        personList[0] = (new P("lin1", 22));
        personList[1] = (new P("lin2", 21));
        personList[2] = (new P("lin3", 36));
        personList[3] = (new P("lin4", 20));

        System.out.println("比较大小");
        P lin1 = new P("lin1", 22);
        P lin2 = new P("lin2", 21);
        String result = lin1.compareTo(lin2) == 0 ? "一样大" : lin1.compareTo(lin2) > 0 ? "lin1大" : "lin2大";
        System.out.println(result);

    }

}

输出

比较大小
lin1大

引用数据类型比较
Comparable：内部比较器
在比较对象类的内部，完成了比较规则的制定

Comparabtor：外部比较器

Comparable代码

package com.atguigu.day10;

public class FlyMan implements Comparable{
    String name;
    int age;
    int height;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public FlyMan() {
    }

    public FlyMan(String name, int age, int height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    @Override
    public String toString() {
        return "name:"+name+" age:"+age+" height:"+height;
    }

    @Override
    public int compareTo(Object o) {
        FlyMan f = (FlyMan) o;
        return this.height-f.height;
    }
}


package com.atguigu.day10;

public class WorkMan implements Comparable{
    String name;
    int age;

    public WorkMan() {
    }

    public WorkMan(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "name:"+name+" age:"+age;
    }


    @Override
    public int compareTo(Object o) {
        WorkMan workMan = (WorkMan) o;
        return this.age-workMan.age;
    }
}



package com.atguigu.day10.Utils;

public class SortArry {
    public static void sort(Comparable[] arr){
        for (int i = 0; i <arr.length-1 ; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j].compareTo(arr[j+1])>0) {
                    Comparable temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }

        }
    }
}



package com.atguigu.day10;

import com.atguigu.day10.Utils.SortArry;

public class CompareTest {
    public static void main(String[] args) {
        FlyMan f1= new FlyMan("lin1",23,177);
        FlyMan f2= new FlyMan("lin2",28,183);
        FlyMan f3= new FlyMan("lin3",19,182);
        FlyMan f4= new FlyMan("lin4",24,181);

        FlyMan[] fly1= {f1,f2,f3,f4};

        WorkMan w1 = new WorkMan("yang1",25);
        WorkMan w2 = new WorkMan("yang2",20);
        WorkMan w3 = new WorkMan("yang3",23);
        WorkMan w4 = new WorkMan("yang4",22);

        WorkMan[] work1 = {w1,w2,w3,w4};

        System.out.println("fly1排序前-------------------");
        for (int i = 0; i < fly1.length; i++) {
            System.out.println(fly1[i]);
        }
        System.out.println("fly1排序后-------------------");
        SortArry.sort(fly1);
        for (int i = 0; i <fly1.length ; i++) {
            System.out.println(fly1[i]);
        }

        System.out.println("work1排序前-------------------");
        for (int i = 0; i <work1.length ; i++) {
            System.out.println(work1[i]);
        }
        System.out.println("work1排序前-------------------");
        SortArry.sort(work1);
        for (int i = 0; i <work1.length ; i++) {
            System.out.println(work1[i]);
        }
    }
}

输出

fly1排序前-------------------
name:lin1 age:23 height:177
name:lin2 age:28 height:183
name:lin3 age:19 height:182
name:lin4 age:24 height:181
fly1排序后-------------------
name:lin1 age:23 height:177
name:lin4 age:24 height:181
name:lin3 age:19 height:182
name:lin2 age:28 height:183
work1排序前-------------------
name:yang1 age:25
name:yang2 age:20
name:yang3 age:23
name:yang4 age:22
work1排序前-------------------
name:yang2 age:20
name:yang4 age:22
name:yang3 age:23
name:yang1 age:25

Comparabtor
代码1：

package com.atguigu.day10;

public class TeacherTest {

    public static void mineSort(Teacher[] ts,TeacherSortOfAge sortOfAge){
        for (int i = 0; i <ts.length-1 ; i++) {
            for (int j = 0; j <ts.length-i-1 ; j++) {
                if(sortOfAge.compare(ts[j],ts[j+1])>0){
                    Teacher temp=ts[j];
                    ts[j]=ts[j+1];
                    ts[j+1]=temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        Teacher t1 = new Teacher("lin1",18,100.0);
        Teacher t2 = new Teacher("lin2",12,101.0);
        Teacher t3 = new Teacher("lin3",19,90.0);
        Teacher t4 = new Teacher("lin4",16,103.0);
        Teacher t5 = new Teacher("lin5",22,87.0);
        Teacher[] ts={t1,t2,t3,t4,t5};
        System.out.println("排序前--------------------");
        for (int i = 0; i <ts.length ; i++) {
            System.out.println(ts[i].toString());
        }
        System.out.println("排序后--------------------");
        TeacherSortOfAge tsoa = new TeacherSortOfAge();
        mineSort(ts,tsoa);
        for (int i = 0; i <ts.length ; i++) {
            System.out.println(ts[i].toString());
        }
    }
}

package com.atguigu.day10;
/*
使用外部比较器比较：
在比较对象的外面新建了一个类专门用于比较
1.定义一个类，实现Comparator接口
2.重写compare()传递连个参数
3.定制比较规则
4.先去创建比较规则的对象，通过对象调用compare()再传入对象
 */
import java.util.Comparator;

public class TeacherSortOfAge implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        Teacher p1 =(Teacher) o1;
        Teacher p2 = (Teacher) o2;
        return p1.age-p2.age;
    }
}

代码2:

package com.atguigu.day10;
import java.util.Comparator;
public class TeacherSortOfAgeAndSalary implements Comparator{

    @Override
    public int compare(Object o1, Object o2) {
        Teacher p1 =(Teacher) o1;
        Teacher p2 = (Teacher) o2;
        //当年龄相等
        if(p1.age==p2.age){
            return Double.compare(p1.salary,p2.salary);
        }
        return p1.age-p2.age;
    }
}

package com.atguigu.day10.Utils;

import java.util.Comparator;

public class SortUtils {
    public static void sort(Object[] objArr, Comparator com){
        for (int i = 0; i < objArr.length-1; i++) {
            for (int j = 0; j <objArr.length-i-1 ; j++) {
                if(com.compare(objArr[j],objArr[j+1])>0){
                    Object temp=objArr[j];
                    objArr[j]=objArr[j+1];
                    objArr[j+1]=temp;
                }
            }
        }
    }
}

package com.atguigu.day10;

import com.atguigu.day10.Utils.SortUtils;

public class TeacherTest {

    public static void mineSort(Teacher[] ts,TeacherSortOfAge sortOfAge){
        for (int i = 0; i <ts.length-1 ; i++) {
            for (int j = 0; j <ts.length-i-1 ; j++) {
                if(sortOfAge.compare(ts[j],ts[j+1])>0){
                    Teacher temp=ts[j];
                    ts[j]=ts[j+1];
                    ts[j+1]=temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        Teacher t1 = new Teacher("lin1",18,100.0);
        Teacher t2 = new Teacher("lin2",12,101.0);
        Teacher t3 = new Teacher("lin3",18,90.0);
        Teacher t4 = new Teacher("lin4",16,103.0);
        Teacher t5 = new Teacher("lin5",16,87.0);
        Teacher[] ts={t1,t2,t3,t4,t5};
        System.out.println("排序前--------------------");
        for (int i = 0; i <ts.length ; i++) {
            System.out.println(ts[i].toString());
        }
        System.out.println("排序后--------------------");
        TeacherSortOfAgeAndSalary tsoas = new TeacherSortOfAgeAndSalary();
        SortUtils.sort(ts,tsoas);
        for (int i = 0; i <ts.length ; i++) {
            System.out.println(ts[i].toString());
        }
    }
}

输出

排序前--------------------
name:lin1 age:18 salary:100.0
name:lin2 age:12 salary:101.0
name:lin3 age:18 salary:90.0
name:lin4 age:16 salary:103.0
name:lin5 age:16 salary:87.0
排序后--------------------
name:lin2 age:12 salary:101.0
name:lin5 age:16 salary:87.0
name:lin4 age:16 salary:103.0
name:lin3 age:18 salary:90.0
name:lin1 age:18 salary:100.0