第十周总结
1.知识总结
1.对于抽象类和抽象方法来说，抽象类不一定包含抽象方法，但是抽象方法一定在抽象类里面。
2.接口是一个特殊的类，编译成功之后形成的还是calss文件。相对于抽象类来说，它是100%的抽象类，即接口里面的方法都是抽象方法。
3.接口里面的方法不一定都没有方法体，当方法被static，default修饰的时候，方法是可以有方法体的。static修饰的方法是加载在方法区的，受接口的影响不大。
4.实现某个接口一定要重写接口中所有的抽象方法。
5.接口中的方法默认的修饰符为public abstract
6.接口没有构造方法，很容易理解，接口只能定义常量不能定义变量，而且实现接口的类必须重写它所有的方法，所以通过构造方法构造特征是没必要的，因为特征已经形成了。
7.抽象类带来了面向抽象编程：多态（父类型引用指向子类型对象）
2.简单工厂模式
通俗地理解简单工厂模式就是，当客户需要某个商品的时候，客户只负责根据自己的需求点，工厂只负责制作。
假如要写一个制作汽车的工厂
先写一个汽车接口，创建一个汽车的基本模型，然后让工厂来根据客户需求具体实现
package factory.EasyF;
public interface Car
{
void Run();
void buy();
void maintain();
}
实现接口，创建不同需求下的类
package factory.EasyF;
public class HongQi implements Car
{
public void Run()
{
S("红旗试跑！！");
}
public void buy()
{
S("已购买红旗！！");
}
public void maintain()
{
S("红旗维修中！！");
}
public static void S(String s )
{
System.out.println(s);
}
}
package factory.EasyF;
public class Lamborghini implements Car
{
public void Run()
{
S("兰博基尼试跑！！");
}
public void buy()
{
S("已购买兰博基尼！！");
}
public void maintain()
{
S("兰博基尼维修中！！");
}
public static void S(String s )
{
System.out.println(s);
}
}
package factory.EasyF;
import factory.EasyF.Car;
public class WuLin implements Car
{
public void Run()
{
S("五菱宏光试跑！！");
}
public void buy()
{
S("已购买五菱宏光！！");
}
public void maintain()
{
S("五菱宏光维修中！！");
}
public static void S(String s )
{
System.out.println(s);
}
}
再写一个工厂类
package factory.EasyF;
public class Factory
{
public static Car getCarName(String name)
{
if(name.equals("兰博基尼"))//判断语句，判断客户需求
{
return new Lamborghini();//返回实例化对象
}
else if(name.equals("五菱宏光"))
{
return new WuLin();
}
else if(name.equals("红旗"))
{
return new HongQi();
}
else
{
System.out.println("不能生产该车辆！！");
}
return null;
}
}
这样一个简单的工厂就实现了，然后测试一下
package factory.EasyF;
import factory.EasyF.Factory;
import java.util.Scanner;
public class run
{
public static void main(String[] args)
{
String name;
Car c = null;//父类型引用，指向子类型对象
int num=0,zl = 100;
Factory f = new Factory();//创建工厂对象
Scanner in = new Scanner(System.in);
System.out.println("请输入你要进行的操作:1-买车，2-维修车，3-试驾,100-退出");
zl = in.nextInt();
while(zl != 100)
{
if(zl == 1)
{
System.out.println("请输入要购买的车辆");
name = in.next();
c = f.getCarName(name);
}
else if(zl == 2)
{
if(c == null)
{
System.out.println("未拥有车辆！！");
}
else
{
c.maintain();
}
}
else if(zl == 3)
{
if(c == null)
{
System.out.println("未拥有车辆！！");
}
else
{
c.Run();
}
}
System.out.println("请输入你要进行的操作:1-买车，2-维修车，3-试驾,100-退出");
zl = in.nextInt();
}
}
}
3.抽象工厂
其实抽象工厂和简单工厂很相似，就是抽象工厂可以创建多个简单工厂，再次拿生产汽车来说。宝马和本田都生产汽车和机车。那么就需要多个工厂，但是假如我有无数个相似功能的工厂，简单工厂的方式的调用就十分的不方便，所以还是运用多态机制，利用父类型引用指向子类型对象的特点。
先构建出工厂的基本特征，创建一个工厂接口
package factory.abF;
public interface abFactory
{
car carProduct();//基本的生产汽车和摩托
mBike mBikeProduct();
}
然后就是简单工厂的基本流程
先创建汽车接口和摩托接口
package factory.abF;
public interface car
{
void Run();
void buy();
void maintain();
}
package factory.abF;
public interface mBike
{
void Run();
void buy();
void maintain();
}
实现汽车和摩托接口
package factory.abF;
public class BmwCar implements car
{
public void Run()
{
System.out.println("宝马汽车试跑中！！！");
}
public void buy()
{
System.out.println("已购买宝马汽车！！！");
}
public void maintain()
{
System.out.println("宝马汽车正在维修中！！！");
}
}
package factory.abF;
public class BMWMBike implements mBike
{
public void Run()
{
System.out.println("宝马机车试跑中！！！");
}
public void buy()
{
System.out.println("已购买宝马机车！！！");
}
public void maintain()
{
System.out.println("宝马机车正在维修中！！！");
}
}
package factory.abF;
public class HondaCar implements car
{
public void Run()
{
System.out.println("本田汽车试跑中！！！");
}
public void buy()
{
System.out.println("已购买本田汽车！！！");
}
public void maintain()
{
System.out.println("本田汽车正在维修中！！！");
}
}
package factory.abF;
public class HondaMBike implements mBike
{
public void Run()
{
System.out.println("本田机车试跑中！！！");
}
public void buy()
{
System.out.println("已购买本田机车！！！");
}
public void maintain()
{
System.out.println("本田机车正在维修中！！！");
}
}
再创建具体品牌的工厂，实现工厂接口，返回实例化对象
package factory.abF;
public class HondaFactory implements abFactory//本田工厂
{
public car carProduct()
{
return new HondaCar();
}
public mBike mBikeProduct()
{
return new HondaMBike();
}
}
package factory.abF;
public class BMWFactory implements abFactory//宝马工厂
{
public car carProduct()
{
return new BmwCar();
}
public mBike mBikeProduct()
{
return new BMWMBike();
}
}
最后再简单的测试实现一下
package factory.abF;
import java.util.Scanner;
public class run
{
public static void main(String[] args)
{
car c = null;
mBike m = null;
int num=100,zl=100000;
abFactory h = new HondaFactory();
abFactory b = new BMWFactory();
Scanner in = new Scanner(System.in);
while(zl != 100)
{
while(num!=1&&num!=2)
{
System.out.println("请输入你要进行操作的种类：1-汽车，2-机车");
num = in.nextInt();
}
System.out.println("请输入你要进行购买的品牌：1-本田，2-宝马，100-退出");
zl = in.nextInt();
if(zl == 1)
{
if(num == 1)
{
c = h.carProduct();
c.buy();
}
else
{
m = h.mBikeProduct();
m.buy();
}
}
if(zl == 2)
{
if (num == 1) {
c = b.carProduct();
c.buy();
}
else
{
m = b.mBikeProduct();
m.buy();
}
}
if(zl==4)
{
if(num == 1)
c.maintain();
else
m.maintain();
}
if(zl == 5)
{
if(num == 1)
c.Run();
else
m.Run();
}
if(zl == 3)
{
System.out.println("请输入你要进行购买的品牌：1-本田，2-宝马，100-退出");
zl = in.nextInt();
continue;
}
System.out.println("请输入你要进行的操作:3-买车，4-维修车，5-试驾,100-退出");
zl = in.nextInt();
}
}
}
扫一扫
42
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
