Java学习路程之接口和抽象

一.接口和抽象类
1.接口和抽象之间的区别
1).使用方式
抽象类: 使用继承(关键字extends)
接口: 接口的实现(关键字 implements)
2.成员变量
抽象类:变量 常量
接口:常量(系统默认以public static final 修饰)
3.成员方法
抽象类: 抽象方法 成员方法
接口: 抽象方法(静态方法 默认方法)
4.构造方法
抽象类:有
接口:没有

类与类之间的关系:单继承和多层继承
类和接口之间的关系:单实现也可以多实现
接口与接口之间的关系:可以是单继承和多继承

public class Day10 {
    public static void main(String[] args) {

    }
}
interface interA{
    public abstract void fn1();
}
interface interB {
    public abstract void fn2();
}
//类和接口之间的关系:单实现也可以多实现
class classA implements interA,interB{
    //抽象方法的实现
    public void fn2() {

    }
    public void fn1() {

    }
}
//接口与接口之间的关系:可以是单继承和多继承
interface interC{
    public abstract void fn1();
}
interface interD extends interC,interE{

}
interface interE{
    public abstract void fn2();
}
//实现interD
class classB implements interD{
    public void fn1() {

    }
    public void fn2() {

    }
}

2.新特性 接口的静态方法和默认方法
静态方法:static修饰
默认方法:default修饰
默认方法实现类不要求强制重写,实现类中可以重写默认方法但是不能使用default修饰,调用可以使用多态的形式

interface Inter1{
    //抽象方法
    public abstract void fn();
    //静态方法
    public static void fn1(){
        System.out.println("接口Inter1中的静态方法");
    }
    //默认方法
    public default void fn2(){
        System.out.println("接口Inter1中的默认方法");
    }
}
//接口实现类
class InterImpl implements Inter1{
    public void fn() {
        System.out.println("我是实现类中的Fn方法");
    }
    public void defaultFn() {
        System.out.println("我是实现类的defaultFn方法");
    }
    //静态方法
    public static void staticFn() {
        System.out.println("我是实现类中的staticFn方法");
    }
    //成员方法
    public void test(){
        //调用接口中的静态方法
        Inter1.staticFn();
        //调用接口中的默认方法
        InterF.super.defaultFn();
    }
}

二.缺省适配器模式
实现方法:
1.使用一个适配器类实现接口,实现接口中的所有方法,方法使用空实现
2.用户的类再来继承这个适配器类
3.用户的类可以进行选择性的重写

public class Day10 {
    public static void main(String[] args) {
        Adapter adapter = new XM();
        adapter.run();//输出:跑步
    }
}
//接口
interface Gym{
    public abstract void run();
    public abstract void swim();
}
//适配器实现接口
class Adapter implements Gym{
    public void run(){};
    public void swim(){};
}
//创建用户类进行选择性重写
class XM extends Adapter{
    public void run(){
        System.out.println("跑步");

    };
}

练习1
/* 经过国际主板研究协会讨论
* 最终要求 主板生产商 要按规则生产可插卡的主板(插卡的方法)
* 所有的卡都要有 开始和停止的方法
* 设计完成 生产 大力牌主板
* 主板接口(插卡方法)
* 抽象卡类(开始和停止的方法)
* 声卡 继承抽象类
* 大力牌主板类 实现接口*/

//抽象卡类
abstract class Card{
    //抽象方法
    public abstract void start();
    public abstract void stop();
}
//接口类
interface MainBoardInter{
    //多态的插卡方法
    public abstract void insertCard(Card card);
}
//声卡类
class SoundCard extends Card{
    public void start(){
        System.out.println("播放音乐");
    }
    public void stop() {

        System.out.println("结束播放");
    }
}
//大力牌主板类
class DLMainBoard implements MainBoardInter{
    public void insertCard(Card card) {
        card.start();
        card.stop();
    }
}

练习2
/* 需求:
* 1.人类 吃 姓名 性别
* 2.男人类 姓名 性别 有女朋友 吃肉 介绍女朋友是谁和性别 并介绍自己是谁
* 3.女人类 姓名 性别 有男朋友 吃素 介绍男朋友是谁和性别 并介绍自己是谁
* 4.男人可以挣钱给女朋友花 接口 男人类实现
* 5.女的特有方法 整容 开眼角 丰唇
* (要求构造方法/set/get方法)
* 6.写测试类测试
*
* */

//人类
class Person{
    private String name;
    private String gender;
    //构造方法
    public Person() {

    }
    public Person(String name,String gender) {
        this.name = name;
        this.gender = gender;
    }
    //set/get方法

    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public String getGender() {
        return gender;
    }
    //抽象吃的方法
    public abstract void eat();
}
//男人类
public class Man extends Person implements MakeMoney{
    //使用其他类的对象来当做自己类的成员变量
    //女友
    private Woman girlFriend;
    //构造方法
    public Man() {

    }
    public Man(String name, String gender, Woman girlFriend) {
        //先调用父类的有参数构造方法
        super(name, gender);
        //给自己特有的成员变量赋值
        this.girlFriend = girlFriend;
    }
    //set/get方法
    public void setGirlFriend(Woman girlFriend) {
        this.girlFriend = girlFriend;
    }
    public Woman getGirlFriend() {
        return girlFriend;
    }
    //实现抽象方法
    public void eat() {
        System.out.println("吃肉");
    }
    //介绍自己和女友方法
    public void sayHi() {
        //现获取女朋友的对象,对象.get方法获取名字性别
        System.out.println("女朋友是" +this.getGirlFriend().getName());
        System.out.println("性别" + this.girlFriend.getGender());
        System.out.println("我是" + this.getName());
    }
    //实现接口的方法
    public void makeMoney() {
        System.out.println("挣钱养家");
    }
}
//女人类
public class Woman extends Person{
    //男友
    private Man manFriend;
    public Woman() {

    }
    public Woman(String name,String gender, Man manFriend) {
        super(name, gender);
        //给自己特有的成员变量赋值
        this.manFriend = manFriend;
    }
    //set/get方法
    public Man getManFriend() {
        return manFriend;
    }
    public void setManFriend(Man manFriend) {
        this.manFriend = manFriend;
    }
    public void eat() {
        System.out.println("吃素");
    }
    //整容
    public void changeFace(String body) {
        System.out.println("整" + body);
    }
    //介绍
    public void sayHi() {
        //现获取男朋友的对象,对象.get方法获取名字性别
        System.out.println("我是" + this.getName());
        System.out.println("男朋友是" +this.manFriend.getName());
        System.out.println("性别" + this.manFriend.getGender());
    }
}
//接口
public interface MakeMoney {
    public abstract void makeMoney();
}
//测试类
public class Test {
    public static void main(String[] args) {
        //创建女对象
        Woman woman = new Woman();

        //男的赋值
        Man man = new Man();
        man.setName("东");
        man.setGender("男");
        man.setGirlFriend(woman);
        //女的赋值
        woman.setName("小花");
        woman.setGender("女");
        woman.setManFriend(man);
        man.sayHi();
        woman.sayHi();
        //通过man对象,把GirlFriend取出
        //拥有一个其他类的对象,
        man.getGirlFriend().changeFace("双眼皮");
    }
}

练习3
/*新建类：汽车类(Car) 引擎类(Engine)
汽车类特征：汽车名称carName 汽车颜色carColor
汽车价格carPrice 引擎carEngine
汽车类行为：介绍sayHi：汽车名称 汽车颜色 汽车价格 引擎名称 引擎类型
引擎类特征：引擎名称engineName 引擎类型engineType

创建轮胎类Tire
将四个轮胎装载在汽车上 输出轮胎装到汽车上的哪个位置
左前轮 右前轮 左后轮 右后轮
轮胎类
成员变量 轮胎名称tireName 轮胎类型tireType 轮胎位置tirePosition*/

public class Car {
    private String carName;
    private String carColor;
    private String carPrice;
    //声明引擎类的对象,作为成员变量
    private Engine carEngine;
    //轮胎保存在车类里
    //Tire[] tires
    private Tire[] tires = new Tire[4];
    //构造方法
    public Car() {
    }
    public Car(String carName, String carColor, String carPrice, Engine carEngine) {
        this.carName = carName;
        this.carColor = carColor;
        this.carPrice = carPrice;
        this.carEngine = carEngine;
    }
    //set/get方法
    public String getCarName() {
        return carName;
    }
    public void setCarName(String carName) {
        this.carName = carName;
    }
    public String getCarColor() {
        return carColor;
    }
    public void setCarColor(String carColor) {
        this.carColor = carColor;
    }
    public String getCarPrice() {
        return carPrice;
    }
    public void setCarPrice(String carPrice) {
        this.carPrice = carPrice;
    }
    public Engine getCarEngine() {
        return carEngine;
    }
    public void setCarEngine(Engine carEngine) {
        this.carEngine = carEngine;
    }
    //轮胎数组的setget方法
    public void setTires(Tire[] tires) {
        this.tires = tires;
    }
    public Tire[] getTires() {
        return this.tires;
    }
    //需要一个装轮胎的方法,一个一个装到声明的数组中
    //tirePosition表示轮胎该装到什么位置上,相当于装到数组的哪个位置上
    public void setTire(Tire tire,int tirePosition) {
        //把轮胎按数组的位置放入数组中
        this.tires[tirePosition] = tire;
        //按照索引赋值轮胎的位置信息
        switch (tirePosition) {
        case 0:
            tire.setTirePosition("左前轮");
            break;
        case 1:
            tire.setTirePosition("右前轮");
            break;
        case 2:
            tire.setTirePosition("左后轮");
            break;
        case 3:
            tire.setTirePosition("右后轮");
            break;

        default:
            break;
        }
    }
    //介绍自己的方法
    //汽车类行为：介绍sayHi：汽车名称 汽车颜色 汽车价格 引擎名称 引擎类型
    public void sayHi() {
        System.out.println("汽车名称" + carName);
        System.out.println("汽车颜色" + carColor);
        System.out.println("汽车价格" + carPrice);
        //如果不给carEngine赋值,初值就是null,用它来调用方法就会出现空指针异常
        System.out.println("引擎名称" + carEngine.getEngineName());
        System.out.println("引擎类型" + carEngine.getEngineType());
        //遍历数组,打印每一个轮胎的属性
        for (int i = 0; i < tires.length; i++) {
            //取出每一个轮胎
            Tire tire = tires[i];
            //打印轮胎信息
            System.out.println(tire);
        }
    }
}
//引擎类
public class Engine {
    private String engineName;
    private String engineType;
    //构造方法
    public Engine() {

    }
    public Engine(String engineName, String engineType) {
        super();
        this.engineName = engineName;
        this.engineType = engineType;
    }
    //set/get方法
    public String getEngineName() {
        return engineName;
    }
    public void setEngineName(String engineName) {
        this.engineName = engineName;
    }
    public String getEngineType() {
        return engineType;
    }
    public void setEngineType(String engineType) {
        this.engineType = engineType;
    }
}
//轮胎类
public class Tire {
    private String tireName;
    private String tireType;
    private String tirePosition;
    //构造方法
    public Tire() {

    }
    //轮胎只有安装的时候才确定位置信息,所以开始不需要次参数
    public Tire(String tireName, String tireType) {
        super();
        this.tireName = tireName;
        this.tireType = tireType;
    }
    //set/get方法
    public String getTireName() {
        return tireName;
    }
    public void setTireName(String tireName) {
        this.tireName = tireName;
    }
    public String getTireType() {
        return tireType;
    }
    public void setTireType(String tireType) {
        this.tireType = tireType;
    }
    public String getTirePosition() {
        return tirePosition;
    }
    public void setTirePosition(String tirePosition) {
        this.tirePosition = tirePosition;
    }
    //
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        String str = "轮胎名字" + tireName + "轮胎类型" + tireType +"轮胎位置" + tirePosition;
        return str;
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Engine engine = new Engine("V18", "涡轮加压");
        Car car = new Car("路虎", "黑色", "50万", engine);
        //循环装轮胎
        for (int i = 0; i < 4; i++) {
            Tire tire = new Tire("米其林", "雨胎");
            //装轮胎,set方法
            car.setTire(tire, i);
        }
        //介绍自己
        car.sayHi();
    }
}