java中关于矩形类

Posted 2023-04-06

创建矩形类Rectangle
存储两个顶点坐标（m_x1,m_y1,m_x2,m_y2)，构造方法接受2个顶点坐标的值，并调用设置方法setCoordinates将得到的坐标写入对应的属性中，设置方法setCoordinates检查坐标x和y值是否大于零，方法isRectangle()检验提供的坐标是否能构成矩形，根据检验结果设置m_isRectangle的值，并将检验结果输出到屏幕上。（有三种情况：1.两点坐标相同，构成一个点；2.两点坐标的x相同或y相同，只能构成矩形的一边；3.两点坐标分别喂矩形两个对角顶点坐标）提供计算height、width、perimeter、area的方法。加入判断方法isSquare，以确定此矩形是否为正方形。该类是公共的，保存文件名为Rectangle2.java，再编译主类Rectangle2Test测试它
属性：
private double m_height;
private double m_width;
private double m_x1;
private double m_y1;
private double m_x2;
private double m_y2;
private boolean m_isRectangle;
操作：
public Rectangle2();
public Rectangle2(double aX1,double aY1,double aX2,double aY2);
public void setCoordinates(double aX1,double aY1,double aX2,double aY2);
public boolean isRectangle();
public boolean isSquare();
private void setHeight();
private void setWidth();
public double getHeight();
public double getWidth();
public double perimeter();
public double area();

public class Rectangle2
// 属性：
private double m_height;
private double m_width;
private double m_x1;
private double m_y1;
private double m_x2;
private double m_y2;
private boolean m_isRectangle;

// 操作：
public Rectangle2()
this(0.0, 0.0, 0.0, 0.0);


public Rectangle2(double aX1, double aY1, double aX2, double aY2)
setCoordinates(aX1, aY1, aX2, aY2);


public void setCoordinates(double aX1, double aY1, double aX2, double aY2)
m_x1 = aX1;
m_y1 = aY1;
m_x2 = aX2;
m_y2 = aY2;

setHeight();
setWidth();
isRectangle();


public boolean isRectangle()
if ((m_height >= 0 && m_width >= 0) && (m_x1 != m_x2 || m_y1 != m_y2))
System.err.println("输入的坐标构成一个矩形");
m_isRectangle = true;
else
if ((m_x1 == m_x2 && m_y1 != m_y2)
|| (m_x1 != m_x2 && m_y1 == m_y2))
System.err.println("输入的坐标构成一条直线");
else if (m_x1 == m_x2 && m_y1 == m_y2)
System.err.println("输入的坐标构成一点");

m_isRectangle = false;

return m_isRectangle;


public boolean isSquare()
return isRectangle() && m_height == m_width;


private void setHeight()
double side1 = Math.abs(m_x1 - m_x2);
double side2 = Math.abs(m_y1 - m_y2);
m_height = side1 >= side2 ? side1 : side2;


private void setWidth()
double side1 = Math.abs(m_x1 - m_x2);
double side2 = Math.abs(m_y1 - m_y2);
m_width = side1 <= side2 ? side1 : side2;


public double getHeight()
return m_height;


public double getWidth()
return m_width;


public double perimeter()
return 2 * (m_height + m_width);


public double area()
return m_height * m_width;



public class Rectangle2Test
public static void main(String[] args)
// TODO Auto-generated method stub
Rectangle2 rect1 = new Rectangle2();
System.err.println(rect1.isRectangle());
System.err.println(rect1.isSquare());
System.err.println(rect1.getHeight());
System.err.println(rect1.getWidth());
System.err.println(rect1.perimeter());
System.err.println(rect1.area());
Rectangle2 rect2 = new Rectangle2(22, 33, 66, 99);
System.err.println(rect2.isRectangle());
System.err.println(rect2.isSquare());
System.err.println(rect2.getHeight());
System.err.println(rect2.getWidth());
System.err.println(rect2.perimeter());
System.err.println(rect2.area());

参考技术A 这种帖子
拒绝回答

java 中关于继集合类的整理

之前看过一些关于Java集合类的内容，但是过段时间不用有些就忘记了，现在整理下以后看也方便，只是给自己当笔记看的~~~~

（转载了一些注明：http://www.cnblogs.com/leeplogs/p/5891861.html）

一般地，我们常用的集合类有这几种：

List结构的集合类：ArrayList类，LinkedList类，Vector类，Stack类

Map结构的集合类：HashMap类，Hashtable类

Set结构的集合类：HashSet类，TreeSet类

Queue结构的集合：Queue接口

 

首先呢，我们来看看为什么要用集合类，这就要说说集合类与数组的关系了。数组（可以存储基本数据类型）是用来存现对象的一种容器，但是数组的长度固定，不适合在对象数量未知的情况下使用。

集合（只能存储对象，对象类型可以不一样）的长度可变，可在多数情况下使用。   集合的底层，是如何实现可变长度的，这里我们后面再来分析，。。。

 

一.Java集合框架图可见下图（实线边框的是实现类，折线边框的是抽象类，而点线边框的是接口）

 

 

在Java类库中，集合类的基本接口是Collection接口。这个接口有两个基本方法：

public interface Collection<E>
{
   boolean add(E element);
   Iterator<E> iterator();
   ...
}

add()方法就是添加元素了，而Iterator方法用于返回一个实现了Iterator接口的对象。 我们可以使用这个迭代器的对象一次访问集合中的元素。

而Iterator接口包含4个方法：

public interface Iterator<E>
{
   E next();
   boolean hasNext();
   void remove();
   default void forEachRemaning(Consumer<? super E> action);
}

 通过反复调用next方法，可以逐个访问集合中的每个元素。 如果到了集合末尾，next方法将会抛出一个NoSuchElementException.所以在调用next之前需要先调用一下hasNext()方法。

例如：

Collection<String> c  = ...;
Iterator<String> itra = c.iterator();
while(itra.hasNext())
{
  String element = itra.next();
  do something with element...
}

或者用foreach:

for(element:c)
{
   do something with element;
}

 

二. 集合有两个基本接口：  Collection 和  Map

Collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。但是却让其被继承产生了两个接口，就是Set和List。Set中不能包含重复的元素。List是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式。

Map是Java.util包中的另一个接口，它和Collection接口没有关系，是相互独立的，但是都属于集合类的一部分。Map包含了key-value对。Map不能包含重复的key，但是可以包含相同的value。

 

三.几个具体的接口和实现类

1. List（有序，可重复）

    类似于顺序表，元素会增加到容器中的特定位置，可以采用两种方式访问元素：1.迭代器  2.使用一个整数索引来访问。   后一种方式称为随机访问（random access），因为这样可以按任意顺序访问元素。List 查询数据快，但是插入，删除数据时速度很慢。

    List 总用于随机访问的方法：

void add(int index. E element)
void remove(int index)
E get(int index)
E set(int index, E element)

2.Set(无序，不可重复)

Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。

3.Map(键值对，键唯一，值不唯一)

Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。

对比如下：

 

四.具体的集合

 1. LinkedList  链表

在java中，所有的链表实际都是双向链接的（doubly linked）， 即每个结点还存放着指向前驱结点的引用。

下面的代码中先是添加了3个元素，然后删去第二个位置的元素：

1         List<Integer> staff = new LinkedList<>();
2         staff.add(10);
3         staff.add(25);
4         staff.add(48);
5         Iterator iter = staff.iterator();
6         int a = (int) iter.next();
7         int b = (int) iter.next();
8         iter.remove();

LinkedList.add方法将对象添加到链表的尾部，但是，我们常常需要将元素添加到链表中间，这时候我们就需要用到迭代器了。

LinkedList类的 ListIteration方法 返回 一个实现了ListIterator接口的迭代器对象。 接下来演示一下越过链表中的第一个元素，在第二个元素之前添加元素。

List<String> staff =new LinkedList<>();
staff.add("A");
staff.add("B");
staff.add("C");
ListInterator<String> iter = staff.listIterator();
iter.next();
iter.add("D");

set方法：

 1         List<String> staff =new LinkedList<>();
 2         staff.add("A");
 3         staff.add("B");
 4         staff.add("C");
 5         ListIterator<String> iter = staff.listIterator();
 6         iter.next();
 7         iter.add("D");
 8         iter.add("E");
 9         String oldValue = iter.next();    返回的上一个元素
10         iter.set("F");
11         System.out.println(oldValue);     //B   ADEFC

get方法：

List<String> staff =new LinkedList<>();
String bb = staff.get(2);
System.out.println(bb);

当然这种方法效率极低，因为这是链表啊，。。

最后，分析下我们为什么要使用链表呢？

因为使用链表可以减少在列表中间插入或者删除元素所付出的代价，如果元素较少，那么完全可以使用ArrayList。 如果需要对集合中的元素进行随机访问，那么就使用ArrayList()或者数组。

 

篇幅过长，换一页吧：   http://www.cnblogs.com/lzynuaa/p/7256833.html   。