java培训-----第三天

homework：定义一“圆”Circle类，圆心为“点”Point类，构造一圆，求圆的周长和面积，并判断某点与圆的关系。

定义圆类：public class circle {
private point centPoint;
private double radius;
public final double PI=Math.PI;
public circle(point centPoint,double radius ) {
this.centPoint=centPoint;
this.radius=radius;
}
public point getCentPoint() {
return centPoint;
}
public void setCentPoint(point centPoint) {
this.centPoint = centPoint;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
@Override
public String toString() {
return "circle [centPoint=" + centPoint + ", radius=" + radius + "]";
}
public double getPerimeter() {
return 2*PI*radius;
}
public double getarea() {
return PI*radius*radius;
}
public void judge(point p) {
double distance=this.centPoint.getDistance(p);
if(distance>radius) {
System.out.println("在圆外");
}
else if(distance==radius) {
System.out.println("在圆上");
}
else {
System.out.println("在圆内");
}
}

}

定义点类：public class point {
private double x;
private double y;
public point(double x,double y) {
this.x=x;
this.y=y;
}
@Override
public String toString() {
return "point [x=" + x + ", y=" + 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 double getDistance(point point) {
double xx=Math.pow((this.x-x), 2);
double yy=Math.pow((this.y-y), 2);
return Math.sqrt(xx+yy);

}

}

主函数：public class homework2 {
public static void main(String[] args) {
point point1=new point(1,2);
point cePoint=new point(1,3);
circle c1=new circle(cePoint, 3);
point1.getDistance(cePoint);
System.out.println(c1.getarea());
System.out.println(c1.getPerimeter());
c1.judge(point1);
}

}

面向对象:第一考虑是做这件事有多少个对象参与，其次就是每对对象有什么属性和方法，然后通过这些属性和方法产生联系，完成这件事。

抽象类 ：天生被继承

抽象类的定义：被 abstract 修饰的类就是抽象类。

抽象类不能new

抽象类不一定有抽象方法，但是含有抽象方法的类，一定的抽象类。

public class Student {

// 修饰属性：静态属性又叫做类属性，属于类，所有对象共享一份。
public static int count;
// 一般的属性，属于对象。
public int age;


// 静态方法:不能调用非静态属性
public static int getCount( ) {
  //age = age + 1; //对象可能不存在
  new Student().age =10;
return count;
}
public  int getAge() {
 count = count +1;
return age;
}

}

this  :指向自己本身.先找自己，自己没有，找父类

super ：指向父类。直接父类，父类没有就报错。

面向对象：1，封装；2，继承  3，多态

没有封装就没有继承，没有继承就没有多态

继承：可以继承到所有公开的属性和方法。
//      但是私有的无法被继承。

//      Java：单继承。只能有一个直接父类。

                    public class Teacher extends Person  {  }    

* 什么时候用继承：
* 1，发现两个类有一些共同属性和方法。那么就把这些共同之处提取出来
*    形成一个父类，然后再各自继承，同时各自里面只保留自己独特的
*    属性和方法。
* 2，如果在用某个类，发现这个类功能不够强，但是还是有些功能被用到。
*    那么就写一个子类继承它。然后子类里面加强功能
*    基类：Object