java学习-初级入门-面向对象④-类与对象-类与对象的定义和使用2

我们继续学习类与对象，上一篇我们定义了  坐标类（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一个对象的时候）直接赋值。