「java环形关系」java实现环形队列
本篇文章给大家谈谈java环形关系，以及java实现环形队列对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、java 编写一个环形类 求环的面积
- 2、java小白 环形链表中连续的创建的对象不会消失么或者说是怎么不消失的
- 3、java程序编程题
- 4、java 类与类之间的关系 及uml图
- 5、java 判断链表是否有环
- 6、JAVA中如何用graphics 作圆环
java 编写一个环形类 求环的面积
public class Ring
{
private double innerR;
private double outR;
public void setDate(double outR)
{
this.outR = outR;
}
public double getArea()
{
return Math.PI*outR*outR;
}
public static void main(String[] args)
{
Ring ring1 = new Ring();
ring1.setDate(2);
Ring ring2 = new Ring();
ring2.setDate(4);
System.out.println("第一个环面积为：" + ring1.getArea());
System.out.println("第二个环面积为：" + ring2.getArea());
}
}
java小白 环形链表中连续的创建的对象不会消失么或者说是怎么不消失的
JAVA有自己的内存回收机制的，不支持使用者直接释放内存。题主说的，一般在程序结束才能回收这些child的（本质还是对象被引用），如果想释放内存，可以考虑将对象赋值为空。发现回答半天还没楼下一句话好，，，，
java程序编程题
public class Ring {
private double outerRadius;
private double innerRadius;
private String color;
public Ring() {
}
public Ring(double outerRadius, double innerRadius, String color) {
this.outerRadius = outerRadius;
this.innerRadius = innerRadius;
this.color = color;
}
public double getOuterRadius() {
return outerRadius;
}
public void setOuterRadius(double outerRadius) {
this.outerRadius = outerRadius;
}
public double getInnerRadius() {
return innerRadius;
}
public void setInnerRadius(double innerRadius) {
this.innerRadius = innerRadius;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getArea(){
//计算环形面积
double outer = Math.PI * Math.pow(outerRadius, 2);
double inner = Math.PI * Math.pow(innerRadius, 2);
return outer - inner;
}
}
java 类与类之间的关系 及uml图
1.关联
关联即对象与对象之间的连接。java类之间的关联是一个类的作为另一个的属性被定义，即“has-a”的关系。关联又分为组合与聚合两种。示例如下：
//两个类之间的聚合public class Car{}public class Person{
private Car car;
}//两个类之间的组合public class Car{}public class Person{
private Car car=new Car();//创建一个Car对象}123456789101112
关联又分为单向关联与双向关联，以上代码为单向关联(Person类关联Car类)，双向关联(Person类关联Car类，同时Car类关联Person类)代码如下：
public class Car{
private Person per;
}public class Person{
private Car car;
}123456
类之间的关联，可以一对一的关联，也可以一对多的关联。
2.依赖
依赖的具体表现是将一个类的对象当做方法参数传给另一个类的方法，是一种use-a的关系。如：
public class Person{
public void dirve(Car car){
}
}1234
关联与依赖的区别在于:关联是has-a的关系，依赖是use-a的关系;而且关联中Person关联Car，只要Person类对象存在，Car对象就存在;依赖中只有Person类对象调用到dirve()方法时，Car对象才会被创建，方法执行结束后，Car对象就被收回。
3.继承
类与类的另一个关系是继承。继承是一个类的定义基于另一个存在的类，即子类基于父类，如此可实现代码的重用，子类能够继承父类可访问的方法、属性，并能扩展新的能力，而且子类可重写父类方法以满足子类需要。在继承中子类可调用父类的构造方法，子类构造方法总是先调用父类的构造方法，而且默认情况下调用父类的无参构造方法，在子类构造方法的第一行使用super关键字即可调用父类构造方法。示例代码如下：
public class Point {
private double x; private double y; public double getX() { return x;
} public void setX(double x) { this.x = x;
} public double getY() { return y;
} public void setY(double y) { this.y = y;
} //无参构造方法
public Point() {
} //有参构造方法
public Point(double x, double y) { this.x = x; this.y = y;
} //draw（）方法
public void draw(){
}
}public class Circle extends Point {
private double r; public double getR() { return r;
} public void setR(double r) { this.r = r;
} //有参构造方法
public Circle(double x, double y) { super(x, y);
} public void draw() {
System.out.println("半径为：" + this.r + " x坐标为：" + getX() + " y坐标为：" + getY() + "的圆绘制成功！");
}
}public class Test {
public static void main(String[] args) {
Circle circle = new Circle(2, 3);
circle.setR(3);
circle.draw();
}
}
java 判断链表是否有环
方法一：首先从头节点开始，依次遍历单链表的每一个节点。每遍历到一个新节点，就从头节点重新遍历新节点之前的所有节点，用新节点ID和此节点之前所有节点ID依次作比较。如果发现新节点之前的所有节点当中存在相同节点ID，则说明该节点被遍历过两次，链表有环；如果之前的所有节点当中不存在相同的节点，就继续遍历下一个新节点，继续重复刚才的操作。
例如这样的链表：A-B-C-D-B-C-D， 当遍历到节点D的时候，我们需要比较的是之前的节点A、B、C，不存在相同节点。这时候要遍历的下一个新节点是B，B之前的节点A、B、C、D中恰好也存在B，因此B出现了两次，判断出链表有环。
假设从链表头节点到入环点的距离是D，链表的环长是S。D+S是链表总节点数。那么算法的时间复杂度是0+1+2+3+….+(D+S-1) = (D+S-1)*(D+S)/2 ， 可以简单地理解成 O(N*N)。而此算法没有创建额外存储空间，空间复杂度可以简单地理解成为O(1)。
方法二：首先创建一个以节点ID为键的HashSet集合，用来存储曾经遍历过的节点。然后同样是从头节点开始，依次遍历单链表的每一个节点。每遍历到一个新节点，就用新节点和HashSet集合当中存储的节点作比较，如果发现HashSet当中存在相同节点ID，则说明链表有环，如果HashSet当中不存在相同的节点ID，就把这个新节点ID存入HashSet，之后进入下一节点，继续重复刚才的操作。
这个方法在流程上和方法一类似，本质的区别是使用了HashSet作为额外的缓存。
假设从链表头节点到入环点的距离是D，链表的环长是S。而每一次HashSet查找元素的时间复杂度是O(1), 所以总体的时间复杂度是1*(D+S)=D+S，可以简单理解为O(N)。而算法的空间复杂度还是D+S-1，可以简单地理解成O(N)。
方法三：首先创建两个指针1和2（在java里就是两个对象引用），同时指向这个链表的头节点。然后开始一个大循环，在循环体中，让指针1每次向下移动一个节点，让指针2每次向下移动两个节点，然后比较两个指针指向的节点是否相同。如果相同，则判断出链表有环，如果不同，则继续下一次循环。
例如链表A-B-C-D-B-C-D，两个指针最初都指向节点A，进入第一轮循环，指针1移动到了节点B，指针2移动到了C。第二轮循环，指针1移动到了节点C，指针2移动到了节点B。第三轮循环，指针1移动到了节点D，指针2移动到了节点D，此时两指针指向同一节点，判断出链表有环。
此方法也可以用一个更生动的例子来形容：在一个环形跑道上，两个运动员在同一地点起跑，一个运动员速度快，一个运动员速度慢。当两人跑了一段时间，速度快的运动员必然会从速度慢的运动员身后再次追上并超过，原因很简单，因为跑道是环形的。
package demo6;import java.util.HashMap;import demo6.LinkReverse2.Node;/**
* 判断链表是否有环的方法
* @author mengfeiyang
*
*/public class LinkLoop {
public static boolean hasLoop(Node n){ //定义两个指针tmp1,tmp2
Node tmp1 = n;
Node tmp2 = n.next; while(tmp2!=null){ int d1 = tmp1.val; int d2 = tmp2.val; if(d1 == d2)return true;//当两个指针重逢时，说明存在环，否则不存在。
tmp1 = tmp1.next; //每次迭代时，指针1走一步，指针2走两步
tmp2 = tmp2.next.next; if(tmp2 == null)return false;//不存在环时，退出
} return true; //如果tmp2为null，说明元素只有一个，也可以说明是存在环
} //方法2：将每次走过的节点保存到hash表中，如果节点在hash表中，则表示存在环
public static boolean hasLoop2(Node n){
Node temp1 = n;
HashMapNode,Node ns = new HashMapNode,Node(); while(n!=null){ if(ns.get(temp1)!=null)return true; else ns.put(temp1, temp1);
temp1 = temp1.next; if(temp1 == null)return false;
} return true;
} public static void main(String[] args) {
Node n1 = new Node(1);
Node n2 = new Node(2);
Node n3 = new Node(3);
Node n4 = new Node(4);
Node n5 = new Node(5);
n1.next = n2;
n2.next = n3;
n3.next = n4;
n4.next = n5;
n5.next = n1; //构造一个带环的链表,去除此句表示不带环
System.out.println(hasLoop(n1));
System.out.println(hasLoop2(n1));
}
}
执行结果：truetrue
JAVA中如何用graphics 作圆环
package zhidao;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JApplet;
import javax.swing.JLabel;
public class Circle extends JApplet {
class Canvas extends JLabel {
public Canvas() {
}
@Override
public void paint(Graphics g) {
super.paint(g);
int w=getWidth();
int h=getHeight();
for (int i = 0; i 10; i++) {
g.setColor(randColor());
int radius=(int)(Math.random()*51+80);
int x=(int)(Math.random()*(w-radius*2));
int y=(int)(Math.random()*(h-radius*2));
Ring ring = new Ring(x, y, radius,(float)(Math.random()/2+0.5));
ring.paint(g);
}
}
}
private Color randColor(){
int r=(int)(Math.random()*256);
int g=(int)(Math.random()*256);
int b=(int)(Math.random()*256);
return new Color(r,g,b);
}
public Circle() {
}
@Override
public void init() {
super.init();
setSize(500, 500);
getContentPane().add(new Canvas(), BorderLayout.CENTER);
}
}
class Ring {
private int x;
private int y;
// 外径
private int radius;
// 内径因子
private float factor;
public int getX() {
return x;
}
public int getY() {
return y;
}
public Ring(int x, int y, int radius, float factor) {
super();
this.x = x;
this.y = y;
this.radius = radius;
if (factor 0 || factor 1)
throw new IllegalArgumentException();
this.factor = factor;
}
public int getInsideRadius() {
return (int) (radius * factor + 0.5f);
}
public int getRadius() {
return radius;
}
public void paint(Graphics g) {
g.fillOval(x, y, radius, radius);
int iWidth = getInsideRadius();
int dif = Math.round((radius - iWidth) / 2f);
Color recent = g.getColor();
g.setColor(new Color(not(recent.getRGB())));
g.fillOval(x + dif, y + dif, iWidth, iWidth);
g.setColor(recent);
}
private int not(int color) {
return (~color) 0xffffff;
}
}
关于java环形关系和java实现环形队列的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
发布于：2022-12-24，除非注明，否则均为原创文章，转载请注明出处。