Solid Edge包含几个子装配的装配剖视图做自动明细表,只显示2个零件标号为啥?

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Solid Edge包含几个子装配的装配剖视图做自动明细表,只显示2个零件标号为啥?相关的知识,希望对你有一定的参考价值。

剖视图A-A怎么只有2和11啊,

参考技术A 明细表属性里面把子装配作为一个零件处理了。 参考技术B 回复 solidedge 的帖子我也是这样做的啊,难道和模板有关吗 参考技术C 就是大有茗堂版主说的,明细表里属性设置的事吧,我这里只能GIF演示了一下了,因为我这是英文测试版,我也不记得中文界面是怎么翻译的了! 参考技术D 回复 solidedge 的帖子呵呵,版主厉害啊,我们什么时候能用上ST4啊

Java设计模式学习笔记,三:建造者模式

建造者模式:实现了构建和装配的解耦,即对象的各个子组件单独构建,再进行装配,从而建造完整对象。

该模式适用于构建较为复杂的对象(多个子组件)。

不同的构建者,使用相同的装配者,可以建造不同的对象实例。相同的构建者,不同的装配顺序,也可能建造出不同的对象实例。

举例:

  汽车对象,子组件包括引擎、轮子和车体。

  Audi汽车构建者,负责制造Audi牌各个子组件。BMW汽车构建者,负责制造BMW牌各个子组件。然后将子组件统一送至汽车装配者的生产线中进行组装,最后会建造出Audi牌汽车和BMW汽车。

以下代码实现:

  首先,定义汽车类,及其子组件类。

  1 package com.corey.builder;
  2 
  3 /**
  4  * 汽车类---产品类
  5  * @author Corey
  6  *
  7  */
  8 public class Car {
  9     private Engine engine;
 10     private Wheel wheel;
 11     private CarBody body;
 12     
 13     public Engine getEngine() {
 14         return engine;
 15     }
 16     public void setEngine(Engine engine) {
 17         this.engine = engine;
 18     }
 19     public Wheel getWheel() {
 20         return wheel;
 21     }
 22     public void setWheel(Wheel wheel) {
 23         this.wheel = wheel;
 24     }
 25     public CarBody getBody() {
 26         return body;
 27     }
 28     public void setBody(CarBody body) {
 29         this.body = body;
 30     }
 31     
 32     public void Run(){
 33         System.out.println("启动汽车,开始行程!");
 34     }
 35     
 36     
 37 }
 38 
 39 /**
 40  * 发动机类
 41  * @author Corey
 42  *
 43  */
 44 class Engine {
 45     private String name;
 46 
 47     public Engine(String name) {
 48         super();
 49         this.name = name;
 50     }
 51 
 52     public String getName() {
 53         return name;
 54     }
 55 
 56     public void setName(String name) {
 57         this.name = name;
 58     }
 59     
 60 }
 61 
 62 /**
 63  * 车轮类
 64  * @author Corey
 65  *
 66  */
 67 class Wheel {
 68     private String name;
 69 
 70     public Wheel(String name) {
 71         super();
 72         this.name = name;
 73     }
 74 
 75     public String getName() {
 76         return name;
 77     }
 78 
 79     public void setName(String name) {
 80         this.name = name;
 81     }
 82     
 83 }
 84 
 85 /**
 86  * 车体类
 87  * @author Corey
 88  *
 89  */
 90 class CarBody {
 91     private String name;
 92 
 93     public CarBody(String name) {
 94         super();
 95         this.name = name;
 96     }
 97 
 98     public String getName() {
 99         return name;
100     }
101 
102     public void setName(String name) {
103         this.name = name;
104     }
105     
106 }

  然后,定义汽车制造者接口。

 1 package com.corey.builder;
 2 
 3 /**
 4  * 汽车制造者接口
 5  * @author Corey
 6  *
 7  */
 8 public interface CarBuilder {
 9     
10     String getBrand();
11     Engine buildEngine();
12     Wheel buildWheel();
13     CarBody buildCarBody();
14     
15     
16 }

  分别实现Audi汽车制造者类和BMW汽车制造者类。

 1 package com.corey.builder;
 2 
 3 /**
 4  * 奥迪汽车建造者---接口实现类
 5  * @author Corey
 6  *
 7  */
 8 public class AudiCarBuidler implements CarBuilder{
 9     
10 
11 
12     @Override
13     public Engine buildEngine() {
14         System.out.println("建造奥迪发动机!");
15         return new Engine("Audi发动机");
16     }
17 
18     @Override
19     public Wheel buildWheel() {
20         System.out.println("建造奥迪车轮!");
21         return new Wheel("Audi车轮");
22     }
23 
24     @Override
25     public CarBody buildCarBody() {
26         System.out.println("建造奥迪车体!");
27         return new CarBody("Audi车体");
28     }
29 
30     @Override
31     public String getBrand() {
32         return "Audi";
33     }
34 
35 }
 1 package com.corey.builder;
 2 
 3 public class BMWCarBuilder implements CarBuilder{
 4 
 5     @Override
 6     public String getBrand() {
 7         return "BMW";
 8     }
 9 
10     @Override
11     public Engine buildEngine() {
12         System.out.println("建造宝马发动机!");
13         return new Engine("BMW发动机");
14     }
15 
16     @Override
17     public Wheel buildWheel() {
18         System.out.println("建造宝马车轮!");
19         return new Wheel("BMW车轮");
20     }
21 
22     @Override
23     public CarBody buildCarBody() {
24         System.out.println("建造宝马车体!");
25         return new CarBody("BMW车体");
26     }
27 
28 }

  定义汽车装配者类。

package com.corey.builder;

/**
 * 奥迪汽车组装者--接口实现类
 * @author Corey
 *
 */
public class CarDirector{

    private CarBuilder builder;
    
    public CarDirector(CarBuilder builder) {
        super();
        this.builder = builder;
    }

    public Car directCar() {
        Car car = new Car();
        car.setEngine(builder.buildEngine());
        car.setWheel(builder.buildWheel());
        car.setBody(builder.buildCarBody());
        String brand = builder.getBrand();
        System.out.println("组装" + brand + "汽车完成!");
        return car;
        
    }

}

由此,我们可以进行汽车生产了。

指定汽车制造商,送入汽车装配厂,生产汽车,上路。以下是测试代码:

 1 package com.corey.builder;
 2 
 3 public class Test {
 4 
 5     public static void main(String[] args) {
 6         
 7         CarBuilder builder = new AudiCarBuidler();
 8         CarDirector director = new CarDirector(builder);
 9         Car car = director.directCar();
10         System.out.println(car.getEngine().getName());
11         car.Run();
12         
13         System.out.println("----------------------------------");
14         
15         CarBuilder builder1 = new BMWCarBuilder();
16         CarDirector director1 = new CarDirector(builder1);
17         Car bmwCar = director1.directCar();
18         System.out.println(bmwCar.getEngine().getName());
19         bmwCar.Run();
20     }
21 }

运行结果:

建造奥迪发动机!
建造奥迪车轮!
建造奥迪车体!
组装Audi汽车完成!
Audi发动机
启动汽车,开始行程!
----------------------------------
建造宝马发动机!
建造宝马车轮!
建造宝马车体!
组装BMW汽车完成!
BMW发动机
启动汽车,开始行程!

 

至此,建造者模式完成。

Java框架中很多都是用建造者模式写的,一般都会以Builder结尾,常见的如StringBuilder。

 

以上是关于Solid Edge包含几个子装配的装配剖视图做自动明细表,只显示2个零件标号为啥?的主要内容,如果未能解决你的问题,请参考以下文章

请教两个关于solidedge问题(多实体与图纸分页)

Solid edge ST5 自己设置工程图模版时,无法设置零件明细表的默认格式

UG中通过API如何在装配环境下获取组件的包容盒(bounding box)

solidedge st3 更换已有工程图的模板及辅助零件如何应用

solidworks装配体图倒cad怎样才能得到装配体图的剖视图?

怎样在solidworks2010装配图中只剖一个零件?