定义类强化——移动的圆

1.构造一个Location类：

1)该类有两个double型私有成员变量x和y，分别表示横坐标和纵坐标；

2)该类有一个有参构造方法，能初始化成员变量x和y；

3)该类具有成员变量的x和y的访问方法和赋值方法。

2.构造一个Circle类：

1)该类有一个double型成员变量radius存放半径；

2)该类有一个Location型成员变量center，存放圆心坐标；

2)该类有一个有参构造方法Circle(double x, double y, double r)，初始化成员变量radius、center，其中center的初始化过程是：使用参数x和y创建类Location的实例，并将这个对象引用赋值给center；

3)该类具有translate(double tx, double ty) 方法，方法无返回值，这个方法能移动圆心坐标，使x坐标增加tx，y坐标增加ty。

4)该类具有overlaps(Circle other)方法，该方法返回值为boolean型，方法判定参数圆是否和当前圆重叠。如果两个圆圆心的距离小于两个圆半径的和则两个圆重叠。圆心距离由如下公式计算：距离= sqrt((x1-x2)^2 + (y1-y2)^2)。其中(x1,y1) and (x2,y2) 分别是两个圆的圆心坐标。

3.主类中，要求用户输入第一个圆的圆心的x、y坐标、半径，创建第一个Circle类对象，然后用户输入第二个圆的圆心的x、y坐标、半径，创建第二个Circle类对象。当两个圆没有重叠时，将第二个圆的x和y坐标都移动0.5，直到两个圆出现重叠为止。

裁判测试程序样例：

import java.util.Scanner;
public class Main {
     public static void main(String[] args) {
       Scanner scanner=new Scanner(System.in);      
       double x=scanner.nextDouble();
       double y=scanner.nextDouble();
       double r=scanner.nextDouble();
       Circle c1 = new Circle(x,y,r);
       x=scanner.nextDouble();
       y=scanner.nextDouble();
       r=scanner.nextDouble();
       Circle c2 = new Circle(x,y,r);
       System.out.println("Circle 1's center is at ("+c1.getCenter().getX()+","+c1.getCenter().getY()+") with a radius of "+c1.getRadius());
       System.out.println("Circle 2's center is at ("+c2.getCenter().getX()+","+c2.getCenter().getY()+") with a radius of "+c2.getRadius());
     
      while(!c1.overlaps(c2))
      {
          c2.translate(0.5, 0.5);
          System.out.printf("Circle 2's center is now at (%.1f,%.1f)\n",c2.getCenter().getX(),c2.getCenter().getY());
      }
      System.out.printf("The circles now overlap!");
      scanner.close();
   }
}

/* 请在这里填写答案 */

输入样例：

在这里给出一组输入。例如：

3 3 0.25
0 0 1

输出样例：

在这里给出相应的输出。例如：

Circle 1's center is at (3.0,3.0) with a radius of 0.25
Circle 2's center is at (0.0,0.0) with a radius of 1.0
Circle 2's center is now at (0.5,0.5)
Circle 2's center is now at (1.0,1.0)
Circle 2's center is now at (1.5,1.5)
Circle 2's center is now at (2.0,2.0)
Circle 2's center is now at (2.5,2.5)
The circles now overlap!

还是定义类的强化，基本的定义属性和构造器、方法，我们也不再多做介绍——需要细细了解的小伙伴，咱们移步前面的《定义类》

定义类：定义一个类Square表示正方形_定义一个square类,当客户访问该页面时,服务器创建该类的对象,只要客户给出正方形-CSDN博客

闲话少叙，正文开始： 

 直接肝的定义部分：

 

class Location
{
   private double x;
   private double y;//俩私有的成员变量

   public Location(double x,double y)
{
    this.x = x;
    this.y = y;
}//有参构造器

   public double getX()
{
    return x;
}
   public double getY()
{
    return y;
}//俩方法为成员变量的访问方法

   public void setX(double x)
{
    this.x = x;
}
   public void setY(double y)
{
    this.y = y;
}//俩方法为成员变量的赋值方法
   

}

Location类定义完成，接着是Circle类 

定义类：定义一个类Square表示正方形_定义一个square类,当客户访问该页面时,服务器创建该类的对象,只要客户给出正方形-CSDN博客

class Circle
{
   private double radius;//半径定义


}

划重点 

当本类中有个成员变量类型为——我们定义过的类 

可知，Location类是我们上面定义的第一个类，现在在Circle类中需要创建个成员变量，类型就是Location。

定义有一个Location型成员变量，名字叫center。意欲何为？存放圆心坐标。

怎么理解？既然center的类型是Location，center本身应该就是一个实例化的类——即对象。

对象怎么来？自然是创建：调用构造器。

至于存放圆心坐标，简直是个很妙的设计：就像一个数组，把x，y聚在一堆。但是又和数组不同，不需要下标，循环啥的访问。直接.操作符，要谁点谁。

代码长这样：

class Circle
{
   private double radius;//半径定义

   private Location center = new Location();//类中成员为另一类的实例对象，需要创建，new+构造器
}

发现前面没有默认构造器是不是？在前面添一个就是。

class Location{
public Location()
    {
        
    }//添加进去，我这里就不拷贝前面的了
}

 Circle类的有参构造器

“并将这个对象引用赋值给center”，意思就是把传过来的x,y赋值给center里面的x,y。

至于说引用赋值，就是传参——什么时候传参，自然是需要调用参数的方法里面。可见，题目上也暗示我们直接给人x,y赋值是行不通的。

还记得大明湖畔：公开访问和赋值私有成员变量的两个方法吗？setter和getter方法：公开是让你随时随地调用。

以后的题目，一般就默认说赋值，提示语句就不会有了。

咱们再看眼代码，就了然了。

class Circle
{
   private double radius;//半径定义
   private Location center = new Location();//类中成员为另一类的实例对象，需要创建，new+构造器
   public Circle(double x,double y,double radius)
   {
     this.center.setX(x);//“这个对象引用赋值”就是用center这个对象名，加上.操作符
     this.center.setY(y);//标准反面教材：this.center.x = x;要是center的x能被公开访问，这样写可以。可是上一个类里面，x属于private，不能在其他类里面公开访问，更别说赋值
     this.radius = radius;
     
}//有参构造器

   
}

举一反三：

 它的代码逻辑：也是改变x,y的值（赋值）

代码如下：

public void translate(double tx,double ty)
{
    this.center.setX(center.getX() + tx);
    this.center.setY(center.getY() + ty);//一定要在每个方法调用的时候，前面加上引用出处。咱们一般调用的是实例方法，缺少“实例”（对象名）也不行。这里的center.getY()
/*标准错误写法：this.center.x = center.x + tx;
               this.center.y = center.y + ty;又是公开访问私有变量*/


}

 正是返回好Boolean，判断时节又逢君（Math类）

:该类具有overlaps(Circle other)方法，该方法返回值为boolean型，方法判定参数圆是否和当前圆重叠。如果两个圆圆心的距离小于两个圆半径的和则两个圆重叠。圆心距离由如下公式计算：距离= sqrt((x1-x2)^2 + (y1-y2)^2)。其中(x1,y1) and (x2,y2) 分别是两个圆的圆心坐标。 

这题明眼就看出来，代码逻辑已经跃然纸上。

前面我们说会再次遇见Math类的俩方法，所谓念念不忘，必有回响：

public boolean overlaps(Circle other)//传参为一个对象，要的是里面的成员和方法
{
    double dis = 0.0;//俩圆心距离
dis = Math.sqrt(Math.pow((this.center.getX() - other.center.getX(),2 + Math.pow(this.center.getY() - other.center.getY(),2));
/*这个dis代码看着长，就是两部分，Math.pow() + Math.pow()，再对它俩和开方 */
    if(dis < this.radius + other.radius)
      return true;//boolean的值有俩：true,false(不是1和0)
    else
      return false;


}

this指的是本对象.里面的成员(center).成员里面的成员(x,y)。 --- 可千万不能忽略了谁

针对这种成员变量center的代码：

要点有3：

1.定义的时候，记得能创建就创建——创建什么？这个类的实例对象（center）

2.后面只要涉及这个对象里面的成员（x,y），不可直接调用，采用合法的访问和赋值方法。（setter和getter），要使用私有变量，优先考虑getter;赋值，就是setter

3.对这个对象的访问和赋值方法，写返回类型的是——它所属的类

实践出真知嘛，上面都是改出来的总结。

完整代码参考：

class Location
{
    private double x;
    private double y;
    public Location()
    {
        
    }

    public Location(double x,double y)
    {
        this.x =x;
        this.y = y;   
    }

    public void setX(double x)
    {
      this.x = x;
        
    }
    public void setY(double y)
    {
        this.y = y;
    }
    public double getX()
    {
        return x;
    }
    public double getY()
    {
        return y;
    }
    
}

class Circle
{
      private double radius;
      private Location center = new Location();

    public Circle(double x,double y,double r)
    {
       center.setX(x);//center 的初始化
       center.setY(y);
        radius = r;
    }
     public void translate(double tx,double ty)
     {
        center.setX(center.getX() + tx);
        center.setY(center.getY() + ty);
         
     }
    public boolean overlaps(Circle other)
    {
        double dis = 0.0;
        dis = Math.sqrt(Math.pow(other.center.getX() - this.center.getX(),2) + Math.pow(other.center.getY() - this.center.getY(),2));
        if(dis < other.radius + this.radius)
            return true;
        else
            return false;
        }
    public Location getCenter()
    {
        return center;
    }
    public double getRadius()
    {
        return radius;
    }
    
    


    
}