依赖倒转原则

依赖倒转原则：通俗点就是，一个类和其他的类建立关系的时候，尽可能的与它们的父类建立关系，避免与子类建立联系。在设计变量时，能用父类尽量用父类。

下面是一道经典例题，我们通过抽象出灯泡类即红灯黄灯各种灯的父类，来让它与台灯建立联系，这样，即使更换灯泡也不用再修改台灯类的代码，并且我们

将发光方法抽象出来，让他的子类各种灯泡去实现他的发光方法。

定义一个台灯类，里面有一个开灯方法。
定义一个灯泡类，该类为抽象类，定义发光的方法，它有两 个子类，红灯泡和黄灯泡。
定义一个Test类，写上主函数创建台灯对象调用开灯方法， 实现传入红灯泡打印发红光，传入黄灯泡打印发黄光。

public class  TestLight{//测试类
    public static void main(String[] args) {
        Bulb redbulb = new RedBulb();//创建一个红灯泡对象
        Bulb yellowbulb = new YellowBulb();//创建一个黄灯泡对象
        Light light = new Light();//创建一个台灯对象
        light.setLight(redbulb);//将红灯泡放进台灯里面
        light.bulbPower();//打开台灯开关
        light.setLight(yellowbulb);//将黄灯泡放进台灯里面
        light.bulbPower();//打开台灯开关
    }
    
}
class Light{//台灯
    private Bulb bulb;//灯泡属性
    public Light(){}//构造方法
    public Bulb setLight(Bulb bulb){//修改灯泡的方法
        this.bulb = bulb;
        return bulb;
    }
    public void bulbPower(){//台灯开灯方法
        bulb.shine();//调用灯泡发光
    }
}
abstract class Bulb{//灯泡抽象类
    public abstract void shine();//抽象发光方法
}
class RedBulb extends Bulb{//红灯泡继承灯泡类
    public void shine(){//实现灯泡发光方法
        System.out.println("红灯发红光");
    }
}
class YellowBulb extends Bulb{
    public void shine(){
        System.out.println("黄灯发黄光");
    }
}

定一个形状类(shape)为抽象的，有两个方法求周长和求面积 为抽象的，它有三个子类，长方形，正方形，圆形，再定义 一个Student里面有一个学习的方法，

要求在学习的方法里可 以调用任意形状的求周长和求面积的方法。

package day18;


public class  TestStudentt{//学生类
    public static void main(String[] args) {
        TestStudentt stu = new TestStudentt();//创建一个学生对象
        Shapee zfx = new Square(15.0);//创建一个正方形对象
        stu.count(zfx);
    }
    public void count(Shapee shape){//开始计算 此处有多态 Shapee shape = new Square(15);
        System.out.println("周长是"+shape.zhouChang());//调用求周长方法并且输出
        System.out.println("面积是"+shape.mianJi());//调用求面积方法并输出
    }
}
abstract class Shapee{//抽象类形状类
    public abstract double zhouChang();
    public abstract double mianJi();
}
class Square extends Shapee{//正方形类继承形状类
    private double bianChang;//成员变量边长
    public Square(){}//无参构造方法
    public Square(double bianChang){//有参构造方法
        this.bianChang = bianChang;
    }
    public double getBianChang(){//get方法
        return bianChang;
    }
    public double setBianChang(double bianChang){//方法
        this.bianChang = bianChang;
        return bianChang;
    }
    public double zhouChang(){//求周长方法
        double result = 4 * bianChang;
        return result;
    }
    public double mianJi(){//求面积方法
        double result = bianChang * bianChang;
        return result;
    }
}
class Cycle extends Shapee{//圆形类继承形状类
    private double banJin;
    public Cycle(){}
    public Cycle(double banJin){
        this.banJin = banJin;
    }
    public double getBanJin(){
        return banJin;
    }
    public double setBanJin(double banJin){
        this.banJin = banJin;
        return banJin;
    }
    public double zhouChang(){
        double result = 3.14 * 2 * banJin;
        return result;
    }
    public double mianJi(){
        double result = 3.14 * banJin * banJin;
        return result;
    }
}
class Rectanglee extends Shapee{//长方形类
    private double chang;
    private double kuan;
    public Rectanglee(){}
    public Rectanglee(double chang,double kuan){
        this.chang = chang;
        this.kuan = kuan;
    }
    public double getChang(){
        return chang;
    }
    public double setChang(double chang){
        this.chang = chang;
        return chang;
    }
    public double getKuan(){
        return kuan;
    }
    public double setKuan(double kaun){
        this.kuan = kuan;
        return kuan;
    }
    public double zhouChang(){
        double result = (chang + kuan) * 2;
        return result;
    }
    public double mianJi(){
        double result = chang * kuan;
        return result;
    }

}