请使用代码描述:    
   奥迪车(Audi)都具有跑的功能，但是智能奥迪车(SmartAudi)除了具有跑的功能外，还具有自动泊车(automaticParking)和无人驾驶(automaticDrive)的功能！
 
   要求:使用多态形式创建对象

1.定义奥迪车为父类,定义跑的方法
2.定义只能奥迪车,继承父类,定义两个自动泊车和无人驾驶的特有方法
3.利用多态创建对象,利用向下转型调用特有方法

操作步骤

1.定义奥迪车类(Audi),定义一个跑的方法(run)
2.定义一个智能奥迪车类(SmartAudi),继承父类,然后定义两个方法
  自动泊车方法(automaticParking)无人驾驶的方法         (automaticDrive)
3.定义一个测试类,使用多态形式创建对象,调用从父类继承过来的run方法
  向下转型之后,调用子类特有的自动泊车方法和无人驾驶方法

//定义一个Audi父类
public class Audi {
    //定义一个跑的方法
    public void run(){
        System.out.println("车跑了");
    }
}

//定义一个智能奥迪车类(SmartAudi)继承父类,然后定义两个方法
//  自动泊车方法(automaticParking)无人驾驶的方法(automaticDrive)
public class SmartAudi extends Audi{
    //然后定义两个方法自动泊车方法(automaticParking)无人驾驶的方法(automaticDrive)
    public void automaticParking(){
        System.out.println("我会自动泊车");
    }
​
    public void automaticDrive(){
        System.out.println("我会无人驾驶");
    }
​
}

//定义一个测试类,使用多态形式创建对象,调用从父类继承过来的run方法
//  向下转型之后,调用子类特有的自动泊车方法和无人驾驶方法
public class Test {
    public static void main(String[] args) {
        //利用多态形式创建对象
        Audi audi = new SmartAudi();
        //调用从父类中继承过来的方法
        audi.run();
        //向下转型,调用子类特有的方法
        SmartAudi smartAudi=(SmartAudi)audi;
        smartAudi.automaticDrive();
        smartAudi.automaticParking();
​
    }
}

请使用代码描述:  
    我们平时的家用电器,都需要通电,然后开启,或者关闭,而且每个家用电器都有自己特殊的功能,比如:
电视,除了通电之后的开启和关闭,还有播放电视剧的功能
空调,除了通电之后的开启和关闭,还有制冷的功能
​
要求:将电视和空调的抽取出来

1.由于电视和空调都有开启和关闭的功能,所以我们可以抽取出来一个父类,在父类中定义开启和关闭功能
  开启和关闭功能可以定义成抽象方法
2.由于电视和空调只有插在插座上,才能通电,正常使用,所以我们可以定义一个插座的接口,在接口中定义通电的功能
3.由于电视和空调都要插在插座上,以及通电之后开启和关闭,所以需要继承父类的同时实现插座的接口,重写所有的抽象方法
4.创建电视和空调对象,调用重写的方法

操作步骤

1.定义一个父类Appliance(家用电器),定义两个抽象方法-->开启(open())和关闭(close())
2.定义一个接口Sockets(插座),定义一个抽象方法-->通电(tongDian())
3.定义一个子类(实现类)TV(电视),继承家用电器类的同时实现插座接口,重写抽象方法
4.定义一个子类(实现类)AirConditioning(空调),继承家用电器类的同时实现插座接口,重写抽象方法
5.定义测试类,创建两个子类的对象,调用重写的方法

//1.定义一个父类Appliance(家用电器)
public abstract class Appliance {
    //定义两个抽象方法-->开启(open())和关闭(close())
    public abstract void open();
    public abstract void close();
}
​

//2.定义一个接口Sockets(插座)
public interface Sockets {
    //定义一个抽象方法-->通电(tongDian())
    public abstract void tongDian();
}

//3.定义一个子类(实现类)TV(电视),继承家用电器类的同时实现插座接口
public class TV extends Appliance implements Sockets{
    //覆盖重写抽象方法
​
    @Override
    public void open() {
        System.out.println("电视机打开了");
​
    }
​
    @Override
    public void close() {
        System.out.println("电视机关闭了");
​
    }
​
    @Override
    public void tongDian() {
        System.out.println("电视通电了");
​
    }
    ////特有方法
    public void lookTv(){
        System.out.println("看电视剧!");
    }
}

//4.定义一个子类(实现类)AirConditioning(空调),继承家用电器类的同时实现插座接口,重写抽象方法
public class AirConditioning extends Appliance implements Sockets{
    //覆盖重写抽象方法
    @Override
    public void open() {
        System.out.println("空调打开了!");
    }
​
    @Override
    public void close() {
        System.out.println("空调关闭了!");
​
    }
​
    @Override
    public void tongDian() {
        System.out.println("空调通电了!");
    }
    //特有方法
    public void refrigeration(){
        System.out.println("空调制冷了!");
    }
}

/*
1.由于电视和空调都有开启和关闭的功能,所以我们可以抽取出来一个父类,在父类中定义开启和关闭功能
  开启和关闭功能可以定义成抽象方法
2.由于电视和空调只有插在插座上,才能通电,正常使用,所以我们可以定义一个插座的接口,在接口中定义通电的功能
3.由于电视和空调都要插在插座上,以及通电之后开启和关闭,所以需要继承父类的同时实现插座的接口,重写所有的抽象方法
4.创建电视和空调对象,调用重写的方法
 */
/*
1.定义一个父类Appliance(家用电器),定义两个抽象方法-->开启(open())和关闭(close())
2.定义一个接口Sockets(插座),定义一个抽象方法-->通电(tongDian())
3.定义一个子类(实现类)TV(电视),继承家用电器类的同时实现插座接口,重写抽象方法
4.定义一个子类(实现类)AirConditioning(空调),继承家用电器类的同时实现插座接口,重写抽象方法
5.定义测试类,创建两个子类的对象,调用重写的方法
5.定义测试类,创建两个子类的对象,调用重写的方法
 */
public class Test {
    public static void main(String[] args) {
        //创建TV对象
        TV tv = new TV();
        //调用TV重写的方法
        tv.tongDian();
        tv.open();
        tv.close();
        tv.lookTv();
        System.out.println("---------------");
        //创建空调对象
        AirConditioning airConditioning = new AirConditioning();
        airConditioning.tongDian();
        airConditioning.close();
        airConditioning.open();
        airConditioning.refrigeration();
​
​
    }
}
​

水果都能被榨成汁,在现实生活中,我们需要一个榨汁机,往榨汁机中的装什么水果就被榨成什么果汁,请根据描述设计一个程序

1.所有的水果都能变成果汁,所以我们需要抽取出一个水果类或者接口,然后再水果类或者接口中定义一个变成果汁的方法
2.然后定义具体的水果类或者实现类,去实现或者继承水果类或者接口.重写变成水果的方法
3.定义一个榨汁机类,定义一个榨汁方法
  因为,我们将来调用榨汁的方法,指定什么水果就让该水果变成果汁儿,所以为了代码的扩展性,我们可以在榨汁方法的参数位置传递水果类或者接口引用,调用榨汁方法的时候传递具体水果的对象,就调用水果类或者实现类重写的变成果汁儿的方法
4.定义一个实现类,创建榨汁机对象,创建具体水果对象,调用榨汁方法,传递具体的水果类(实现类)对象

操作步骤

1.定义一个接口Fruit(水果接口),其中定义一个toJuice()(变成果汁方法)
2.定义一个实现类Apple(苹果类),实现Fruit接口重写toJuice()方法,输出内容为"苹果变成苹果汁儿"
3.定义一个实现类Banana(香蕉类),实现Fruit接口重写toJuice()方法,输出内容为"香蕉变成香蕉牛奶汁儿"
4.定义一个实现类Mango(芒果类),实现Fruit接口重写toJuice()方法,输出内容为"芒果变成芒果汁儿"
5.定义一个实现类Orange(橙子类),实现Fruit接口重写toJuice()方法,输出内容为"橙子变成橙汁儿"
6.定义一个类ZhaZhiJi(榨汁机类),定义zhaZhi方法,将来在榨汁机中的传递什么水果,就榨成什么汁儿
  所以调用zhaZhi方法传递Fruit接口类型,方法体直接调用toJuice()方法,此处为多态,传递那个水果对象
  
  

//1.定义一个接口Fruit(水果接口)其中定义一个toJuice()(变成果汁方法)
public interface Fruit {
    //其中定义一个toJuice()(变成果汁方法)
    public void toJuice();
}
​

//2.定义一个实现类Apple(苹果类),实现Fruit接口
public class Apple implements Fruit{
    //重写toJuice()方法
    @Override
    public void toJuice() {
        //输出内容为"苹果变成苹果汁儿"
        System.out.println("苹果变成苹果汁儿");
​
    }
}
​

//3.定义一个实现类Banana(香蕉类),实现Fruit接口
public class Banana implements Fruit{
    //重写toJuice()方法
    @Override
    public void toJuice() {
        //输出内容为"香蕉变成香蕉牛奶汁儿"
        System.out.println("香蕉变成香蕉牛奶汁儿");
    }
}
​

//4.定义一个实现类Mango(芒果类),实现Fruit接口
public class Mango implements Fruit{
    //重写toJuice()方法
    @Override
    public void toJuice() {
        //输出内容为"芒果变成芒果汁儿"
        System.out.println("芒果变成芒果汁儿");
    }
}
​

//5.定义一个实现类Orange(橙子类),实现Fruit接口
public class Orange implements Fruit{
    //重写toJuice()方法
    @Override
    public void toJuice() {
        //输出内容为"橙子变成橙汁儿"
        System.out.println("橙子变成橙汁儿");
    }
}
​

//6.定义一个类ZhaZhiJi(榨汁机类),定义zhaZhi方法,将来在榨汁机中的传递什么水果,就榨成什么汁儿
// 参数传递接口类型或者父类类型,可以接收任何传递过来的子类对象,此处是多态,传递那个水果对象
//Fruit就指向那个水果对象,就会调用那个水果对象重写后的方法
public class ZhaZhIJi {
    public void zhaZhi(Fruit f){
        System.out.println(" 榨汁机开始运行....");
        f.toJuice();
    }
}
​

//测试类

    public static void main(String[] args) {
        //创建榨汁机的对象
        ZhaZhiJi zhaZhiJi = new ZhaZhiJi();
​
        //创建苹果的对象
        Apple apple = new Apple();
        //创建香蕉的对象
        Banana banana = new Banana();
        //创建芒果的对象
        Mango mango = new Mango();
        //创建橘子的对象
        Orange orange = new Orange();
​
        //调用榨汁机的榨汁方法完成榨汁
        zhaZhiJi.zhaZhi(apple);
        zhaZhiJi.zhaZhi(banana);
        zhaZhiJi.zhaZhi(mango);
        zhaZhiJi.zhaZhi(orange);
    }
}