抽象类和继承抽象类
 
抽象类不能直接实例化，需要创建一个指向自己的对象引用（其子类）来实例化 
 代码：
 
public class Main
{
    public static void main(String[] args)
    {
        /* People people = new People(); */ //错误
        People p = new Man();
        p.eat();
        p.drink();
        /* p.palyGames() */ //此方法错误
        Man man = new Man();
        man.eat();
        man.playGames();
        Women women = new Women();
        women.eat();
        women.dressing();
    }
    abstract static class People{
        String name;
        int age;
        float height;
        float weight;
        public void eat(){
            System.out.println("人都会吃饭");
        }
        public abstract void drink();
    }
    static class Man extends People{
        float short_hair;
        public void playGames(){
            System.out.println("男的独有的打游戏技能");
        }
        @Override
        public void drink(){
            System.out.println("man drink 酒");
        }
    }
    static class Women extends People{
        float long_hair;
        public void dressing(){
            System.out.println("女的独有的化妆技能");
        }
        @Override
        public void drink(){
            System.out.println("women drink 饮料");
        }
    }
}

 
这里People不能直接实例化，如果是People p = new Man();这里p只能调用People类n抽象方法和成果调用了其抽象方法，则访问的是其引用类（子类）继承的抽象类；如果是Man man= new Man();这里man是可以调用类Man和其继承的抽象类People的方法和属性 
 

当A类想要实现一个接口中个别方法是（不是所有方法），可以创建一个抽象类去实现该接口，然后在有A类去继承这个抽象类。

注意：这个抽象类必须重写这个接口的所有方法，A类才可以实现其中的个别方法；如果抽象类没有实现接口中的所有有方法（不用写方法体），那么A类继承抽象类后就必须重写抽象类没有实现的方法。所以为了方便的去使用个别方法，可以让抽象类去实现接口的所用方法（不用写方法体），这样A类就可以随便（想写几 个就写几个）重写抽象类的方法了。

设计一个抽象类图形类，在该类中包含有至少两个抽象方法求周长和求面积，分别定义圆形类、长方形类、正方形类来继承图形类，并实现上述两个方法。并创建实例验证。
 
直接上代码了
 
package ThirdDay;

 abstract class Shape {
    //计算面积
    public abstract Double calculateS();

    //计算周长
    public  abstract Double calculateC();
}

//长方形类
  class Rectangle extends  Shape{
     private double l;
     private double s;

    public Rectangle(double l, double s) {
        this.l = l;
        this.s = s;
    }

    public double getL() {
        return l;
    }

    public void setL(double l) {
        this.l = l;
    }

    public double getS() {
        return s;
    }

    public void setS(double s) {
        this.s = s;
    }

    @Override
    public Double calculateS() {
        return s*l;
    }

    @Override
    public Double calculateC() {
        return 2*(s+l);
    }

}

  class Square extends Shape{

     private double sideLength;

      public Square(double sideLength) {
          this.sideLength = sideLength;
      }

      public double getSideLength() {
          return sideLength;
      }

      public void setSideLength(double sideLength) {
          this.sideLength = sideLength;
      }

      @Override
      public Double calculateS() {
          return Math.pow(sideLength,2);
      }

      @Override
      public Double calculateC() {
          return 4*sideLength;
      }
  }

  class Triangle extends Shape{

     private double a;
     private double b;
     private double c;

      public Triangle(double a, double b, double c) {
          this.a = a;
          this.b = b;
          this.c = c;
      }

      public double getA() {
          return a;
      }

      public void setA(double a) {
          this.a = a;
      }

      public double getB() {
          return b;
      }

      public void setB(double b) {
          this.b = b;
      }

      public double getC() {
          return c;
      }

      public void setC(double c) {
          this.c = c;
      }

      @Override
      public Double calculateS() {
          double s = (a + b + c) / 2;
          double area = Math.pow(s*((s - a)*(s - b)*(s - c)), 0.5);
          return area;
      }

      @Override
      public Double calculateC() {
          return a+b+c;
      }
  }


class Circle extends Shape{

    private double r;

      public Circle(double r) {
          this.r = r;
      }

      public double getR() {
          return r;
      }

      public void setR(double r) {
          this.r = r;
      }

      @Override
      public Double calculateS() {
          return Math.PI*r*r;
      }

      @Override
      public Double calculateC() {
          return 2*Math.PI*r;
      }
  }


  class Graphice {
      public static void main(String[] args) {
          Circle circle=new Circle(2.5);
          System.out.println("半径为:"+circle.getR()+"的圆面积为:"+circle.calculateC());
          System.out.println("半径为:"+circle.getR()+"的圆周长为:"+circle.calculateS());
          Triangle triangle=new Triangle(3,4,5);
          if (triangle.getA() > 0 && triangle.getB()> 0 && triangle.getC() > 0 &&
                  (triangle.getA()+ triangle.getB()) > triangle.getC() && (triangle.getA() + triangle.getC()) > triangle.getB() && (triangle.getB() + triangle.getC()) > triangle.getA()) {
              System.out.println("三角形的a,b,c三边长为:"+triangle.getA()+","+triangle.getB()+","+triangle.getC());
              System.out.println("三角形的周长为 = " + triangle.calculateC());
              System.out.println("三角形的面积 = " + triangle.calculateS());
          }else {
              System.out.println("\n三角形三边不合法! 三角形创建失败! "
                      + "\n请重新输入三边\n");
          }
          Rectangle rectangle=new Rectangle(5,2);
          System.out.println("长为:"+rectangle.getL()+"宽为:"+rectangle.getS()+"的长方形面积为:"+rectangle.calculateS());
          System.out.println("长为:"+rectangle.getL()+"宽为:"+rectangle.getS()+"的长方形周长为:"+rectangle.calculateC());
          Square square=new Square(2);
          System.out.println("边长为:"+square.getSideLength()+"的正方形面积为:"+square.calculateS());
          System.out.println("边长为:"+square.getSideLength()+"的正方形周长为:"+square.calculateC());
      }
  }
 
运行结果如下
 
半径为:2.5的圆面积为:15.707963267948966
半径为:2.5的圆周长为:19.634954084936208
三角形的a,b,c三边长为:3.0,4.0,5.0
三角形的周长为 = 12.0
三角形的面积 = 6.0
长为:5.0宽为:2.0的长方形面积为:10.0
长为:5.0宽为:2.0的长方形周长为:14.0
边长为:2.0的正方形面积为:4.0
边长为:2.0的正方形周长为:8.0

 
继承抽象类的子类必须重写抽象类的方法
 
转载于:https://www.cnblogs.com/classmethond/p/9926283.html