精华内容
下载资源
问答
  • 根据板块构造理论,强调已知大地构造演化阶段岩石建造构造地质体现时的综合结果,突出重要大地构造演化阶段的原则,广西归属1~8大地构造单元,属欧亚板块(1)、华南陆壳板段(2)、中新生代南华褶皱系(中...
  • 中国东北地区赋煤构造是在太平洋地球动力学体系影响下形成的系列NE—NNE向断陷盆地,目前对本区赋煤构造单元划分尚未形成统一认识。根据东北地区含煤岩系赋存特征,将东北赋煤构造单元划分为三体系,即:东北赋煤...
  • 研究中应用位场分离技术获取布格重力异常划分贝克盆地边界及二级构造单元6个;利用位场边缘识别技术计算布格重力异常总水平-垂向导数推测贝克盆地控盆断裂3组,其中2组为近东西走向,组为近南北走向。研究表明贝克...
  • 文章基于煤田地质构造特征并集成前人研究工作成果,从区域构造控制与煤系赋存状况相结合的角度对柴北缘赋煤区构造单元进行了深入研究,认为柴北缘赋煤区可新厘定为""三隆三凹(五小凹区)"即3个三单元,11个四单元,...
  • 云南省大地构造单元及成矿带区带划分研究新进展发表于云南地质上,最新版的云南省大地构造单元划分依据,包含一级、二级、三级构造单元划分情况以及成矿带的分布
  • 如何用Java构造数组,数组每个单元含有多个元素:数据结构基础 方法原理 我们平时创建普通数组时候,每个单元只能存放个元素。而Java是面向对象的高级语言。在不使用泛型的情况下。我们创建个类,类型的数组。并...

    如何用Java构造数组,数组每个单元含有多个元素:数据结构基础

    方法原理

    我们平时创建普通数组时候,每个单元只能存放一个元素。而Java是面向对象的高级语言。在不使用泛型的情况下。我们创建一个类,类型的数组。并将其初始化。将每一个单元初始化

    先创建一个类,并将其初始化

    class ID {
    	protected int id;
    	protected String name;
    
    	public ID(int id, String name) {
    		this.id = id;
    		this.name = name;
    	}
    	
    
    
    	public ID() {
    		this(0,null);
    	}
    }
    
    
    ## **创建一个类数组``**
    
    
    class HX{
    	ID []e;//创建类数组
    	public HX(int length) {
    		e=new ID[length];
    		for (int i = 0; i < e.length; i++) {
    			e[i]=new ID();
    		}
    	}
    	public HX() {
    		e =new ID[99];
    		for (int i = 0; i < e.length; i++) {
    			e[i]=new ID();
    		}
    	}
    }
    
    
    

    main方法中,创建数组(顺序表)实例,及一个数组放入多个元素完成

    HX h=new HX();
    System.out.println(h.e[16].id);
    

    结果如下

    0

    展开全文
  • 早白垩世民乐盆地为走滑拉分断陷盆地,由西至东划分为西部斜坡、中央坳陷、东部斜坡3个一级构造单元。其中中央坳陷进一步划分为7个二级构造单元,其中3个凹陷、2个凸起、1个低凸起和1个次凹。构造演化经历了燕山早期、...
  • 在如上的A指向B、B指向C的指向关系中,如果A、B、C都是变量,即C是普通变量,B是一级指针变量,其中存放着C的地址,A是二级指针变量,其中存放着B的地址,则这3个变量分别在内存中占据各自的存储单元,它们之间的...

    二级指针实现二叉树的构造

    首先二级指针作为函数参数的作用:在函数外部定义一个指针p,在函数内给指针赋值,函数结束后对指针p生效,那么我们就需要二级指针。不懂没有关系,继续往下看~加油!

    在如上的A指向B、B指向C的指向关系中,如果A、B、C都是变量,即C是普通变量,B是一级指针变量,其中存放着C的地址,A是二级指针变量,其中存放着B的地址,则这3个变量分别在内存中占据各自的存储单元,它们之间的相互关系下图所示,相互之间的前后位置关系并不重要.此时,B是一级指针变量,B的值(即C的地址)是一级指针数据;A是二级指针变量,A的值(即B的地址)是二级指针数据.

    我们都知道二叉树的建立可以用两种方式

    1.    class中声明函数

            BT(){
            cout<<"请输入建立二叉树的节点数据"<<endl;
            this->root=Creat();
            }
            BT_node* Creat();

    2.     BT(){
               cout<<"请按先序输入二叉树的节点信息"<<endl;
               Creat(&root);
           }
            void Creat(BT_node **root);

    两种函数是等价的,即BT_node* Creat();和void Creat(BT_node **root);效果是一样的。

    很多人包括刚开始学习二叉树的我,都认为第二个函数就只要用一级指针不就应该完成嘛?为什么非要用二级指针。

    那么问题来了!这两个函数需要达到的目的是什么????是不是创建一颗二叉树,然后把你创建的二叉树的根指针赋值给当前二叉树的根指针!也就是你需要改变根节点指针的值!!

    第一个函数是如何改变的呢??通过BT_node* Creat();函数return回一个指针,然后在构造函数中通过 this->root=Creat();改变二叉树的根指针。

    第二个函数呢??我们在刚开始接触指针时,一定遇到交换两个数的操作。显然void  Fun_swap(int a,int b);是无法实现交换a和b的值。因为这个时候我们传递的只是a和b的副本,副本的交换并不能交换内存空间中a和b的值。也就是我们熟知的,如果你要改变某个数,必须通过地址传递实现,也就是通过指针来实现!

    那么我们回到这里~我们要实现的是改变二叉树根指针的值,如果这时候通过一级指针void Creat(BT_node *root);是没有办法实现的,类比之前交换两个数,这里必须使用指针的指针才能改变指针的值!也就是void Creat(BT_node **root);

    具体构造方法以及三种递归遍历操作如下

    #include <iostream>
    using namespace std;
    struct BT_node{
    	char data;
    	struct BT_node *lchild,*rchild;
    };
    class BT{
    	public:
    		BT_node *root;
    	public:
    		BT();
    		BT_node* Creat();
    		~BT();
    		void Release(BT_node *root);
    		void PreOrder(BT_node*root);
    		void InOrder(BT_node*root);
    		void PostOrder(BT_node *root);
    };
    BT::BT(){
    	cout<<"请输入建立二叉树的节点数据"<<endl;
    	this->root=Creat();
    }
    BT_node* BT::Creat(){
    	BT_node *root;
    	char ch;
    	cin>>ch;
    	if(ch=='#'){
    		root=NULL;
    	}else{
    		root=new BT_node;
    		root->data=ch;
    		root->lchild=Creat();
    		root->rchild=Creat();
    	}
    	return root;
    }
    BT::~BT(){
    	Release(root);
    }
    void BT::Release(BT_node *root){
    	if(root){
    		Release(root->rchild);
    		Release(root->lchild);
    		delete root;
    	}
    }
    void BT::PreOrder(BT_node *root){
    	if(root==NULL){
    		return;
    	}else{
    		cout<<root->data<<'\t';
    		PreOrder(root->lchild);
    		PreOrder(root->rchild);
    	}
    }
    void BT::LevelOrder(BT_node *root){
    	Queue Q;//队列q
    	if(root==NULL){
    		return;
    	}
    	int i=0;
    	Q.EnQueue(root);//队头元素入队列
    	while(!Q.Empty()){
    		BT_node *p=Q.DeQueue();
    		cout<<p->data<<'\t';
    		if(p->lchild!=NULL){
    			Q.EnQueue(p->lchild);
    		}
    		if(p->rchild!=NULL){
    			Q.EnQueue(p->rchild);
    		}
    	} 
    }
    //中序遍历 
    void BT::InOrder(BT_node *root){
    	if(root==NULL){
    		return;
    	}else{
    		InOrder(root->lchild);
    		cout<<root->data<<'\t';
    		InOrder(root->rchild);
    	}
    }
    void BT::PostOrder(BT_node *root){
    	if(root==NULL){
    		return;
    	}else{
    		PostOrder(root->lchild);
    		PostOrder(root->rchild);
    		cout<<root->data<<'\t';
    	}
    }
    int main(){
    	BT test;
    	cout<<"先序遍历"<<endl; 
    	test.PreOrder(test.root);
    	cout<<endl; 
    	cout<<"中序遍历"<<endl; 
    	test.InOrder(test.root);
    	cout<<endl; 
    	cout<<"后序遍历"<<endl; 
    	test.PostOrder(test.root);
    	cout<<endl; 
    	return 0;
    }
    #include <iostream>
    using namespace std;
    //定义节点数据类型 
    struct BT_node{
    	char data;
    	struct BT_node *lchild ,*rchild;
    }; 
    class BT{
    	public:
    		struct BT_node *root=NULL;
    	public:
    		BT();
    		void Creat(BT_node **root);
    		void Pre_order(BT_node *root);
    		~BT();
    		void Release(BT_node *root);
    };
    BT::BT(){
    	cout<<"请按先序输入二叉树的节点信息"<<endl;
    	Creat(&root);
    }
    void BT::Creat(BT_node **root){
    	char ch;
    	cin>>ch;
    	if(ch=='#'){
    		*root=NULL;
    	}else{
    		*root=new BT_node;
    		(*root)->data=ch;
    		Creat(&((*root)->lchild));
    		Creat(&((*root)->rchild));
    	}
    }
    void BT::Pre_order(BT_node *root){
    	if(root==NULL){
    		return;
    	}else{
    		cout<<root->data<<'\t';
    		Pre_order(root->lchild);
    		Pre_order(root->rchild);
    	}
    }
    BT::~BT(){
    	Release(root);
    } 
    void BT::Release(BT_node *root){
    	if(root){
    		Release(root->rchild);
    		Release(root->lchild);
    		delete root;
    	}
    }
    int main(){
    	BT test;
    	test.Pre_order(test.root);
    	if(test.root==NULL){
    		cout<<"二叉树为空!"<<endl; 
    	}
    	return 0;
    }

     

    展开全文
  • 面向对象设计与构造...第次作业:实现两个容器类Path和PathContainer,JML规格入门的理解和代码实现。 第二次作业:实现容器类Path和数据结构类Graph,JML规格进阶级的理解和代码实现、设计模式的简单实战,...

    面向对象设计与构造课程作业

    第三单元总结

    北京航空航天大学计算机学院 2019春季

    17373468 赵子敬

     

    单元主题:规格的理解、撰写和使用(图和地铁运行系统)

    第一次作业:实现两个容器类PathPathContainerJML规格入门级的理解和代码实现。

    第二次作业:实现容器类Path和数据结构类GraphJML规格进阶级的理解和代码实现、设计模式的简单实战,以及单元测试的初步使用尝试。

    第三次作业:实现容器类Path,地铁系统类RailwaySystemJML规格进阶级的理解和代码实现、设计模式和单元测试的进阶级实战。

     

    一、JML语言的理论基础、应用工具链情况

    (本段较多引用网络教程,链接:http://tech.it168.com/a2009/0222/266/000000266316.shtml)

    面向对象分析和设计的原则之一就是应当尽可能地把过程设想往后推。我们大多数人只在实现方法之前遵守这一规则。一旦确定了类及其接口并该开始实现方法时,我们就转向了过程设想。那么到底有没有别的选择?和大多数语言一样,编写 Java 代码时,我们需要为计算每个方法的结果一步一步地提供过程。

    就其本身而言,过程化表示法只是说 如何做某事,却不曾说过我们正在设法做 什么。在动手之前了解我们想要取得的结果,这可能会有用,但是 Java 语言没有提供显式地将这种信息合并到代码中的方法。

    Java 建模语言(JML)将注释添加到 Java 代码中,这样我们就可以确定方法所执行的内容,而不必说明它们如何做到这一点。有了JML,我们就可以描述方法预期的功能,无需考虑实现。通过这种方法,JML将延迟过程设想的面向对象原则扩展到了方法设计阶段。

    JML 编译器可以生成类文件,这些文件可以在运行时自动检查 JML 规范。如果程序没有完成其 JML 注释中规定要做的事,则 JML 会抛出一个未经检查的异常,指出违反了哪部分规范。这在捕获错误或帮助使文档(JML 注释格式)与代码保持同步方面都非常有用。

    JML 运行时断言检查编译器是数目不断增多的使用 JML 的工具中的第一个。其它工具包括 jmldocjmlunitjmldoc 类似于 javadoc ,不过它还在生成的 HTML 文档中包含了 JML 规范。 jmlunit 生成测试案例类的框架,它使 JML 能方便地与 JUnit 结合使用。

    二、【选做】部署 SMTSolver ,至少选择3个主要方法来尝试进行验证,报告结果
    三、部署 JMLUnitNG/JMLUnit,针对 Graph 接口的实现自动生成测试用例, 并结合规格对生成的测试用例和数据进行简要分析

    本次作业我没有使用 JMLUnit 进行测试,只是使用了 JUnit ,针对规格实现了单元测试,在此简单梳理随机用例测试代码。

       private static final int maxPathSize = 80;
       private static final int maxDistinctNode = 120;
       private RailwaySystem system = new MyRailwaySystem();
       private ArrayList<Integer> nodeSet = new ArrayList<>();
       private ArrayList<Path> pathSet = new ArrayList<>();

    上面这段定义测试类全局变量,maxPathSizemaxDistinctNode 两个常量用来便于修改测试过程中数据范围边界;system 实例化一个 RailwaySystem 类,作为测试的对象; nodeSetpathSet 分别用来存储测试类生成的路径和节点。

      private Path generateRadomPath() {
           int pathSize = (int)(2 + Math.random() * (maxPathSize - 1));
           ArrayList<Integer> pathNodeList = new ArrayList<>();
           for (int i = 0; i < pathSize; i++) {
               int flag = (int)(Math.random() * 2);
               if ((nodeSet.size() == maxDistinctNode || flag == 0)
                       && nodeSet.size() != 0) {
                   int index = (int)(Math.random() * nodeSet.size());
                   Integer node = nodeSet.get(index);
                   pathNodeList.add(node);
              } else {
                   Integer newNode =
                          (int)(Integer.MIN_VALUE + Math.random() *
                                  ((long)Integer.MAX_VALUE -
                                          (long)Integer.MIN_VALUE + 1));
                   pathNodeList.add(newNode);
                   nodeSet.add(newNode);
              }
          }
           int[] pathList = new int[pathNodeList.size()];
           for (int i = 0; i < pathNodeList.size(); i++) {
               pathList[i] = pathNodeList.get(i);
          }
           System.out.println("adding path, path size: " + pathSize);
           System.out.println(pathNodeList);
           return new MyPath(pathList);
      }

    上面这段为随机生成路径。首先路径长度是在最大范围内随机的,其次循环生成在int范围内随机的节点。为了保证整个系统中的节点数不超过限制,在生成路径时即存储所有节点,若超过限制则在已有的节点里寻找节点构建新路径。最后打印生成路径信息。

      private Path removeRandomPath() {
           int pathIndex = (int)(Math.random() * pathSet.size());
           Path toBeRemoved = pathSet.get(pathIndex);
           System.out.println("the following path has been removed.");
           System.out.println(toBeRemoved);
           pathSet.remove(pathIndex);
           nodeSet.clear();
           int i;
           int j;
           for (i = 0; i < pathSet.size(); i++) {
               for (Integer node : pathSet.get(i)) {
                   if (!nodeSet.contains(node)) {
                       nodeSet.add(node);
                  }
              }
          }
           return toBeRemoved;
      }

    上面这段为随机删除路径。在已有的路径随机选择一个下标将对应的路径删除,随即更新节点集信息。

      @Before
       public void setUp() throws Exception {
           int addNum = (int)(1 + Math.random() * 50);
           for (int i = 0; i < addNum; i++) {
               Path newPath = generateRadomPath();
               pathSet.add(newPath);
               system.addPath(newPath);
          }
           int removeNum = (int)(Math.random() * addNum);
           for (int i = 0; i < removeNum; i++) {
               Path toBeRemoved = removeRandomPath();
               system.removePath(toBeRemoved);
          }
           System.out.println("system has been built.");
           System.out.println("total paths: " + pathSet.size());
           System.out.println("distinct node count: " + nodeSet.size());
      }

    上面这段是 JUnit 框架的 @Before 模块,在单元测试之前初始化测试类。在此仍然采用随机的方式,在增删指令数限定范围内随机增加路径,随后在不超过已有路径数量的范围内随机删除路径,最终打印现有地铁系统路径数量和节点数量信息,在测试之前建立好地铁系统。

      @Test
       public void containsNode() {
           int index = (int)(Math.random() * nodeSet.size());
           assert system.containsNode(nodeSet.get(index));
           System.out.println("correct: " + nodeSet.get(index)
                   + " is in the system.");

           int node = (int)(Math.random() * Integer.MAX_VALUE);
           while (nodeSet.contains(node)) {
               node = (int)(Math.random() * Integer.MAX_VALUE);
          }
           assert system.containsNode(nodeSet.get(index));
           System.out.println("correct: " + node + " is not in the system.");
      }

    上面这段是 JUnit 单元测试针对 containsNode 接口的测试。此处由于我们已经在测试类存储了所有节点,因此只是从测试类取出了已有节点或随机生成新节点,无需按照规格遍历所有路径即可找到测试节点。上面这段代码从正反分别验证,在系统中的节点和不在系统中的节点均有测试。

      @Test
       public void containsEdge() {
           int index = (int)(Math.random() * pathSet.size());
           Path testPath = pathSet.get(index);
           index = (int)(Math.random() * (testPath.size() - 1));
           int fromNode = testPath.getNode(index);
           int toNode = testPath.getNode(index + 1);
           assert system.containsEdge(fromNode, toNode);
           System.out.println("correct: edge (" + fromNode + ", " +
                   toNode + ") is in the system");

           index = (int)(Math.random() * nodeSet.size());
           fromNode = nodeSet.get(index);
           index = (int)(Math.random() * nodeSet.size());
           toNode = nodeSet.get(index);
           boolean flag = true;
           while (flag) {
               flag = false;
               for (Path path : pathSet) {
                   for (int i = 0; i < path.size() - 1; i++) {
                       if ((path.getNode(i) == fromNode &&
                               path.getNode(i + 1) == toNode)
                               || (path.getNode(i) == toNode &&
                               path.getNode(i + 1) == fromNode)
                               || fromNode == toNode) {
                           flag = true;
                           break;
                      }
                  }
                   if (flag) {
                       break;
                  }
              }
               if (flag) {
                   index = (int)(Math.random() * nodeSet.size());
                   toNode = nodeSet.get(index);
              }
          }
           assert !system.containsEdge(fromNode, toNode);
           System.out.println("correct: edge (" + fromNode + ", " +
                   toNode + ") is not in the system");
      }

    上面这段是 JUnit 单元测试针对 containsEdge 接口的测试。这段测试严格遵循了规格,按照规格的定义对边进行了测试,同样是从正反两方面验证,首先在已有路径随机选择一条路,再从中随机选择一条边取出进行测试,确保这条边是属于系统的;而另一方面寻找不属于系统的边则比较麻烦,需要首先随机寻找节点,再遍历系统确保所有路径都不包含这条边。

    还有更多接口的单元测试,代码过于冗长在此不再赘述。以 containsEdge 为例,测试的输出信息如下:

    ...
    junit4 MyRailwaySystemTest,containsEdge
    adding path, path size: 22
    [1232241898, 1232241898, 378328260, 1232241898, 1232241898, 378328260, 1059498109, 1059498109, 1059498109, 1232241898, 513409004, -1001154432, -1001154432, -1001154432, 1059498109, -1151735537, 1478286012, -2011719206, -1151735537, -338002509, -1719290353, -1077194302]
    adding path, path size: 8
    [-1009325207, -1009325207, 280639520, 378328260, 1640517423, -1009325207, -358986601, 1059498109]
    adding path, path size: 42
    [966545447, 378328260, 1215082132, -1922842082, -1922842082, -1009325207, 378328260, -1151735537, -1009325207, -358986601, -1061266839, -1719290353, 410078478, 2085504756, 1232241898, 280639520, -2060925210, -369734078, 1223397009, -426274874, 1223397009, 933549319, -761667280, -271824825, 467283959, -1365251337, 1032049891, -1009325207, 1190892105, -1151735537, 1478286012, 1232241898, -1077194302, 1288726621, 1313963050, -1612728892, -73540680, -1719290353, 1640517423, -1873436263, -426274874, -426274874]
    adding path, path size: 54
    [1690346573, 402468808, -1873436263, -1873436263, 1232241898, -1061266839, 1640517423, 1475715686, 1977518312, 1575320703, -413736847, -1505480721, 1288726621, -1723345819, -73540680, 723556111, 1886070244, 467283959, 2015089536, -1719290353, -1061266839, 1478286012, 1762562422, -1719290353, -1001154432, 2015089536, 11719880, 1919254022, -1922842082, -87287690, -1503898901, -1489990093, 1882643122, 1288726621, 1139289371, 2015089536, -1365251337, 2101859962, -269155122, -966483414, 1575320703, 723556111, 410078478, -910520886, -271824825, -1422471783, 1575320703, -1422471783, 1139289371, 257175990, -1503898901, 2052736417, 1690346573, -1723345819]
    adding path, path size: 58
    [-583849437, 1190892105, -1196197506, -910520886, -1756866206, 273438400, -1814841704, 725680019, -73540680, -506344367, -73540680, -1365251337, -309934114, 465396124, 1223397009, -860023481, -369734078, 1204976612, 1762562422, -25286283, 467283959, 1886070244, 1736431410, -1968909372, 1478286012, 2052736417, 755188845, -2060925210, 1690922899, -1756866206, 1762562422, 816076988, -910520886, 723556111, 151760211, -2011719206, -1505480721, 1357764646, -301487943, 2085504756, -354252823, 1554967211, -1008226810, 933549319, 1221881081, 1191566630, -87287690, 755188845, -641269296, -1513703690, -830510707, -90020217, 437843332, -271824825, -768990883, 228240350, -1505480721, 1223397009]
    adding path, path size: 9
    [-70177856, 1278044153, -269155122, 816076988, -1263627592, 180011778, 11719880, -271824825, -34994370]
    adding path, path size: 28
    [1762562422, -420234991, 755188845, 1167139935, -377147417, 549200588, 281646107, 1118305039, -1429609969, -1632813850, -1873436263, -562522988, -1922842082, -510676862, -761667280, 1357764646, -1151735537, 876397354, 419176848, 941885397, 1518270263, -309934114, 1091165502, 1221881081, 1993619079, 1810909193, -625828750, 1052359578]
    adding path, path size: 55
    [1690346573, -73540680, -1758621909, 1575320703, 1052359578, -301487943, -1873436263, 2015089536, 1223397009, 1478286012, -1723345819, 1167139935, 1191566630, -641269296, -1009325207, 816076988, 1118305039, 1091165502, 1690346573, -1489990093, -269155122, -1077194302, 1690346573, 11719880, -73540680, -966483414, -506344367, -1756866206, 1640517423, 281646107, 1059498109, -1873436263, -70177856, 437843332, 1288726621, -1196197506, 1810909193, 437843332, 1191566630, -1612728892, -761667280, 2101859962, -1489990093, -1968909372, 419176848, 1288726621, 1052359578, 281646107, -1719290353, -1196197506, -562522988, -1756866206, 228240350, -1263627592, 1882643122]
    adding path, path size: 35
    [1221881081, -506344367, -338002509, -1503898901, -761667280, -1489990093, 410078478, 1690922899, -1719290353, 180011778, 1919254022, 513409004, 1052359578, -860023481, -910520886, 1091165502, 402468808, -271824825, 257175990, -358986601, 1478286012, 876397354, 1215082132, -1151735537, -377147417, 1139289371, -625828750, 410078478, -301487943, 755188845, -562522988, -25286283, 437843332, 2052736417, -1719290353]
    adding path, path size: 19
    [-1719290353, 1518270263, 1993619079, -358986601, 257175990, -583849437, 257175990, 378328260, 1882643122, 1810909193, 281646107, -358986601, 1575320703, -1814841704, 151760211, 11719880, -269155122, -338002509, -761667280]
    adding path, path size: 48
    [1215082132, 467283959, 1690922899, 1215082132, 933549319, 280639520, -354252823, 1554967211, 1690346573, 273438400, -25286283, 1223397009, 941885397, 1059498109, 280639520, -761667280, -426274874, 378328260, -1719290353, -413736847, 1554967211, -1968909372, -1365251337, 1993619079, -966483414, -1196197506, -1503898901, 273438400, 1690922899, 1313963050, 1288726621, -1196197506, -338002509, 1139289371, -1758621909, 1091165502, 1690346573, -1632813850, -269155122, 1690922899, 1278044153, -301487943, -301487943, -641269296, -641269296, -426274874, 410078478, 2052736417]
    adding path, path size: 76
    [-1489990093, -269155122, 1313963050, 281646107, 1204976612, 1139289371, 281646107, -1077194302, 437843332, -73540680, 1221881081, -269155122, -830510707, 941885397, 1475715686, 1518270263, -338002509, 1032049891, 1190892105, 1139289371, 1278044153, 1640517423, -1365251337, -1489990093, 402468808, -358986601, 1575320703, 1204976612, 1993619079, 966545447, 11719880, -1196197506, -1429609969, 941885397, -1365251337, 1690346573, 1191566630, 1554967211, 933549319, 1313963050, -1429609969, -1719290353, 1223397009, -1814841704, -87287690, 1640517423, -1009325207, -1632813850, -2011719206, 1475715686, -73540680, -1922842082, -506344367, -309934114, -562522988, -1365251337, 1191566630, 755188845, -966483414, -1968909372, 257175990, -910520886, 1221881081, 723556111, 933549319, 419176848, -1365251337, -583849437, -70177856, 281646107, -910520886, -1503898901, -1723345819, -1489990093, 1762562422, 280639520]
    adding path, path size: 27
    [-768990883, 549200588, 1762562422, -271824825, 1032049891, -1196197506, -562522988, 1575320703, -1263627592, -1001154432, -73540680, -1873436263, -301487943, -1922842082, -1612728892, 1221881081, 273438400, 1232241898, -354252823, -2011719206, 437843332, 1357764646, -420234991, 1736431410, -1422471783, 1575320703, -506344367]
    adding path, path size: 72
    [1977518312, -87287690, -1503898901, 1052359578, -420234991, 933549319, -1632813850, -1009325207, 151760211, 966545447, 2085504756, -1758621909, 1575320703, 1190892105, -1263627592, -369734078, -1513703690, -301487943, 755188845, -271824825, -1503898901, 1288726621, 1882643122, -420234991, -34994370, 1690922899, -625828750, -761667280, 1554967211, 933549319, 1091165502, 273438400, 1518270263, -354252823, 1478286012, 1762562422, -1196197506, -1263627592, 378328260, -1503898901, 410078478, 1810909193, 1690346573, 513409004, -562522988, -1077194302, 410078478, -1873436263, 1091165502, 1091165502, -301487943, 228240350, -413736847, -1008226810, -1422471783, -1632813850, -338002509, -1489990093, -369734078, -1968909372, 1518270263, -830510707, 1288726621, -1422471783, 2101859962, 1215082132, 1357764646, 1977518312, 1288726621, 933549319, -562522988, -506344367]
    the following path has been removed.
    [1215082132, 467283959, 1690922899, 1215082132, 933549319, 280639520, -354252823, 1554967211, 1690346573, 273438400, -25286283, 1223397009, 941885397, 1059498109, 280639520, -761667280, -426274874, 378328260, -1719290353, -413736847, 1554967211, -1968909372, -1365251337, 1993619079, -966483414, -1196197506, -1503898901, 273438400, 1690922899, 1313963050, 1288726621, -1196197506, -338002509, 1139289371, -1758621909, 1091165502, 1690346573, -1632813850, -269155122, 1690922899, 1278044153, -301487943, -301487943, -641269296, -641269296, -426274874, 410078478, 2052736417]
    the following path has been removed.
    [1690346573, -73540680, -1758621909, 1575320703, 1052359578, -301487943, -1873436263, 2015089536, 1223397009, 1478286012, -1723345819, 1167139935, 1191566630, -641269296, -1009325207, 816076988, 1118305039, 1091165502, 1690346573, -1489990093, -269155122, -1077194302, 1690346573, 11719880, -73540680, -966483414, -506344367, -1756866206, 1640517423, 281646107, 1059498109, -1873436263, -70177856, 437843332, 1288726621, -1196197506, 1810909193, 437843332, 1191566630, -1612728892, -761667280, 2101859962, -1489990093, -1968909372, 419176848, 1288726621, 1052359578, 281646107, -1719290353, -1196197506, -562522988, -1756866206, 228240350, -1263627592, 1882643122]
    the following path has been removed.
    [1690346573, 402468808, -1873436263, -1873436263, 1232241898, -1061266839, 1640517423, 1475715686, 1977518312, 1575320703, -413736847, -1505480721, 1288726621, -1723345819, -73540680, 723556111, 1886070244, 467283959, 2015089536, -1719290353, -1061266839, 1478286012, 1762562422, -1719290353, -1001154432, 2015089536, 11719880, 1919254022, -1922842082, -87287690, -1503898901, -1489990093, 1882643122, 1288726621, 1139289371, 2015089536, -1365251337, 2101859962, -269155122, -966483414, 1575320703, 723556111, 410078478, -910520886, -271824825, -1422471783, 1575320703, -1422471783, 1139289371, 257175990, -1503898901, 2052736417, 1690346573, -1723345819]
    the following path has been removed.
    [-70177856, 1278044153, -269155122, 816076988, -1263627592, 180011778, 11719880, -271824825, -34994370]
    the following path has been removed.
    [966545447, 378328260, 1215082132, -1922842082, -1922842082, -1009325207, 378328260, -1151735537, -1009325207, -358986601, -1061266839, -1719290353, 410078478, 2085504756, 1232241898, 280639520, -2060925210, -369734078, 1223397009, -426274874, 1223397009, 933549319, -761667280, -271824825, 467283959, -1365251337, 1032049891, -1009325207, 1190892105, -1151735537, 1478286012, 1232241898, -1077194302, 1288726621, 1313963050, -1612728892, -73540680, -1719290353, 1640517423, -1873436263, -426274874, -426274874]
    the following path has been removed.
    [-583849437, 1190892105, -1196197506, -910520886, -1756866206, 273438400, -1814841704, 725680019, -73540680, -506344367, -73540680, -1365251337, -309934114, 465396124, 1223397009, -860023481, -369734078, 1204976612, 1762562422, -25286283, 467283959, 1886070244, 1736431410, -1968909372, 1478286012, 2052736417, 755188845, -2060925210, 1690922899, -1756866206, 1762562422, 816076988, -910520886, 723556111, 151760211, -2011719206, -1505480721, 1357764646, -301487943, 2085504756, -354252823, 1554967211, -1008226810, 933549319, 1221881081, 1191566630, -87287690, 755188845, -641269296, -1513703690, -830510707, -90020217, 437843332, -271824825, -768990883, 228240350, -1505480721, 1223397009]
    system has been built.
    total paths: 8
    distinct node count: 107
    correct: edge (-1922842082, -510676862) is in the system
    correct: edge (1690922899, 1736431410) is not in the system

    Process finished with exit code 0

    生成的测试数据是完全随机的,这个特性有优势也有劣势。优势在于可以全面地并且随即地测试接口实现,并可以灵活调整测试规模,方便地进行多次不同数据测试。当然,明显的劣势在于随即数据难以很好地兼顾边界和特殊情况,只能通过大量多次测试来提升语句覆盖率,而很难达到语句覆盖100%。

    四、按照作业梳理自己的架构设计,并特别分析迭代中对架构的重构
    第一次作业:

    第一次作业要求比较简单,只需要实现路径( path )的构造和路径容器( pathContainer )的构造。pathContainer 需要实现路径的增添、删除、编号,以及一个相对特殊的方法:统计节点数。由于是第一次作业,原本的思路就是按照规格中规中矩地实现了,但是在性能要求的影响下我们发现不可以按照规格一模一样地实现代码,因为采用静态的容器不能满足增删需求,用动态数组统一进行每一个方法的计算查询又会耗费大量时间,这也是我们第一次体会到,规格仅仅用来规范输入输出,而具体的实现是自由的。只要保证与规格的输入输出要求一致,应该尽可能构思性能更好的实现方法。

    因此在两个接口实现的过程中,为了提升时间性能我都适当牺牲了空间性能。在 Path 接口的实现过程中我才用了这样的存储:

      private ArrayList<Integer> nodeList = new ArrayList<>();
       private HashSet<Integer> nodeSet = new HashSet<>();

       public MyPath(int... nodeList) {
           for (int node : nodeList) {
               this.nodeList.add(node);
               this.nodeSet.add(node);
          }
      }

    同时使用动态数组和集合,把每一个节点存两遍,这样既保留路径原有节点和顺序信息,也能够方便地查询节点和统计不相同节点数。

    pathContainer 接口实现中我同样采取了存储多次的方法,将不同类型信息多次存储,已达到快速查询的目的:

      private HashMap<Integer, Path> pathMap1 = new HashMap<>();
        private HashMap<Path, Integer> pathMap2 = new HashMap<>();
        private static int idCount = 0;
        private ArrayList<Integer> nodeList = new ArrayList<>();
        private HashSet<Integer> distinctNodeSet = new HashSet<>();
    
        public MyPathContainer() {
        }
    

    其中 pathMap1pathMap2 将路径和其编号一一对应地存储,为了使查询更快使用哈希表,而为了能实现路径-编号双向查询我使用了两个哈希表,并为路径重写了 hashCodeequals 方法。而为了查询不相同节点,我将所有路径的节点再次存储,这样一来所有查询的复杂度都被降到常数。

    第二次作业:

    第二次作业的需求比第一次多了一些,主要挑战在于要求查询节点的连通性以及计算最短路径。这两个新增需求看似可以通过少量对第一次代码的扩展来实现,但实际上如果这样做,时间性能将不能够支撑代码通过测试。但看计算最短路径,不论是迪杰斯特拉还是弗洛伊德,时间复杂度都在三次方量级。按照作业需求,高达数千次的查询操作会耗费大量时间。并且如果在动态容器基础上操作,不论是查询计算还是增删,都会有很多Java包调用的开销。因此我采用了多重存储+静态二维数组的方式,并单独封装一类维护图结构。

      private static final int SIZE = 400;
        private HashMap<Integer, Integer> idexMap = new HashMap<>();
        private HashMap<Integer, Integer> nodeMap = new HashMap<>();
        private int[][] adjMatrix = new int[SIZE][SIZE];
        private int[][] dstMatrix = new int[SIZE][SIZE];
    

    这是我单独封装的 Matrix 类全局变量,我使用了静态的二维数组作为增删和查询路径操作的主要对象,而为了让动态变化的节点可以反映在静态的二维数组上,我才用了两个哈希表将节点映射为数组下标,并实现双向索引。而二维数组我也采用了两重存储,dstMatrix 用来存储计算好的两点之间最短距离,而 adjMatrix 则用来存储点的邻接情况。这样一来,只需要在每次增删操作时改变矩阵和映射关系,重新计算更新所有矩阵的信息,将繁杂的计算工作分摊给需求较少的增删操作,而每次的查询无非是访问了一个静态二维数组。

    	private void setDstMatrix() {
            int i;
            int j;
            int k;
            for (i = 0; i < SIZE; i++) {
                for (j = 0; j < SIZE; j++) {
                    if (i == j) {
                        dstMatrix[i][j] = 0;
                    } else if (adjMatrix[i][j] > 0) {
                        dstMatrix[i][j] = 1;
                    } else {
                        dstMatrix[i][j] = -1;
                    }
                }
            }
    
            for (k = 0; k < SIZE; k++) {
                for (i = 0; i < SIZE; i++) {
                    for (j = 0; j < SIZE; j++) {
                        int temp = -1;
                        if (dstMatrix[i][k] >= 0 && dstMatrix[k][j] >= 0) {
                            temp = dstMatrix[i][k] + dstMatrix[k][j];
                        }
                        if (temp >= 0 &&
                                (temp < dstMatrix[i][j] || dstMatrix[i][j] < 0)) {
                            dstMatrix[i][j] = temp;
                        }
                    }
                }
            }
        }
    

    上面这段代码是采用弗洛伊德算法更新距离矩阵。我们基于邻接矩阵来更新距离矩阵,初始化过程为,相同节点间距离为0,若两节点邻接则距离为1,其余节点间距离均为无穷(在这里使用了-1)。而弗洛伊德算法,遍历每个节点(变量k表示),对于每个节点,遍历整张图的其他所有节点对(变量i和j表示),查看如果k节点作为中间节点,i和j之间的路径如果通过k到达会不会更短,如果更短则更新i和j之间的距离。弗洛伊德算法的时间复杂度是n^3,理论上比迪杰斯特拉算法要慢,但是在本次作业中实测优于迪杰斯特拉,这可能是由于节点数目多但图较为稀疏的情况下迪杰斯特拉算法时间复杂度的常数项很大,而弗洛伊德能够始终保持稳定的三次方。

    第三次作业:

    第三次作业的需求比第二次再升一级,需要实现地铁线路中很现实的:最低票价查询、最少换乘查询和最少不满意度查询,以及相对独立的连通块个数查询。题目给出的模型我认为非常符合实际,地铁系统给出两站之间最少换乘是很有必要的功能;票价的模型是两站间距离加上最少换乘数的二倍,这与北京地铁实际票价计价方式一致;不满意度也很符合人们的实际心理,不满意度和路途远近、线路途径站点的平均人流量和换成次数有关,以我个人的经验,从沙河到学院路,在早晚高峰我宁愿选择站数更多的八号线,也不愿意选择在魔鬼西二旗换乘的十三号线。

    仔细分析过后我们会发现,前三种查询都涉及到了换乘站的记录,这是我们前两次作业始料未及的。我们在第二次作业计算最短路的时候,不论是弗洛伊德算法还是迪杰斯特拉算法,都无法确定中途哪一站在换乘。而这次三个查询都需要确定,我们所选的这条路有哪些站在换乘。

    而这个棘手的问题被王嘉仪同学提出的算法完美解决,即升级邻接矩阵。如果将每条路径也看成图,每条路径内部的联通情况和距离情况将被提前计算好,而原有 Matrix 类的邻接矩阵将被升级为每个单独路径的图的简单叠加。这样一来,不同路径之间的连通性就不会被直接显示在邻接矩阵中。接下来,在计算和换乘有关的最短路时,只需要按照需求分别存储其他的矩阵,基于升级后的邻接矩阵增加边权值即可。

    例如在计算最低票价时,对每条Path, 任意两个直接连边,边权修改为距离+2,即在边权中直接加入换乘的钱,然后进行弗洛伊德算法的计算。这样做求出的结果多最后一次换乘的2,减去即可。这个做法能够保证正确性。因为任意一条求出的路径长度都是真实的路径长度+2,和中间的换乘次数无关。且不存在求出的最短路在一条路线上多次换乘的问题,因为每条路径上的任意两点都直接连有边。最少换乘问题,可以将每条边的边权设为1+很大的一个数(大于最多换乘次数,这个数被我设置为700),这样根据最短路的特性,求出最短路后/120即为换乘的次数。最少不满意度可以参考最低票价解决。

      private static final int SIZE = 130;
        private static final int INF = Integer.MAX_VALUE;
        private static final int MODE = 700;
        private HashMap<Integer, Integer> idexMap = new HashMap<>();
        private HashMap<Integer, Integer> nodeMap = new HashMap<>();
        private HashSet<Path> pathSet = new HashSet<>();
        private int[][] adjMatrix = new int[SIZE][SIZE];
        private int[][] dstMatrix = new int[SIZE][SIZE];
    
        private int[][] cntMatrix = new int[SIZE][SIZE];
        private int[][] priMatrix = new int[SIZE][SIZE];
        private int[][] excMatrix = new int[SIZE][SIZE];
        private int[][] upvMatrix = new int[SIZE][SIZE];
    
        private int[] pre = new int[SIZE];
        private int cntCount;
    

    以上代码即第三次作业多存储的诸多矩阵。同样,为了查找方便,我们适当地采用空间换时间。

    private void setAdjMatrix(Integer lastNode, Integer curnNode) {
        int last = nodeMap.get(lastNode);
        int curn = nodeMap.get(curnNode);
        adjMatrix[last][curn] += 1;
        adjMatrix[curn][last] += 1;
    }
    
    private void setCntMatrix() {
        int i;
        int j;
        for (i = 0; i < SIZE; i++) {
            for (j = 0; j < SIZE; j++) {
                if (i == j) {
                    cntMatrix[i][j] = upvMatrix[i][j] = 0;
                } else {
                    cntMatrix[i][j] = upvMatrix[i][j] = INF;
                }
            }
        }
        for (Path path : pathSet) {
            for (Integer inode : path) {
                for (Integer jnode : path) {
                    i = nodeMap.get(inode);
                    j = nodeMap.get(jnode);
                    int temp = ((MyPath)path).getUpv(inode, jnode) + 32;
                    if (((MyPath)path).getLength(inode, jnode)
                            < cntMatrix[i][j]) {
                        cntMatrix[i][j] =
                                ((MyPath)path).getLength(inode, jnode);
                    }
                    if (temp < upvMatrix[i][j]) {
                        upvMatrix[i][j] = temp;
                    }
                }
            }
        }
    }
    
    private void setMatrixes() {
        int i;
        int j;
        int k;
        for (i = 0; i < SIZE; i++) {
            for (j = 0; j < SIZE; j++) {
                if (adjMatrix[i][j] > 0) {
                    dstMatrix[i][j] = 1;
                } else {
                    dstMatrix[i][j] = INF;
                }
                if (cntMatrix[i][j] != INF) {
                    priMatrix[i][j] = cntMatrix[i][j] + 2;
                    excMatrix[i][j] = 1 + MODE;
                } else {
                    priMatrix[i][j] = INF;
                    excMatrix[i][j] = INF;
                }
                if (i == j) {
                    dstMatrix[i][j] = 0;
                    priMatrix[i][j] = 0;
                    excMatrix[i][j] = 0;
                }
            }
        }
        for (k = 0; k < SIZE; k++) {
            for (i = 0; i < SIZE; i++) {
                for (j = 0; j < SIZE; j++) {
                    int temp1 = INF;
                    int temp2 = INF;
                    int temp3 = INF;
                    int temp4 = INF;
                    if (dstMatrix[i][k] != INF && dstMatrix[k][j] != INF) {
                        temp1 = dstMatrix[i][k] + dstMatrix[k][j];
                    }
                    if (priMatrix[i][k] != INF && priMatrix[k][j] != INF) {
                        temp2 = priMatrix[i][k] + priMatrix[k][j];
                    }
                    if (excMatrix[i][k] != INF && excMatrix[k][j] != INF) {
                        temp3 = excMatrix[i][k] + excMatrix[k][j];
                    }
                    if (upvMatrix[i][k] < INF && upvMatrix[k][j] < INF) {
                        temp4 = upvMatrix[i][k] + upvMatrix[k][j];
                    }
                    if (temp1 < dstMatrix[i][j]) {
                        dstMatrix[i][j] = temp1;
                    }
                    if (temp2 < priMatrix[i][j]) {
                        priMatrix[i][j] = temp2;
                    }
                    if (temp3 < excMatrix[i][j]) {
                        excMatrix[i][j] = temp3;
                    }
                    if (temp4 <= upvMatrix[i][j]) {
                        upvMatrix[i][j] = temp4;
                    }
                }
            }
        }
    }
    
    public void addPath(Path path) {
        pathSet.add(path);
        Integer lastNode = null;
        Integer curnNode = null;
        for (Integer node : path) {
            curnNode = node;
            mapId(curnNode);
            if (lastNode != null && curnNode != null) {
                setAdjMatrix(lastNode, curnNode);
            }
            lastNode = node;
        }
        setCntMatrix();
        setMatrixes();
        setCntCount();
    }
    

    以上代码即增添路径的过程中对所存储矩阵的操作。

    最终是连通快数目的计算,这一部分采用并查集的算法,不再赘述。

    三次作业中,重构的方式无非是增添存储来适应更多的需求。不增添存储也是可以的,只是为了满足时间性能需求,我们不能够直接采用规格直接规定的算法,而是要思考更好的实现方式。

    五、按照作业分析代码实现的bug和修复情况

    说来惭愧,三次作业我一共只有一个愚蠢的bug,而这个bug导致我前两次作业强测都炸到六十多分,它就是:

      @Override
        public int compareTo(Path path) {
            int len1 = this.size();
            int len2 = path.size();
            int lin = Math.min(len1, len2);
    
            for (int k = 0; k < lin; k++) {
                Integer i1 = this.getNode(k);
                int i2 = path.getNode(k);
                if (!i1.equals(i2)) {
                    return i1 - i2;
                }
            }
            return len1 - len2;
        }
    

    没错,就是int类型的减法溢出。第一次作业我没有考虑到这一点,修复bug之后第二次作业重用第一次的代码竟然又忘记改这个地方,所以死两次。

    这个故事告诉我们,千里之堤溃于蚁穴。

    六、阐述对规格撰写和理解上的心得体会

    说来惭愧,在这么多次训练过后,我所收获的有关规格的理解仅仅停留在写规格。当然,我理解为什么要产生规格,为什么要产生Java建模语言,为什么要进行基于规格的单元测试,这显然是这个单元给我的一大收获,我慢慢理解在大型工程开发中团队分工实现代码的过程。在企业研讨课上专家也向我们讲述了,架构设计不是一个过程,而是一个模块,不是设计完成后交付实现就完事了,而是作为一个模块随时调用随时调整的。

    另一方面,这单元作业也让我真正实操了诸如继承、重写、接口实现和 JUnit 单元测试等多项以前模糊的概念。我认为这个单元代码量虽然不大,确是对我个人编码和理解能力很好的提升。

    转载于:https://www.cnblogs.com/zhaozijing1998/p/10907950.html

    展开全文
  • 通过地震剖面解释,分析二连盆地赛汉塔拉凹陷的构造特征及其控藏作用。...赛汉塔拉凹陷总体呈现“东西分带、南北分块”的构造格局,内部发育5个一级构造单元、4个二级构造带和多种多样的局部构造。断层
  • 在不显式形成总刚度阵的情况下利用单元级矩阵的Cholesky分解构造总刚度阵的近似,形成预条件矩阵,提出了求解大型线性方程组的EBE-PCG并行算法,并讨论了算法在网络机群(COW)并行计算环境下的实现。结合实际算例,对EBE-...
  • 海拉尔盆地呼和湖凹陷构造特征与演化,王培俊,钟建华,呼和湖凹陷位于海拉尔盆地的东部,是海拉尔盆地呼和湖坳陷内的二级构造单元,也是海拉尔盆地勘探程度较低的个凹陷。本文通过对
  • 重新厘定9条一级断裂,确定4个一级构造单元,依据地质结构与构造样式的不同,将西缘中南段划分为5个段。构造变形自西向东依次减弱,南北向中部马家滩段以薄皮构造为主,其余段以厚皮构造为主;西缘中南段不同地区最短收缩...
  • 对调节构造的涵义、类型进行了讨论,提出了种新的分类方案,将将调节构造分为变(或转)换断层和传递带2大类,并依据其对构造单元的控制作用进行次划分;而传递带按形态又可分为"凸起、斜坡、地垒、地堑、断阶"5种类型...
  • NNE向、NW-NWW向的控制,这种构造特征同时也影响着矿区和井田内部断层的展布及其瓦斯赋存特征,即区域板块构造运动及其演化,奠定了淮南煤田区域性高瓦斯的基础,潘谢矿区内次一级构造控制着不同范围的瓦斯分布,...
  • 根据地震、钻井等基础资料建立主干剖面,结合平面构造展布及剖面构造特征研究孟加拉湾若开盆地的构造特征和演化。...北段挤压褶皱带可分为高陡褶皱带和低缓褶皱带2个次一级构造单元,变形强度从东往西逐渐减弱。(2)
  • JAVA笔记:构造方法

    2017-07-04 15:07:00
     【修饰符】:构造方法的上一级单元是类,所以修饰符可以public、protected(父子类访问权限)、private(本类访问权限)、默认(包访问权限)  【没有返回类型】  【构造方法名】:必须与类名一致  a.一般概...

     构造方法定义:

      【修饰符】 构造方法名(形参列表)

                 {

                    }

      【修饰符】:构造方法的上一级单元是类,所以修饰符可以public、protected(父子类访问权限)、private(本类访问权限)、默认(包访问权限)

      【没有返回类型】

      【构造方法名】:必须与类名一致

      a.一般概念

      构造方法不能够被继承,也就构造方法不能够被重写

      构造方法是特殊的方法,不能够被程序员直接调用,必须使用new关键字来调用,或者在构造方法中this(实参)调用本类构造方法,

      或者在构造方法中super(实参)调 用父类构造方法。

      b.创建对象执行过程

      首先分配内存空间,并且执行默认初始化操作(根、父、子类的顺序分配空间),此时对象已经创建成功。

      然后执行初始化代码块,在执行构造方法(根初始化代码块、根构造方法、父初始化代码块、父构造方法、子初始化代码块、子构造方法的顺序执行)。

      c.构造方法调用的规则

      首先判断子类中是否有super(必须在构造方法中第一条语句使用)调用父类构造方法,如果有,则调用super匹配的父类构造方法。

      如果没有,如果父类显式定义构造方法,则判断是否有无参构造方法,如果有,则调用父类无参构造方法。

      如果没有,则编译出错。

      如果父类没有定义构造方法,则系统自动默认一个无参构造方法,并且执行体为空。

      最后判断是否有this(必须在构造方法中第一条语句使用)调用本类构造方法,如果有,则调用this匹配的本来构造方法

      d.构造方法中使用成员变量

      如果要调用父类的成员变量,可以使用super.变量

      如果要调用本类的成员变量,可以使用this.变量

      如果要调用局部变量,可以直接使用变量

      e.构造方法中使用成员方法

      如果要调用父类的成员方法,可以使用super.方法名(实参);

      如果要调用本类的成员方法,可以使用this.方法名(实参)或者方法名(实参);

      注意点:如果父类构造方法中调用普通方法,并且此普通方法在子类中被重写,则父类构造方法中调用的普通方法为子类的普通方法,

      (也就是执行子类的普通方法),但此时子类的引用变量为null时没有进行显式初始化,所以有可能导致null指针异常(如果在

      子类普通方法中使用子类的引用变量计算)。   



    最新内容请见作者的GitHub页:http://qaseven.github.io/

       

    展开全文
  • java--构造方法

    2015-07-09 13:57:59
     【修饰符】:构造方法的上一级单元是类,所以修饰符可以public、protected(父子类访问权限)、private(本类访问权限)、默认(包访问权限)  【没有返回类型】  【构造方法名】:必须与类名一致  a.一般概念 ...
  • java的构造方法!

    2014-01-18 16:23:38
     【修饰符】:构造方法的上一级单元是类,所以修饰符可以public、protected(父子类访问权限)、private(本类访问权限)、默认(包访问权限)  【没有返回类型】  【构造方法名】:必须与类名一致  a.一般概念  ...
  • 在此基础上,结合构造应力机制研究和区域构造应力场演化,采用平衡剖面技术解析查干凹陷的构造-沉积史,将该凹陷的构造和沉积演化序列划分为4个一级构造-沉积演化阶段和若干二级、三级构造-沉积演化阶段,进而分析了各...
  • 研究结果表明:将12号煤层划分为65个评价单元,其中地质构造复杂程度评价结果为Ⅰ、Ⅱ和Ⅲ的评价单元分别有18,7和40个,且垂向分布明显。评价结果与生产实际过程中已揭露的情况基本吻合,结合备采区域的瓦斯含量和瓦斯...
  •  【修饰符】:构造方法的上一级单元是类,所以修饰符可以public、protected(父子类访问权限)、private(本类访问权限)、默认(包访问权限)  【没有返回类型】  【构造方法名】:必须与类名一致  a.一般概念 ...
  • OO第四单元作业总结

    2019-06-22 19:01:00
    本次作业的架构采用了讨论区杨嘉成同学的建议,构造了MyClass, MyInterface, MyStateMachine, MyInteraction四个一级类用来包装相应的数据,同时构造了二级类MyOperation, MyAssociation。 MyClass ...
  • Fula坳陷内部次级构造单元包括南部断阶带、南部凹陷、中部构造带、北部凹陷和北部断阶带“三正两负”5个二级构造带。盆地断裂的差异活动控制着沉积地层厚度、水体深浅和沉积格局的变化。同裂谷早中期,Fula坳陷发育...
  • Data Manipulation Toolbox (dmtoolbox) 是个 MATLAB 工具箱,用于促进使用各种数据结构(如字符串、数组、元胞数组和... 映射(查找表) 构造映射(也称为字典、哈希表或循环表)并将标量或字符串映射到相应值的函数
  • 综合地质单元的地质特征、岩石学、变形变质特征和同位素年代学资料,对区内早前寒武纪的构造环境进行了初步研究;并在此基础上对该区的地壳演化和构造相相变成因进行了探讨。合理地解释了变质岩区普遍发生的所谓"同岩...
  • Spring是个轻量的框架,主要有**IOC(控制反转 )和AOP(面向切面)**两大核心内容。简化了开发,降低了开发的复杂度,同时可以整合其他的优秀的第三方框架或者类库,目前在大多数公司中都比较流行。 spring的...
  • 该方法使用逻辑功效模型分析乘法器的关键路径, 通过构造驱动能力更为完备的单元以实现关键路径中每一级门功效相等, 从而得到最短路径延时。将TSMC 90 nm标准单元库扩展得到扩展单元库, 使用两个单元库版图分别实现...
  • 领域模型的基本构造块: 1.实体(Entity):有业务生命周期,使用标识进行跟踪。...聚合是簇相关联的对象,出于封装的目的,将这些对象作为单元(业务、持久化和并发)。 2).每个聚合都...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 342
精华内容 136
关键字:

一级构造单元