[关闭]
@Sarah 2015-11-05T17:43:23.000000Z 字数 7499 阅读 1294

Java 构造函数 equals() 面向对象 圆

java笔记
面向对象 OOP
java c++ OC

类：模板
对象：实现

类似电脑包括硬盘/cpu/软盘，要制作硬盘有个模板（类），不同的硬盘具体不一样（对象）

主程序→ 发消息→ 【对象】→ 发消息→ 【对象】
⬇
发消息
⬇
【对象】

  1. class 名称{第一个字母大写 多个英文词
  2. 成员 【变量定义：多个】
  3.      【函数定义：多个】
  4.      }
 这里的变量之后还要实例化 
 每个新的对象都包括变量 和函数

  1. 变量：类型 名称；
  2.       类型 名称=初始；
  4. 函数：返回值类型 名称 （[参数]）{
  5.       代码
  6. }

大案例：
定义二位坐标点类point

  1. class point{
  2.     int x,y;
  3.   //改变点的数值
  4.     setX(int x){} 
  5.     setY(int y){}
  6.   //求两点距离
  7.     distance(){}
  8.   //求关于原点对称点
  9.     getApoint(){}
  10.   //两点是否相等
  11.     equals(){}

piont p ←发消息← p赋值

构造函数：名称=类名，无返回说明
函数重载：同名的两个函数
封装：内部的数据、代码

override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。
重写（覆盖）的规则：
1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.
2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。
3、重写的方法的返回值必须和被重写的方法的返回一致；
4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；
5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。
6、静态方法不能被重写为非静态的方法（会编译出错）。

overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。
重载的规则：
1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；

多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。
一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。

构造函数是一个计算机术语，是一种特殊的方法，主要用来在创建对象时初始化对象，构造函数的命名必须和类名完全相同，而一般方法则不能和类名相同。特别的一个类可以有多个构造函数 ，可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载。一个班级有学生，有的是TA有的是拿奖学金的，为了能够把每一个学生类型匹配，需要构造函数来建立不同的参数把他们对应起来。
1构造方法必须与所在的类有相同的名字
2构造方法没有返回类型，连void也没有
3构造方法的调用是创建一个对象时使用new进行的，构造方法的作用是初始化对象。

构造方法(constructor )是一种特殊的方法
• 用来初始化(new)该类的一个新的对象
• 构造方法和类名同名,而且不写返回数据类型。

  1. Person( String n, int a ){ 
  2. name = n;
  3. age = a;
  4. }

一般情况下,类都有一个至多个构造方法
• 如果没有定义任何构造方法,系统会自动产生一个构造方法,称为默认构造方法(default constructor)。
• 默认构造方法不带参数,并且方法体为空。



equals() 判断是否相等
toString() 转换成字符串输出

  2. public class Point {
  3.     int x,y;
  4.     Point(){
  6.     }
  7.     Point(int bb){
  9.     }
  10.     Point(int xx,int yy){
  11.         x=xx;
  12.         y=yy;
  13.     }
  15.     void setX(long xx){
  16.         x=(int)xx;
  17.     }
  19.     void setX(int xx){
  20.         x=xx;
  21.     }
  22.     void setY(int yy){
  23.         y=yy;
  24.     }
  25.     Point getApoint(){
  26.         Point q=new Point(-x,-y);
  28.         return q;
  29.     }
  30.     double distance(Point p2){
  31.         double d=0;
  32.         d=Math.sqrt((x-p2.x)*(x-p2.x)+(y-p2.y)*(y-p2.y));
  33.         return d;
  34.     }
  35.     boolean equals(Point p3){
  36.         if (p3.x==x && p3.y==y) {
  37.             return true;
  39.         }
  40.         else {
  41.             return false;
  42.         }
  43.     }
  46.     public String toString(){
  47.         return  "("+x+","+y+")";
  48.     }
  49. }
  50.     //不要再这里输出打印任何东西
  2. public class Main {
  3.     public static void main(String[] args) {
  4.         Point p;
  5.         p=new Point(10);
  6. //      System.out.println("x="+p.x+"\ty="+p.y);
  7.         p.setX(100l);
  8. //      System.out.println("x="+p.x+"\ty="+p.y);
  9.         p.setY(-100);
  10.         System.out.println("p:"+p.toString());
  11.         Point t=p.getApoint();
  12.         System.out.println("ttttt:"+t);
  13.         Point q=t.getApoint();
  14.         System.out.println("q.x="+p.x+"\tq.y="+p.y);
  15.         System.out.println( q.distance( t) );
  16.         System.out.println(p.equals(t));
  17.         System.out.println(p.equals(q));
  19.     }
  20. }

关于圆的关系
我写的有错误的代码

  1. package Circle;
  3. import java.awt.Point;
  6. public class Circle {
  7.     int x, y;
  8.     int r;
  9.     Point center;
  10.     int radius;
  12.     Circle() {
  13.         center = new Point();
  14.         radius = 1;
  15.     }
  17.     Circle(int x, int y) {
  19.         radius = 0;
  20.     }
  22.     Circle(int xx, int yy, int r) {
  23.         center = new Point(xx, yy);
  24.         radius = r;
  25.     }
  27.     Circle(Point p, int r) {
  28.         center = p;
  29.         radius = r;
  30.     }
  32.     Point setCenter(Point p1) { // 设置圆心坐标
  33.         x = p1.x;
  34.         y = p1.y;
  35.         return p1;
  36.     }
  38.     void setR(int rr) { // 设置圆的半径
  39.         radius = rr;
  40.     }
  42.     double getArea(int r) { // 求面积
  43.         return radius * radius * 3.1415926;
  44.     }
  46.     int relation(Circle c) {
  47.         double distance = Math.sqrt((x - c.x) * (x - c.x) + (y - c.y)
  48.                 * (y - c.y));
  49.         int k = 0;
  50.         if (distance > r + c.r) {
  51.             return k = 0;
  52.         } else if (distance == r + c.r) {
  53.             return k = 1;
  54.         } else if (r - c.r < distance && distance < r + c.r) {
  55.             return k = 2;
  56.         } else if (distance == r - c.r) {
  57.             return k = 3;
  58.         } else {
  59.             return k = 4;
  60.         }
  62.     }
  64.     boolean equals(Circle c2) { // 判断两个圆是否相等
  65.         if (c2.x == x && c2.y == y && c2.r == r) {
  66.             return true;
  67.         } else {
  68.             return false;
  69.         }
  70.     }
  72.     public String toString() {
  73.         return "(" + x + "," + y + "," + r + ")";
  74.     }
  76. }
  1. package Circle;
  3. import java.awt.Point;
  5. public class Main {
  7.     public static void main(String[] args) {
  9.         Point p1 = new Point();
  10.         p1.x=5;
  11.         p1.y=4;
  13.         Point p2 = new Point();
  14.         p2.x=6;
  15.         p2.y=7;
  17.         int r1 = 5;
  19.         Circle c1 = new Circle(p1, 8);
  21.         Circle c2 = new Circle();
  22.         c2.x=5;
  23.         c2.y=6;
  24.         c2.r=9;
  26.         Circle c3 = new Circle();
  27.         c3.x=5;
  28.         c3.y=6;
  29.         c3.r=7;
  33. //      p1.setCenter(p2); 有错
  34. //      System.out.println("P1:"+p1);
  36. //      c3.setR(9); 有错
  37. //      System.out.println("C3:"+c3.toString());
  40. //      System.out.println(c2.getArea(r1)); 有错
  42.         System.out.println(c2.relation(c1));
  43.         System.out.println(c1.equals(c2));
  44.         System.out.println("C2:"+c2.toString());
  45.     }
  47. }

我改了一次以后的代码

  1. package Circle;
  3. import java.awt.Point;
  6. public class Circle {
  7.     int x, y;
  8.     Point center;
  9.     int radius;
  11.     Circle() {
  13.     }
  15.     Circle(int xx, int yy) {
  16.         x=xx;
  17.         y=yy;
  18.         radius = 0;
  19.     }
  21.     Circle(int xxx, int yyy, int rr) {
  22.         x=xxx;
  23.         y=yyy;
  24.         radius = rr;
  25.     }
  27.     Circle(Point p, int rrr) {
  28.         x = p.x;
  29.         y=p.y;
  30.         radius = rrr;
  31.     }
  33.     Point setCenter(Point p1) { // 设置圆心坐标
  34.         x = p1.x;
  35.         y = p1.y;
  36.         return p1;
  37.     }
  39.     void setR(int rr) { // 设置圆的半径
  40.         radius = rr;
  41.     }
  43.     double getArea(int radius) { // 求面积
  44.         return radius * radius * 3.1415926;
  45.     }
  47.     int relation(Circle c) { //求两圆关系
  48.         double distance = Math.sqrt((x - c.x) * (x - c.x) + (y - c.y)
  49.                 * (y - c.y));
  50.         int k = 0;
  51.         if (distance > radius + c.radius) {
  52.             return k = 0;
  53.         } else if (distance == radius + c.radius) {
  54.             return k = 1;
  55.         } else if (radius - c.radius < distance && distance < radius + c.radius) {
  56.             return k = 2;
  57.         } else if (distance ==radius - c.radius) {
  58.             return k = 3;
  59.         } else {
  60.             return k = 4;
  61.         }
  63.     }
  65.     boolean equals(Circle c2) { // 判断两个圆是否相等
  66.         if (c2.x == x && c2.y == y && c2.radius == radius) {
  67.             return true;
  68.         } else {
  69.             return false;
  70.         }
  71.     }
  73.     public String toString() {
  74.         return "(" + x + "," + y + "," + radius + ")";
  75.     }
  77. }
  1. package Circle;
  3. import java.awt.Point;
  5. public class Main {
  7.     public static void main(String[] args) {
  9.         Point p1 = new Point();
  10.         p1.x=5;
  11.         p1.y=4;
  13.         Point p2 = new Point();
  14.         p2.x=6;
  15.         p2.y=7;
  17.         int radius = 5;
  19.         Circle c1 = new Circle(p1, 8);
  21.         Circle c2 = new Circle();
  22.         c2.x=5;
  23.         c2.y=6;
  24.         c2.radius=9;
  26.         Circle c3 = new Circle();
  27.         c3.x=4;
  28.         c3.y=8;
  29.         c3.radius=7;
  33. //      p1.setCenter(p2);
  34. //      System.out.println("P1:"+p1);
  36.         c3.setR(5); 
  37.         System.out.println("C3: "+c3.toString());
  40.         System.out.println("圆的面积是: "+c2.getArea(c2.radius)); 
  41.         System.out.println("两个圆的关系: "+c2.relation(c1));
  42.         System.out.println("两圆是否相等: "+c1.equals(c2));
  43.         System.out.println("C2:  "+c2.toString());
  44.     }
  46. }

更改以后的答案

  1. package Circle;
  4. public class Circle {
  5.     Point center;
  6.     int radius;
  7. //不要设置乱七八糟的x y变量了！因为圆里的center引用的点对象包括了x y，所以只要设点对象就好，之后召唤的时候用center.x/center.y即可
  9.     Circle() {
  10.         center=new Point(0,0);
  11.     }
  13.     Circle(int xx, int yy) {
  14.         center=new Point(xx,yy);//这里需要new出一个新的内存空间，否则会没地方存储数据（null）
  15.         radius = 0;
  16.     }
  18.     Circle(int xx, int yy, int rr) {
  19.         center=new Point(xx,yy);
  20.         radius = rr;
  21.     }
  23.     Circle(Point p, int rrr) {
  24.         center=p;
  25.         radius = rrr;
  26.     }
  28.     void setCenter(Point p1) { // 设置圆心坐标
  29.         center=p1;
  30.     }
  32.     void setR(int rr) { // 设置圆的半径
  33.         radius = rr;
  34.     }
  36.     double getArea() { // 求面积
  37.         return radius * radius * 3.1415926;
  38.     }
  40.     int relation(Circle c) { //求两圆关系
  41.         double distance = center.distance(c.center); //重要 ※ 记住
  42.         if (equals(c))
  43.             return 5;
  44.         else if (distance > radius + c.radius) {
  45.             return  0;
  46.         } else if (distance == radius + c.radius) {
  47.             return 1;
  48.         } else if (radius - c.radius < distance && distance < radius + c.radius) {
  49.             return  2;
  50.         } else if (distance ==radius - c.radius) {
  51.             return  3;
  52.         } else {
  53.             return  4;
  54.         }
  56.     }
  58.     boolean equals(Circle c2) { // 判断两个圆是否相等
  59.         if (c2.center.x == center.x && c2.center.y == center.y && c2.radius == radius) {
  60.             return true;
  61.         } else {
  62.             return false;
  63.         }
  64.     }
  66.     public String toString() {
  67.         return "{" + center + "," + radius + "}";
  68.     }
  70. }
  1. package Circle;
  3. public class Point {
  4.     int x,y;
  5.     private Point(){
  6.         this(0,0);
  7.     }
  8.     public Point(int bb){
  10.     }
  11.     public Point(int x,int y){ 
  12.         this.x=x;
  13.         this.y=y;
  14.     }
  15.     Point getPoint(){
  16.         Point p=new  Point();
  17.         p.setX(-x);
  18.         p.setY(-y);
  19.         return p;
  21.     }
  22.     public void setX(long xx){
  23.         x=(int)xx;
  24.     }
  26.     void setX(int xx){
  27.         x=xx;
  28.     }
  29.     void setY(int yy){
  30.         y=yy;
  31.     }
  32.     Point getApoint(){   //新函数 返回值是point
  33.         Point q=new Point(-x,-y);
  35.         return q;
  36.     }
  37.     public double distance(Point p2){ //point是原来的点坐标，p2是另一点的坐标
  38.         double d=0;
  39.         d=Math.sqrt((x-p2.x)*(x-p2.x)+(y-p2.y)*(y-p2.y));
  40.         return d;
  41.     }
  42.     public boolean equals(Point p3){
  43.         if (p3.x==x && p3.y==y) {
  44.             return true;
  46.         }
  47.         else {
  48.             return false;
  49.         }
  50.     }
  52.     public String toString(){
  53.         return  "["+x+","+y+"]";
  54.     }
  55.     public int getX(){
  56.         return x;
  58.     }
  59.     public int getY() {
  60.         return y;
  61.     }
  63. }
  1. package Circle;
  3. public class Main {
  5.     public static void main(String[] args) {
  6.         Point p1 = new Point(0, 4);//这里new出了新空间
  7.         p1.x = 5;
  8.         p1.y = 4;
  10.         Point p2 = new Point(6, 7);//new出空间存放数据
  11.         // p2.x=6;
  12.         // p2.y=7;
  14.         int radius = 5;
  16.         Circle c1 = new Circle(p1, 8);
  18.         Circle c2 = new Circle();
  19.         System.out.println(c2.center);
  20.         System.out.println(c2.center.x);
  21.         c2.setCenter(new Point(5, 6));
  22.         c2.radius = 9;
  24.         Circle c3 = new Circle(10, 10);
  25.         c3.radius = 7;
  27.         c3.setCenter(p2);
  28.         System.out.println("P1:" + p1);//是圆里的这点
  30.         c3.setR(5);
  31.         System.out.println("C3: " + c3.toString());
  33.         System.out.println("圆的面积是: " + c2.getArea());
  34.         System.out.println("两圆是否相等: " + c1.equals(c2));
  35.         System.out.println("C2:  " + c2.toString());
  36.         System.out.println("C1:  " + c1.toString());
  37.         int r = c1.relation(c2);
  38.         System.out.print("c1,c2两个圆的关系: ");
  39.         switch (r) { //用switch语句打印，能针对不同情况打印出更多的内容
  40.         case 0:
  41.             System.out.println("相离");
  42.             break;
  43.         }
  44.     }
  46. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注