北京坐飞机怎么去黑龙江北安市？

Posted 2023-04-15

从北京到黑龙江北安市，您可以选择以下几种方式：
1. 坐飞机：从北京首都国际机场或北京大兴国际机场乘坐飞往黑龙江哈尔滨的航班，然后在哈尔滨太平国际机场转乘前往北安市的航班。
2. 坐火车：从北京乘坐火车前往黑龙江哈尔滨，然后在哈尔滨火车站转乘前往北安市的火车。
3. 自驾车：从北京出发，沿京哈高速公路一路向东行驶，经过长春、哈尔滨等城市，最终到达北安市。
无论您选择哪种方式，建议提前做好行程规划和准备，以确保旅途顺利。 参考技术A

从北京出发前往黑龙江北安市，您可以选择以下几种交通方式：

飞机：您可以在北京首都国际机场或北京大兴国际机场乘坐航班前往哈尔滨太平国际机场，然后在机场转乘火车或者大巴前往黑龙江北安市。哈尔滨到北安市的火车和大巴都有，车程约为4-5小时。

火车：您可以在北京火车站或北京西站乘坐火车前往哈尔滨站，然后在哈尔滨站转乘前往北安市的火车。哈尔滨到北安市的火车有多趟，车程约为4-5小时。

自驾车：您可以在北京租车自驾前往黑龙江北安市，路线可以选择京哈高速公路-绥芬河市-北安市，全程约2200公里，需要约28小时左右。需要注意的是，冬季道路比较难行驶，需要注意安全。

长途客车：您可以在北京的汽车站或者长途客运站乘坐长途客车前往黑龙江北安市，路程约为40小时左右，需要耐心等待。

总之，您可以根据个人需要和实际情况选择合适的交通方式前往黑龙江北安市。

参考技术B

如果您在北京，想要前往黑龙江北安市，可以选择以下的交通方式：

飞机：从北京首都国际机场乘坐飞往黑龙江的航班，到达哈尔滨机场后，再转乘飞往北安的航班，最终到达目的地。飞行时间大约在4-5小时左右，比较快捷方便。

高铁：从北京南站或北京西站乘坐高铁到达哈尔滨站，再从哈尔滨站转乘火车或大巴到达北安市。全程需要约13-14个小时，但是价格相对比较经济。

自驾或包车：如果您有自己的车辆或者可以包车前往，也是一个不错的选择。从北京出发，经过京哈高速、哈尔滨绕城高速、鹤北高速等，然后进入黑龙江省北安市。

需要注意的是，以上交通方式都需要提前做好规划和预订，特别是飞机和火车票需要提前预订以确保顺利出行。同时，出行前最好了解相关的交通规划和路线，以确保安全和顺利到达目的地。

参考技术C 北京坐飞机怎么去黑龙江北安市 中国城市距离
» 北京直辖市北京市 » 黑龙江省北安市

从北京直辖市北京市到黑龙江省北安市的距离
从北京市到北安市的直线(飞行路线)距离为1227公里(763英里或663海里)。

1227公里 763英里 663海里
表 1. 从北京市到北安市的航空距离以及飞行时间
航空距离 飞行速度 行程时间
1227 公里 900公里/小时 1 小时 21 分
1227 公里 700公里/小时 1 小时 45 分
1227 公里 500公里/小时 2 小时 27 分
注释: 从北京市到北安市的地理中心之间的直线距离是用数学公式计算所得 [参考资料]。 典型的长途客运商业航班巡航飞行速度约为900公里/小时。
表 2. 比较开车驾驶1227公里对不同耗油汽车的燃料成本
耗油量 开车里程(公里) 汽油费
12升/每100公里 1227 公里 ¥2380
10升/每100公里 1227 公里 ¥1190
8升/每100公里 1227 公里 ¥793
6升/每100公里 1227 公里 ¥595
4升/每100公里 1227 公里 ¥476
2升/每100公里 1227 公里 ¥397
注释: 计算燃料成本时我们用的汽油价格为每升9.7人民币(元)。 请注意从北京市开车到北安市的驾驶距离比直线距离长。

Map here
+
−
500 km
300 mi
Leaflet | OpenStreetMap contributors

表 3. 从北京直辖市北京市到附近城市的距离
北京直辖市北京市 — 北京直辖市大兴区 18公里
北京直辖市北京市 — 北京直辖市通州区 24公里
北京直辖市北京市 — 北京直辖市房山区 29公里
北京直辖市北京市 — 北京直辖市顺义区 32公里
北京直辖市北京市 — 北京直辖市昌平区 37公里
表4. 从黑龙江省北安市到附近城市的距离
黑龙江省北安市 — 黑龙江省克东县 30公里
黑龙江省北安市 — 黑龙江省海伦市 93公里
黑龙江省北安市 — 黑龙江省嫩江县 140公里
黑龙江省北安市 — 黑龙江省孙吴县 144公里
黑龙江省北安市 — 黑龙江省富裕县 160公里
注: 表中的距离是直线距离。

简说设计模式——策略模式

一、什么是策略模式

　　策略这个词应该怎么理解，打个比方说，我们出门的时候会选择不同的出行方式，比如骑自行车、坐公交、坐火车、坐飞机、坐火箭等等，这些出行方式，每一种都是一个策略。

　　再比如我们去逛商场，商场现在正在搞活动，有打折的、有满减的、有返利的等等，其实不管商场如何进行促销，说到底都是一些算法，这些算法本身只是一种策略，并且这些算法是随时都可能互相替换的，比如针对同一件商品，今天打八折、明天满100减30，这些策略间是可以互换的。

　　策略模式（Strategy），定义了一组算法，将每个算法都封装起来，并且使它们之间可以互换。UML结构图如下：

　　其中，Context是上下文，用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用；Strategy是策略类，用于定义所有支持算法的公共接口；ConcreteStrategy是具体策略类，封装了具体的算法或行为，继承于Strategy。

　　1. Context上下文

　　Context上下文角色，也叫Context封装角色，起承上启下的作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。

 1 public class Context {
 2     
 3     Strategy strategy;
 4     
 5     public Context(Strategy strategy) {
 6         this.strategy = strategy;
 7     }
 8     
 9     //上下文接口
10     public void contextInterface() {
11         strategy.algorithmInterface();
12     }
13 
14 }

　　2. 策略角色

　　抽象策略角色，是对策略、算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属性。algorithm是“运算法则”的意思。

1 public abstract class Strategy {
2     
3     //算法方法
4     public abstract void algorithmInterface();
5 
6 }

　　3. 具体策略角色

　　用于实现抽象策略中的操作，即实现具体的算法，下方用print代替。测试类共3个ConcreteStrategy，其它两个类与ConcreteStrategyA同理，就不再赘述了。

1 public class ConcreteStrategyA extends Strategy {
2 
3     @Override
4     public void algorithmInterface() {
5         System.out.println("算法A实现");
6     }
7 
8 }

　　4. Client客户端

　　下面依次更换策略，测试一下策略模式。

 1 public class Client {
 2     
 3     public static void main(String[] args) {
 4         Context context;
 5         
 6         context = new Context(new ConcreteStrategyA());
 7         context.contextInterface();
 8         
 9         context = new Context(new ConcreteStrategyB());
10         context.contextInterface();
11         
12         context = new Context(new ConcreteStrategyC());
13         context.contextInterface();
14     }
15 
16 }

　　运行结果如下：

　　

二、策略模式的应用

　　1. 何时使用

• 一个系统有许多类，而区分它们的只是他们直接的行为时

　　2. 方法

• 将这些算法封装成一个一个的类，任意的替换

　　3. 优点

• 算法可以自由切换
• 避免使用多重条件判断（如果不用策略模式我们可能会使用多重条件语句，不利于维护）
• 扩展性良好，增加一个策略只需实现接口即可

　　4. 缺点

• 策略类数量会增多，每个策略都是一个类，复用的可能性很小
• 所有的策略类都需要对外暴露

　　5. 使用场景

• 多个类只有算法或行为上稍有不同的场景
• 算法需要自由切换的场景
• 需要屏蔽算法规则的场景

　　6. 应用实例

• 出行方式，自行车、汽车等，每一种出行方式都是一个策略
• 商场促销方式，打折、满减等
• Java AWT中的LayoutManager，即布局管理器

　　7. 注意事项

• 如果一个系统的策略多于四个，就需要考虑使用混合模式来解决策略类膨胀的问题

三、策略模式的实现

　　下面就以商场促销为例使用策略模式实现商场促销算法。UML图如下：

　　1. 上下文类

　　首先声明一个CashSuper对象，通过构造方法，传入具体的收费策略，getResult()方法的功能为根据收费策略的不同获得计算结果。

 1 public class CashContext {
 2     
 3     private CashSuper cashSuper;
 4     
 5     public CashContext(CashSuper cashSuper) {
 6         this.cashSuper = cashSuper;
 7     }
 8     
 9     public double getResult(double money) {
10         return cashSuper.acceptCash(money);
11     }
12 
13 }

　　2. 现金收费抽象类

　　策略类，为抽象类，抽象出收费的方法供子类实现。

1 public abstract class CashSuper {
2     
3     public abstract double acceptCash(double money);
4 
5 }

　　3. 正常收费子类

　　没有任何活动的情况，正常收费，返回原价。

1 public class CashNormal extends CashSuper {
2 
3     @Override
4     public double acceptCash(double money) {
5         return money;
6     }
7 
8 }

　　4. 打折收费子类

　　打折活动，根据折扣返回打折后的价格。

 1 public class CashRebate extends CashSuper {
 2     
 3     private double moneyRebate = 1;    //折扣
 4     
 5     public CashRebate(double moneyRebate) {
 6         this.moneyRebate = moneyRebate;
 7     }
 8 
 9     @Override
10     public double acceptCash(double money) {
11         return money * moneyRebate;
12     }
13 
14 }

　　5. 返利收费子类

　　返利活动，输入返利条件和返利值，比如满300返100，moneyCoditation为300，moneyReturn为100。

　　 result = money - Math.floor(money / moneyConditation) * moneyReturn; 的意思为，如果当前金额大于等于返利条件，则使用当前金额减去返利值。

 1 public class CashReturn extends CashSuper {
 2 
 3     private double moneyConditation = 0.0;    //返利条件
 4     private double moneyReturn = 0.0d;    //返利值
 5     
 6     public CashReturn(double moneyConditation, double moneyReturn) {
 7         this.moneyConditation = moneyConditation;
 8         this.moneyReturn = moneyReturn;
 9     }
10 
11     @Override
12     public double acceptCash(double money) {
13         double result = money;
14         
15         if (money >= moneyConditation) {
16             result = money - Math.floor(money / moneyConditation) * moneyReturn;
17         }
18         
19         return result;
20     }
21 
22 }

　　6. Client客户端

　　下面写一个简单的程序测试一下上方编写的代码。

 1 public class Client {
 2     
 3     public static void main(String[] args) {
 4         CashContext cashContext = null;
 5         
 6         Scanner scanner = new Scanner(System.in);
 7         System.out.print("请输入打折方式（1/2/3）：");
 8         int in = scanner.nextInt();
 9         String type = "";
10         
11         switch (in) {
12             case 1:
13                 cashContext = new CashContext(new CashNormal());
14                 type += "正常收费";
15                 break;
16                 
17             case 2:
18                 cashContext = new CashContext(new CashReturn(300, 100));
19                 type += "满300返100";
20                 break;
21                 
22             case 3:
23                 cashContext = new CashContext(new CashRebate(0.8));
24                 type += "打8折";
25                 break;
26     
27             default:
28                 System.out.println("请输入1/2/3");
29                 break;
30         }
31         
32         double totalPrices = 0;
33         
34         System.out.print("请输入单价：");
35         double price = scanner.nextDouble();
36         System.out.print("请输入数量：");
37         double num = scanner.nextDouble();
38         totalPrices = cashContext.getResult(price * num);
39         
40         System.out.println("单价：" + price + "，数量：" + num + "，类型：" + type + "，合计：" + totalPrices);
41         
42         scanner.close();
43     }
44 
45 }

　　正常收费结果如下：

　　

　　返利收费结果如下：

　　

　　打折收费结果如下：

　　

 

 

 

 

 

此篇引用自：https://www.cnblogs.com/adamjwh/p/11011095.html