（七）Java关于抽象类abstract

最新推荐文章于 2024-04-18 14:41:19 发布

HB0o0

最新推荐文章于 2024-04-18 14:41:19 发布

阅读量779

点赞数 2

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/SwaggerHB/article/details/129798427

版权

Java基础专栏收录该内容

16 篇文章 3 订阅

订阅专栏

Java关于抽象类与内部类

文章目录

Java关于抽象类与内部类

抽象类

前言

在继承中，我们讨论了“自顶向下？自底向上？”的问题。结论是：在具体的编程中，通常是用“自底向上”的方式，从众多类中抽象出类似或者雷同的部分，构建基类。

下面我们就用这种思想考察和一个具体问题：几何图形；

定义一个抽象类图形Shape类，由该派生出两个子类圆Circle类和矩形Rectangle类。在Shape里声明抽象方法area( )，该方法分别在两个子类里得到实现。

抽象方法与抽象类

用关键字 abstract 修饰一个方法，并且只“声明”而不具体实现这个方法，就可以生成一个抽象方法：

public abstract double area();

包含至少一个抽象方法的类，必须用 abstract 修饰，称为抽象类。下面看代码：

抽象类实现代码

首先实现抽象类 Shape

public abstract class Shape {
	protected String name;
	
	public Shape(String name) {
		this.name = name;
	}
	
	public abstract double area();
    public abstract double perimeter();

	@Override
	public String toString() {
		return name;
	}
}

第 1 行，用 abstract 关键字声明 Shape 类是抽象类；

第 8、9 行，定义了两个抽象方法；

抽象类是不能直接实例化的，因为抽象类存在未实现的方法。 由抽象类派生出的子类，如果依然没有实现其抽象方法，则这个子类也是抽象类。

下面看在 Shape 类基础上派生出来的正方形类，Square 类：

public class Square extends Shape{
   /**
    *正方形独有的边长属性
    */
    private double length;

    //无参构造中默认边长为 1.0
    public Square() {
        this(1.0);
    }

    public Square(double length) {
        super("正方形");
        this.length = length;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

   /**
    * 这是对基类抽象方法的实现
    * 按正方形周长公式计算周长
    */
    @Override
    public double perimeter() {
        return 4 * this.length;
    }
    
	/**
     * 这是对基类抽象方法的实现
     * 按正方形面积公式计算面积
     */
    @Override
    public double area() {
        return this.length * this.length;
    }
}

再看圆形类（Circle）代码：

public class Circle extends Shape {
    private double radius;

    public Circle() {
        this(1.0);
    }

    public Circle(double radius) {
        super("圆形");
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    /**
     * 这是对基类抽象方法的实现
     * 按圆形面积公式计算面积
     */
    @Override
    public double area() {
        return Math.PI * this.radius * this.radius;
    }

    /**
     * 这是对基类抽象方法的实现
     * 按圆形周长公式计算周长
     */
    @Override
    public double perimeter() {
        return 2 * Math.PI * this.radius;
    }
}

下面是演示类，Test：

public class Test {
    public static void main(String[] args) {
        Square square = new Square(2.0);
        System.out.println("正方形的面积为：" + square.area());
        System.out.println("正方形的周长为：" + square.perimeter());

        Circle circle = new Circle(2.0);
        System.out.println("圆的面积为：" + circle.area());
        System.out.println("圆的周长为：" + circle.perimeter());
    }

代码很简单，执行结果如下;

抽象类编程核心思想

上述代码理解起来并不困难，但是，其中包含的编程思想却值得好好体会！

抽象类通常是在很多类的基础上进行抽象形成的，因此，抽象类由“确定的成分”和“不确定的成分”两部分组成。“确定的成分”通常是那些类中固定的，固有的和确定的成员、方法组成；这些成分在抽象类中实现，再用派生的方式让子类继承,从而实现了“代码复用”。
“不确定的成分”是那些类彼此又相同、又不同的部分。相同点在于，这些类都存在这些成分；不同点在于，这些成分的具体实现方法有所不同。
正如，无论是什么几何图形，都存在计算“周长”和“面积”的共同需求，只是在具体计算方式上存在差异。
这是从正面考察上面的几个几何图形类与形状类（Shape类）之间的关系得到的结果。但是，如果从另外一个角度考虑，可以得到更多编程的启示：
某个类，对于其确定的功能，直接实现就好。
如果该类存在这么一种功能（方法)：这个功能不是由这个类实现的，或者说，它无法确定其实现的过程，但是，又要用到这个功能以便实现其它“确定"的功能，那么，就可以把这个“不确定”、当前无法实现的功能声明为抽象方法，以待其派生类实现它。

Java 内部类

内部类的概念

在一个类中，可以定义其它类，这些类称为内部类。（需要注意的是，“在一个类中”的意思是，在这个类定义过程的“{ }”内。）

内部类所在的类称为“外部类“。内部类可以直接引用外部类的成员和方法，无需受到权限修饰符的限制。

public class AboutInnerClass {
	private int outterInt;
	private InnerClass one;
	
	public AboutInnerClass() {
		this.one = new InnerClass();
	}

	public int getOutterInt() {
		return outterInt;
	}

	public void setOutterInt(int outterInt) {
		this.outterInt = outterInt;
	}
	
	public void fun() {
		this.one.fun();
		System.out.println(this.one.innerInt);
	}

	public class InnerClass {
		private int innerInt;
		
		public InnerClass() {
		}

		public int getInnerInt() {
			return innerInt;
		}

		public void setInnerInt(int innerInt) {
			this.innerInt = innerInt;
		}
		
		private void fun() {
			outterInt += 1;
			System.out.println("outterInt : " + outterInt);
		}
	}
}