27. java面向对象

一、定义

/**
 * @ Author HuQi
 * @ Date 2020/2/1 17:05
 * @ Version 1.0
 * ---------------------------
 */

/*
* 1.接口的定义
* 2.java中，接口和类是并列结构
* 3.jdk8接口中可以定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
* 4.接口中不能定义构造器。意味着接口不可以实例化
* 5.接口通过让类去实现(implement)的方式来使用
* (1)如果实现类覆盖了接口中所有抽象方法，则此实现类就可以实例化
* (2)如果实现类没有覆盖了接口中所有抽象方法，则此实现类仍为一个抽象类
* 6.java类可以实现多个接口->弥补了java单继承行的局限性
* 7.接口和接口直接可以继承，而且可以多继承
* interface AA{}
* interface BB{}
* interface CC extends AA, BB{}
* */
public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.Max_SPEED);
        Plane plane = new Plane();
        plane.fly();
    }
}

interface Flyable{
    //全局变量
    public static final int Max_SPEED = 7990;
    public static final int MIN_SPEED = 1;

    public abstract void fly();

    public abstract void stop();
}


//实现飞的功能，需要将所有抽象方法进行重写
class Plane implements Flyable{
    @Override
    public void fly() {
        System.out.println("通过引擎起飞");
    }

    @Override
    public void stop() {
        System.out.println("驾驶员停止");
    }
}

//如果未全部覆盖实现类方法，则需要加上abstract
abstract class Kite implements Flyable{
    @Override
    public void stop() {
        System.out.println("放风筝");
    }
}

二、示例

​ 接口使用上提现多态性；

/**
 * @ Author HuQi
 * @ Date 2020/2/1 17:32
 * @ Version 1.0
 * ---------------------------
 */
public class USBTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        //1.创建接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        computer.transferData(flash);
        System.out.println("----------------------");
        //2.创建了接口的非匿名实现类的匿名对象
        computer.transferData(new Printer());
        System.out.println("----------------------");
        //3.创建接口的匿名实现类的非匿名对象
        USB phone = new USB() {
            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机停止工作");
            }
        };
        computer.transferData(phone);

        System.out.println("------------------");
        //4.创建接口的匿名实现类的匿名对象
        computer.transferData(new USB() {
            @Override
            public void start() {
                System.out.println("电视开始工作");
            }

            @Override
            public void stop() {
                System.out.println("电视停止工作");
            }
        });

    }
}

class Computer{
    //传输数据
    public void transferData(USB usb){
        usb.start();
        System.out.println("具体传输细节");
        usb.stop();
    }
}


interface USB{
    //定义了长、宽

    void start();
    void stop();
}

class Flash implements USB{
    @Override
    public void start() {
        System.out.println("u盘开启");
    }

    @Override
    public void stop() {
        System.out.println("u盘关闭");
    }
}


class Printer implements USB{
    @Override
    public void start() {
        System.out.println("printer开启");
    }

    @Override
    public void stop() {
        System.out.println("printer关闭");
    }
}

--------------------结果--------------------------
u盘开启
具体传输细节
u盘关闭
----------------------
printer开启
具体传输细节
printer关闭
----------------------
手机开始工作
具体传输细节
手机停止工作
------------------
电视开始工作
具体传输细节
电视停止工作

三、接口应用

>[package]Test
..>Circle.class
..>ComparableCircle.class  
..>ComparableCircleTest.class
..>CompareObject.interface

1. Circle

package Test;

public class Circle {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }
}

2. CompareObject

package Test;

public interface CompareObject {
    /*
    * 0：相等
    * 正数：当前对象大
    * 负数：当前对象小
    * */
    public int compareTo(Object obj);
}

3. ComparableCircle

package Test;

/**
 * @ Author HuQi
 * @ Date 2020/2/1 18:14
 * @ Version 1.0
 * ---------------------------
 * 定义一个ComparableCircle类，继承Circle类并实现CompareObject接口
 * 在ComparableCircle类中给出接口中方法compareTo的实现体用来比较两圆半径大小
 */
public class ComparableCircle extends Circle implements CompareObject {
    //继承父类构造器
    public ComparableCircle(double radius){
        super(radius);
    }

    @Override
    public int compareTo(Object obj) {
        if (this == obj) {
            return 0;
        }
        if (obj instanceof ComparableCircle) {
            ComparableCircle c = (ComparableCircle) obj;
            if (this.getRadius() > c.getRadius()) {
                return 1;
            } else if (this.getRadius() < c.getRadius()) {
                return -1;
            } else {
                return 0;
            }
        } else {
            throw new RuntimeException("传入的数据类型不匹配");
        }
    }
}

4. ComparableCircleTest

package Test;

public class ComparableCircleTest {
    public static void main(String[] args) {
        ComparableCircle comparableCircleOne = new ComparableCircle(10);
        ComparableCircle comparableCircleTwo = new ComparableCircle(10);

        int compareValue = comparableCircleOne.compareTo(comparableCircleTwo);
        System.out.println(compareValue );

    }
}

1.抽象类
	类的一种，用 abstract 关键字修饰的类。不能直接创建对象，但可以有构造器，用于子类继承后使用。
	
2.抽象方法
	用 abstract 关键字修饰的方法，没有方法体，必须给子类重写
	
3.final关键字
	>修饰变量：变为常量，接口中必须在声明时进行赋值，后续无法修改。类中可以在构造器中赋值，后续无法修改
	>修饰方法：变为最终方法，子类只能调用，不能重写
	>修饰类：变为最终类，不能被其他类继承，可以创建对象。例如String

4.接口 - 它和类是统一级别的存在，都是引用类型。
	>接口没有构造器，不能直接new对象
	>接口中的变量都是公开的静态的常量，默认被 public static final 修饰
	>接口中的方法都是抽象方法(不考虑1.8新特性)，默认被 public abstract 修饰
	>使用接口时，需要提供一个类去实现接口。关键字 implements 。实现类必须要重写接口中所有的抽象方法
	>一个接口可以有多个实现类，一个类可以实现多个接口