接口
请使用代码描述:
奥迪车(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{
//覆盖重写抽象方法
//4.定义一个子类(实现类)AirConditioning(空调),继承家用电器类的同时实现插座接口,重写抽象方法
public class AirConditioning extends Appliance implements Sockets{
//覆盖重写抽象方法
/*
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()方法
//3.定义一个实现类Banana(香蕉类),实现Fruit接口
public class Banana implements Fruit{
//重写toJuice()方法
//4.定义一个实现类Mango(芒果类),实现Fruit接口
public class Mango implements Fruit{
//重写toJuice()方法
//5.定义一个实现类Orange(橙子类),实现Fruit接口
public class Orange implements Fruit{
//重写toJuice()方法
//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);
}
}
浙公网安备 33010602011771号