夜光精华：Java面向对象编程 学习笔记（三）在校资源

夜光序言：

 

“你离我有多远呢，果实呀？“

”我藏在你的心里呀，花呀。”

 

 

 

 

 

 

 

 

 

 

 

正文：Java的继承与多态

 

---

 

属性的继承与隐藏

---

方法的继承、重载与覆盖

---

父类对象与子类对象的使用与转化

 

 

---

构造方法的重载与继承

 

 

/* 例： 一个表示图形的类 Shapes.java */
abstract class Shapes     //定义一个名为Shape的抽象类
{
    protected double circumference;         // 图形的周长
    protected double area;                  // 图形的面积
    abstract void setCircumference();       //抽象方法：计算周长
    abstract void  setArea();               //抽象方法：计算面积
    public double getCircumference()           //实例方法: 获取周长
    {
       return  circumference ;
    }
     public double getArea()              //实例方法: 获取面积
     {
        return  area ;
     }
}

 

 

class Rectangle extends Shapes  //继承于Shapes的子类：矩形类
{
  protected int height;                //矩形的高度
  protected int width;                 //矩形的宽度
  Rectangle(int h,int w)  //构造方法，带2个参数：高度、宽度
  {
    height=h;
    width=w;
  }
  public void setCircumference()  //覆盖计算周长的父类方法
  {
    circumference=2*(height+width);
  }
  public void setArea()          //覆盖计算面积的父类方法
  {
    area=height*width;
  }
  public String toString()
  {
    return ""+area;
  }
}

 

class Box extends Rectangle  //继承于Rectangle的子类：矩形框类
{
  private int width;   //内部正方框的宽度、高度，将隐藏父类同名属性
  Box(int h,int w)     //带2个参数：矩形外框高度、宽度
  {
    super(h,w);      //调用父类的构造方法，外框尺寸被赋值
  }
  Box(int h,int w,int innerw)  //带3个参数：矩形外框高度、宽度、内方框宽度
  {
    this(h,w);      //调用带2个参数的构造方法构造矩形
    width=innerw;   //确定内部正方形框的尺寸
  }
  public void setWidth(int innerw) //设置内方框尺寸的方法
  {
    width=innerw;
  }
  public int getWidth()     //获得内方框的尺寸
  {
    return width;       //如果想获取外框的宽度，可改为super.width
  }
  public void setCircumference()  //覆盖父类方法，计算周长
  {
    super.setCircumference();  //调用父类方法计算外边周长
    circumference+=4*width;    //矩形框的周长=外框+内框
  }
  public int setArea(int innerw) //重载方法setArea() ，计算内部正方形面积
  {
    return width*width;        //正方形面积
  }
  public void setArea()          //覆盖父类方法，计算面积
  {
    area=height*super.width-setArea(width); //总面积=矩形面积-内部正方形面积
  }
}

 

class TestThis{   //this的使用示例
  int y;
  TestThis(){    //构造函数1，无参
    y=10;
  }
  TestThis(int newY){  //构造函数2，带1个参数
    this();                 //   （1）在构造方法中使用this
    y=y+newY;
  }
  int max(int n1,int n2){    //方法1，带2个参数
    if(n1>n2) return n1;
    else return n2;
  }
  int max(int n1,int n2,int n3) {    //方法2 ，重载了方法1，带3个参数
    int temp=this.max(n1,n2);   //（2）在实例方法中使用this，调用方法1
    return this.max(temp,n3);
  }
  int changeY(int y) {       //带同名的参数
    this.y=y;                  //（3）使用this区分参数和成员变量
    return this.y;
  }
  int getY() {
    return y;
  }
  int exchange()  {           //测试同名的局部变量
    int y=5;                   //与成员变量同名的局部变量
    return this.y+y;       //（4）使用this区分成员变量和局部变量
  }
}
 
class TestSuper extends TestThis{
  int y;      //覆盖了父类的同名变量
  int x;
  TestSuper(int newX) {   //子类的构造方法
    super();                   // 调用父类无参构造方法,可以省略
      y=newX;
  }
  /* TestSuper(int newX) { //子类的构造方法
    super(newX);        //测试另外一种方式：调用父类带一个参数的构造方法
     y=newX;
  }*/
  int getY(){    //重写父类同名方法，返回的是子类成员y；否则子类继承父类方法，返回的是父类的同名变量值
    return y;
  }
  int getX() {
    return x;
  }
  int getY1() {
    return super.y;  //使用super操作被隐藏的成员变量
  }
}
public class TestThisSuper{
  public static void main(String args[])
  {
    TestThis this1=new TestThis();
    TestThis this2=new TestThis(99);
     System.out.println("********测试this的使用情况********\n");
    System.out.println("用第一种构造方法时初始的成员变量y值="+this1.getY()+"\n");
    System.out.println("用第二种构造方法时初始的成员变量y值="+this2.getY()+"\n");
    System.out.println("调用方法max(25,12,46)比较三个参数中的最大值="+this1.max(25,12,46)+"\n");
    System.out.println("用第一种构造方法时，调用方法changeY（）修改y值="+this1.changeY(66)+"\n");
    System.out.println("用第一种构造方法时，调用方法getY（）提取y值="+this1.getY()+"\n");
    System.out.println("用第一种构造方法时，调用方法exchange（）用局部变量y叠加5后的y值="+this1.exchange()+"\n");
    TestSuper super2=new TestSuper(20);
    System.out.println("********测试super的使用情况********\n");
    System.out.println("用子类构造方法时，调用方法getY（）提取成员变量y值="+super2.getY()+"\n");
    System.out.println("用子类构造方法时，调用方法getX（）提取成员变量x值="+super2.getX()+"\n");
    System.out.println("子类中调用父类方法对y值修改后，父类成员变量y值="+super2.changeY(55)+"\n");  //操作的是父类中的同名变量
    System.out.println("子类中，得到子类的成员变量y值="+super2.getY()+"\n");
    System.out.println("子类中，得到父类的成员变量y值="+super2.getY1()+"\n");
  }
}

 

 

标签：Java,构造方法,int,子类,width,面向对象编程,return,父类,夜光
来源： https://blog.csdn.net/weixin_41987706/article/details/91429373