我们继续学习类与对象，上一篇我们定义了 坐标类（Point）,
这次我们在Point的基础上，创建一个圆类（Circle）.
案例:创建一个圆类
题目要求：
计算圆的周长和面积；求判断两个圆的位置关系，①两圆外离 d>R+r ②两圆外切 d=R+r
③两圆相交 R-r<d<R+r(R>r) ④两圆内切 d=R-r(R>r) ⑤两圆内含d<R-r(R>r)
解题思路：
1.圆的属性：圆心（用一个坐标来表示），半径
2.计算周长函数 perimeter
3.计算面积函数 area
4.判断两个圆的位置关系
5.进行测试
代码设计：
Point类（上次我们有一个测试函数，去掉or不去掉都可以，测试函数跟我们这次案例无关，但也不影响运行）
public class Point {
private double x; //成员变量
private double y;
/**
* 初始化方法
* @param x 横坐标
* @param y 纵坐标
*/
public void init(double x,double y){
this.x = x;
this.y = y;
}
/**
* @param p 计算距离的两个点之一（因为这个类自己本身就是一个坐标，所以调用 类自己的距离函数 的时候，只需要加入要比较的坐标即可）
* @return 距离
*/
public double distance(Point p){
return Math.sqrt(Math.pow((p.x-this.x),2)+Math.pow((p.y-this.y),2)); // 当前对象 p1.distance(p2)) this 表示的是 p1
}
}
圆类（Circle）（这个类里面有三个构造函数，构造函数的使用，是根据参数的不同）
构造函数，就是在新建一个对象时（即new一个对象的时候）直接赋值。
第一个构造函数没有参数
第二个构造函数 三个参数 r x y
第三个构造函数 两个参数 p(坐标) r(半径)，这个构造函数在调用的时候就需要，把p坐标初始化（即坐标的初始化函数init（））
其余的函数比较普通。
判断圆的位置关系时我们返回的byte值，在测试函数中根据返回值 来确定位置关系：1-外离 2-外切 3-相交 4-内切 5-内离
public class Circle {
private double r;
private Point p;// 圆心
/**
* 构造函数1，无参，直接进行赋值
*/
public Circle() {
p = new Point();
p.init(3,4);
r = 1;
System.out.println("第一个构造函数被自动调用了");
}
/**
* 构造函数2，三个参数
* @param r 初始化半径r
* @param x 初始化横坐标x
* @param y 初始化纵坐标y
*/
public Circle(double r, double x,double y){
Point p = new Point();
p.init(x,y);
this.p = p;
this.r = r;
System.out.println("第二个构造函数被自动调用了");
}
/**
* 构造函数(constructor)
* @param p 定义一个坐标
* @param r 初始化半径
*/
public Circle(Point p, double r){
this.p = p;
this.r = r;
System.out.println("第三个函数被调用了！");
}
/**
* 求面积
* @return 返回面积
*/
public double area( ){
return Math.PI*r*r;
}
/**
* 求周长
* @return 返回周长
*/
public double perimeter( ){
return Math.PI*r*2;
}
/**
* 判断当前圆与另一个圆的位置关系。 1-外离 2-外切 3-相交 4-内切 5-内离
* @param circle
* @return
*/
public byte position(Circle circle){
double dis = this.p.distance(circle.p); // 两个圆心的距离
double sumOfR = this.r + circle.r; // 半径和的距离
double subOfR = Math.abs(this.r-circle.r);
if (dis>sumOfR){
return 1;
}
if (Math.abs(sumOfR-dis)<1e-6) {
return 2;
}
if (dis>subOfR&&dis<sumOfR){
return 3;
}
if (Math.abs(dis-subOfR)<1e-6){
return 4;
}
if (dis <subOfR){
return 5;
}
return 0;
}
}
测试类 Test 进行测试（大家可以更改数据进行测试）
public class Test {
public static void main(String[] args) {
// c1我们在Circle中设置为： 半径 1， 圆心（3，4）
Circle c1 = new Circle(); // 调用第一种无参构造函数
//c2我们设置为: 圆心（0,0）,半径为4
Circle c2 = new Circle(4,0,0);//调用第二种构造函数，三个参数 r x y
//c3我们设置为 圆心（0,0） 半径为6
Point p = new Point(); // 调用第三种 ，两个参数 p r
p.init(0,0);
Circle c3 = new Circle(p,6);
System.out.println("c1的周长是： "+c1.perimeter());
System.out.println("c1的面积是： "+c1.area());
System.out.println("c2的周长是： "+c2.perimeter());
System.out.println("c2的面积是： "+c2.area());
String str ;
switch (c1.position(c2)){
case 1:
str = "外离 ";
break;
case 2:
str = "外切" ;
break;
case 3:
str = "相交";
break;
case 4:
str = "内切";
break;
case 5:
str = "内含";
break;
default:
str = " 0.0 ";
}
System.out.printf("两个圆的位置关系为%s :",str);
System.out.println();
}
}
测试结果：
收获总结：因为我们在Point类里面的初始化不是用的构造函数，在Circle类的构造函数要不断的 创建一个坐标（Point）对象（即new 一个Point）
所以我决定我把Point的 初始化方法 init() 也改为 构造函数。
Point类 修改如下：
把函数init 的函数名换位 Point(即类名) Ciecle类修改如下：（修改了构造函数1，和构造函数2，修改后的代码如下）
/**
* 构造函数1，无参，直接进行赋值
*/
public Circle() {
Point p = new Point(3,4);
this.p = p;
r = 1;
System.out.println("第一个构造函数被自动调用了");
} /**
* 构造函数2，三个参数
* @param r 初始化半径r
* @param x 初始化横坐标x
* @param y 初始化纵坐标y
*/
public Circle(double r, double x,double y){
Point p = new Point(x,y);
this.p = p;
this.r = r;
System.out.println("第二个构造函数被自动调用了");
}
Test函数因为 构造函数发生了改变，也随之发生了改变；
//c3我们设置为 圆心（0,0） 半径为6
Point p = new Point(0,0); // 调用第三种 ，两个参数 p r
Circle c3 = new Circle(p,6);
构造函数，就是在新建一个对象时（即new一个对象的时候）直接赋值。