JavaSE【抽象类和接口】(抽象类、接口、实现多个接口、接口的继承)

一、抽象类

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

1.语法

// 抽象类:被 abstract 修饰的类
public abstract class Shape {
// 抽象方法:被 abstract 修饰的方法,没有方法体
        abstract public void draw ();
        abstract void calcArea ();
// 抽象类也是类,也可以增加普通方法和属性
        public double getArea (){
               return area ;
        }
        protected double area ; // 面积
}
JavaSE【抽象类和接口】(抽象类、接口、实现多个接口、接口的继承)_第1张图片
写完之后,编译器可以看到抽象类 和 抽象方法 的图标

 

 

2.抽象类的特性 

1. 抽象类不能直接实例化自身对象,只能创建该抽象类的子类
2. 抽象方法不能是 private
3. 抽象方法不能被 fifinal static 修饰,因为抽象方法要被子类重写

4. 抽象类必须被继承,并且继承后子类要重写父类中的抽象方法,否则子类也是抽象类,必须要使用 abstract 修饰
5. 抽象类中不一定包含抽象方法,但是有抽象方法的类一定是抽象类
6. 抽象类中可以有构造方法,供子类创建对象时,初始化父类的成员变量
7.如果普通类A继承了抽象类,但不想重写该抽象类Shape的方法,这个普通类A前面就要用abstract修饰,但如果又有一个普通类B继承了这个A,那么B既要重写A的抽象方法,也要重写Shape的抽象方法

例子: 特性都在里面标注了


//抽象类,被abstract修饰的方法
abstract class Shape{
    //抽象类当中,可以和普通类一样,定义成员变量 和 成员方法
    //抽象类,被abstract修饰的方法
   public abstract void draw();
   //被final、private、static修饰的抽象方法是不可以的
}
//抽象类就是为了被继承
//当一个普通的类,继承了这个抽象类,那么需要重写这个抽象类中的所有抽象方法!!!
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("圆形");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}
//如果普通类A继承了抽象类,但不想重写该抽象类Shape的方法,这个普通类A前面就要用abstract修饰
//但如果又有一个普通类B继承了这个A,那么B既要重写A的抽象方法,也要重写Shape的抽象方法
abstract class A extends Shape{
    public abstract void test();
}
class B extends A{
    //重写Shape里的所有抽象方法
    @Override
    public void draw() {

    }
    //重写A里的所有抽象方法
    @Override
    public void test() {

    }
}
public class Test {
    public static void drawMap(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
        //抽象类本身不能实例化对象
        //Shape shape = new Shape();

        //抽象类只能创建该抽象类的子类
        Shape shape = new Rect();
        Shape shape2 = new Cycle();
        drawMap(shape);
        drawMap(shape2);
    }
}

二、接口

Java 中,接口可以看成是:多个类的公共规范,是一种引用数据类型。

1.语法

接口的定义格式与定义类的格式基本相同,将 class 关键字换成 interface 关键字,就定义了一个接口。
public interface 接口名称 {
// 抽象方法
        public abstract void method1 (); // public abstract 是固定搭配,可以不写
        public void method2 ();
        abstract void method3 ();
        void method4 ();
// 注意:在接口中上述写法都是抽象方法,跟推荐方式 4 ,代码更简洁
}

2.接口的使用

接口不能直接使用,必须要有一个 " 实现类 " " 实现 " 该接口,实现接口中的所有抽象方法。
public class 类名称 implements 接口名称 {
// ...
}
子类和父类之间是 extends 继承关系,类与接口之间是 implements 实现关系。

 4.接口特性

1. 接口类型是一种引用类型,但是不能直接 new 接口的对象
2. 接口里只能有抽象方法; dk8中:接口中还可以包含default、static方法。
3. 接口中的方法是不能在接口中实现的,只能由实现接口的类来实现,或者使用 static、default修饰的方法 (其中由接口实现的类,必须被重写,因为接口里的方法默认都是 public abstract 所修饰的!!!)(default修饰的可以重写也可以不重写)(static不能重写,可以直接通过类名调用)
4.  重写接口中方法时,不能使用默认的访问权限,只能是public
(因为子类的访问权限要大于父类)
5. 接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static fifinal 变量
(相当于常量)
6.   接口中不能有代码块和构造方法
7. 接口虽然不是类,但是接口编译完成后字节码文件的后缀格式也是 .class
8. 如果类没有实现接口中的所有的抽象方法,则类必须设置为抽象类

//接口
interface IShape{
    //接口里的方法默认都是 public abstract 所修饰的!!!
    //全称 :public abstract void draw();
    void draw();//默认抽象方法

    //接口里只能有抽象方法,还有static、default修饰的方法(jdk8引入的)
    default public void test(){}
    static public void test2(){};

    //接口当中的成员变量 默认都是 public static final 修饰的!!!
    //实际上就是一个常量,常量一般大写字母表示
    int A = 1;
    public static int B = 2;
    public static final int C = 3;

}
//类实现接口,使用implement
class Rect_i implements IShape{
    //需要重写接口的抽象方法
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}
class Flower_i implements IShape{
    @Override
    public void draw() {
        System.out.println("花花");
    }
}
public class Test2 {
    public static void drawMap(IShape iShape){
        iShape.draw();
    }
    public static void main(String[] args) {
        //接口不能实例化自身
        //IShape iShape = new IShape();

        //接口只能创建该抽象类的子类
        IShape iShape1 = new Flower_i();
        IShape iShape2 = new Rect_i();
        drawMap(iShape1);
        drawMap(iShape2);

        System.out.println("================");

        IShape[] iShapes ={new Flower_i(),new Rect_i()};
        for (IShape x:iShapes) {
            drawMap(x);
        }
    }

}

 

4.实现笔记本电脑使用USB鼠标、USB键盘的例子

1. USB 接口:包含打开设备、关闭设备功能
2. 笔记本类:包含开机功能、关机功能、使用 USB 设备功能
3. 鼠标类:实现 USB 接口,并具备点击功能
4. 键盘类:实现 USB 接口,并具备输入功能
package demo2;

public interface USB {
    void openDevice();
    void closeDevice();
}
package demo2;

public class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println("鼠标开始工作");
    }
    @Override
    public void closeDevice() {
        System.out.println("鼠标结束工作");
    }
    public void click(){
        System.out.println("疯狂点击鼠标。。。。。。。。");
    }
}
package demo2;

public class KeyBoard implements USB{
    @Override
    public void openDevice() {
        System.out.println("键盘开始工作");
    }
    @Override
    public void closeDevice() {
        System.out.println("键盘结束工作");
    }
    public void input(){
        System.out.println("疯狂敲打键盘。。。。。。。。。。。");
    }
}
package demo2;

public class Computer {
    public void powerOn(){
        System.out.println("打开电脑!!");
    }
    public void powerOff(){
        System.out.println("关闭电脑!!");
    }
    public void useService(USB usb){
        usb.openDevice();
        //如果usb引用的对象是Mouse,强制类型转换到Mouse
        //如果usb引用的对象是KeyBoard,强制类型转换到KeyBoard
        if (usb instanceof Mouse){
            Mouse mouse = (Mouse) usb;
            mouse.click();
        } else if (usb instanceof KeyBoard) {
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.input();
        }
        usb.closeDevice();
    }
}
package demo2;

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        Mouse mouse = new Mouse();
        KeyBoard keyBoard = new KeyBoard();

        computer.powerOn();
        computer.useService(mouse);
        System.out.println("=================");
        computer.useService(keyBoard);
        computer.powerOff();
    }
}

 JavaSE【抽象类和接口】(抽象类、接口、实现多个接口、接口的继承)_第2张图片

5.实现多个接口 - 解决Java的多继承问题

Java 中,类和类之间是单继承的,一个类只能有一个父类,即 Java 中不支持多继承 ,但是 一个类可以实现多个接 。下面通过类来表示一组动物 .
狗是一种动物 , 具有会跑的特性 .
青蛙也是一种动物 , 既能跑 , 也能游泳
鸭子也是一种动物 , 既能跑 , 也能游 , 还能飞
JavaSE【抽象类和接口】(抽象类、接口、实现多个接口、接口的继承)_第3张图片

 

 

package demo3;

abstract class Animal{
    public String name;
    public int age;

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

}
interface IFly{
    void fly();
}
interface IRun{
    void run();
}
interface ISwim{
    void swim();
}
//狗是一个动物,具备跑这个功能
class Dog extends Animal implements IRun{
    public Dog(String name, int age) {
        super(name, age);
    }

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

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


}
class Frog extends Animal implements IRun,ISwim{
    public Frog(String name,int age){
        super(name,age);
    }

    @Override
    public void run() {
        System.out.println(this.name+"正在用4条腿跳着跑!!");
    }

    @Override
    public void swim() {
        System.out.println(this.name+"正在蛙泳!!");
    }

    @Override
    public void eat() {
        System.out.println(this.name+"吃蛙粮");
    }
}
class Duck extends Animal implements IRun,IFly,ISwim{
    public Duck(String name, int age) {
        super(name, age);
    }

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

    @Override
    public void swim() {
        System.out.println(this.name+"正在 游泳!!!");
    }

    @Override
    public void fly() {
        System.out.println(this.name+"正在用两只翅膀飞!!!");
    }

    @Override
    public void eat() {
        System.out.println(this.name+"吃鸭粮");
    }
}
public class Test {
    public static void func1(Animal animal){
        animal.eat();
    }
    public static void run(IRun iRun){
        iRun.run();
    }
    public static void fly(IFly ifly){
        ifly.fly();
    }
    public static void swim(ISwim iSwim){
        iSwim.swim();
    }

    public static void main(String[] args) {
        run(new Duck("唐老鸭",1));
        swim(new Duck("唐老鸭",1));
        fly(new Duck("唐老鸭",1));
        System.out.println("========");
        run(new Dog("二狗子",2));
        System.out.println("========");
        run(new Frog("青蛙王子",3));
        swim(new Frog("青蛙王子",3));

    }
    public static void main1(String[] args) {
//        Animal animal = new Duck("唐老鸭",1);
//        Animal animal2 = new Dog("二狗子",2);
//        Animal animal3 = new Frog("青蛙王子",3);

        Animal[] animals = {new Duck("唐老鸭",1),new Dog("二狗子",2),new Frog("青蛙王子",3)};
        for (Animal x:animals) {
            func1(x);

        }

    }
}

 6.接口间的继承

JavaSE【抽象类和接口】(抽象类、接口、实现多个接口、接口的继承)_第4张图片

package demo4extends;

interface A{
    void testA();
}
interface B extends A{
    void testB();
}
class TestDemo1 implements B{
    @Override
    public void testA() {
        
    }

    @Override
    public void testB() {

    }
}
public class Test {
}

 7.接口的使用实例

1)给定一个学生对象数组, 对这个对象数组中的元素进行排序

JavaSE【抽象类和接口】(抽象类、接口、实现多个接口、接口的继承)_第5张图片

JavaSE【抽象类和接口】(抽象类、接口、实现多个接口、接口的继承)_第6张图片 

JavaSE【抽象类和接口】(抽象类、接口、实现多个接口、接口的继承)_第7张图片 

 

 

方法1:类里重写comparaTo方法(方式固定)

package demo5;

/**
 * 方法1:固定比较方式
 */
class Student implements Comparable{
    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 +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        if(this.age > o.age){
            return 1;
        } else if (this.age == o.age) {
            return 0;
        }else {
            return -1;
        }
    }
}
public class Test {
    public static void main(String[] args) {
        //两个引用类型比较大小
        Student student1 = new Student("zhangsan",10);
        Student student2 = new Student("lisi",20);
        //System.out.println(student1>student2);无法比较
        //因为,student是引用类型,里面存的是地址,无法直接通过大于小于符号比较大小
        //不知道拿什么作比较(是姓名还是年龄)

        //使用重写后的compareTo
        System.out.println(student1.compareTo(student2));
    }
    public static void main1(String[] args) {
        //普通数值比较大小
        int a = 10;
        int b = 20;
        System.out.println(a > b);//false
    }
}

方法2:自定义一个类,写比较器(运用灵活)


import java.util.Comparator;

/**
 * 方法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{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age- o2.age;
    }
}
//根据姓名比较
class NameComparator implements Comparator{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class Test {
    public static void main(String[] args) {
        //两个引用类型比较大小
        Student student1 = new Student("zhangsan",10);
        Student student2 = new Student("lisi",20);

        AgeComparator ageComparator = new AgeComparator();
        System.out.println(ageComparator.compare(student1, student2));

        NameComparator nameComparator = new NameComparator();
        System.out.println(nameComparator.compare(student1, student2));
    }

}

2)给students数组排序

package demo5;
import java.util.Arrays;
import java.util.Comparator;

/**
 * 方法1:固定比较方式
 */
//class Student implements Comparable{
//    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 +
//                '}';
//    }
//
//    @Override
//    public int compareTo(Student o) {
//        if(this.age > o.age){
//            return 1;
//        } else if (this.age == o.age) {
//            return 0;
//        }else {
//            return -1;
//        }
//    }
//}
/**
 * 方法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{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age- o2.age;
    }
}
//根据姓名比较
class NameComparator implements Comparator{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class Test {
    public static void main(String[] args) {
//        int[] array = {1,2,31,4};
//        Arrays.sort(array);
//        System.out.println(Arrays.toString(array));

        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",10);
        students[1] = new Student("lisi",4);
        students[2] = new Student("abc",5);
        System.out.println("排序前:"+Arrays.toString(students));

        //方法1:可以用固定方法
        //Arrays.sort(students);

        //方法2:可以用自定义方法,比较器
        AgeComparator ageComparator = new AgeComparator();
        NameComparator nameComparator = new NameComparator();
        //Arrays.sort(students,ageComparator);
        Arrays.sort(students,nameComparator);
        System.out.println("排序后:"+Arrays.toString(students));

    }
    public static void main3(String[] args) {
        //两个引用类型比较大小
        Student student1 = new Student("zhangsan",10);
        Student student2 = new Student("lisi",20);

//        AgeComparator ageComparator = new AgeComparator();
//        System.out.println(ageComparator.compare(student1, student2));
//
//        NameComparator nameComparator = new NameComparator();
//        System.out.println(nameComparator.compare(student1, student2));
    }
    public static void main2(String[] args) {
        //两个引用类型比较大小
        Student student1 = new Student("zhangsan",10);
        Student student2 = new Student("lisi",20);
        //System.out.println(student1>student2);无法比较
        //因为,student是引用类型,里面存的是地址,无法直接通过大于小于符号比较大小
        //不知道拿什么作比较(是姓名还是年龄)

        //使用重写后的compareTo
        //System.out.println(student1.compareTo(student2));
    }
    public static void main1(String[] args) {
        //普通数值比较大小
        int a = 10;
        int b = 20;
        System.out.println(a > b);//false
    }
}

方法1:固定方法

JavaSE【抽象类和接口】(抽象类、接口、实现多个接口、接口的继承)_第8张图片 

 

 

方法2:自定义方法,比较器

JavaSE【抽象类和接口】(抽象类、接口、实现多个接口、接口的继承)_第9张图片

根据name排序 

 根据age排序

 

你可能感兴趣的:(Java,java,开发语言)