oop-Inheritance & Polymorphism
本文主要作为java学习笔记,方便以后查看,大部分内容都源于以下网站:
http://www.ntu.edu.sg/home/ehchua/programming/index.html#Game
本文的内容是根据自己理解而归类,有不准确的地方,敬请谅解。
本文主要内容:
1.继承(inheritance)
2.多态(polymorphism)
3.抽象类(abstract_class)
4.接口(interface)
-----------------------------------------------------------------
1.继承
修饰符:extends
继承只能是单继承,一个子类只能继承一个父类,不能继承多个父类。
The "@Override" is known as annotation (introduced in JDK 1.5), which asks compiler to check whether there is such a method in the superclass to be overridden. This helps greatly if you misspell the name of the method to be overridden. For example, suppose that you wish to override method toString() in a subclass. If @Override is not used and toString() is misspelled as TOString(), it will be treated as a new method in the subclass, instead of overriding the superclass. If @Override is used, the compiler will signal an error.@Override annotation is optional, but certainly nice to have.
Annotations are not programming constructs. They have no effect on the program output. It is only used by the compiler, discarded after compilation, and not used by the runtime.
“@Override”作为标注,告诉编译器去检查父类中是否存在子类将要重载的同名函数。注意这里的Override开头的‘O’需要大写。
Point.java
public class Point {
private int x;
private int y; public Point() {
x = 0;
y = 0;
}
public Point(int x, int y) {
this.x = x;
this.y = y;
} public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
} public String toString() {
return "(" + x + ", " + y + ")";
}
}
Point3D.java
public class Point3D extends Point {
private int z; public Point3D() {
super(); //调用父类的构造函数
z = 0;
}
public Point3D(int x, int y, int z) {
super(x, y); //调用父类的构造函数
this.z = z;
} public int getZ() {
return z;
}
public void setZ(int z) {
this.z = z;
} @Override
public String toString() {
return "(" + super.getX() + ", " + super.getY() + ", " + z + ")";
}
}
TestPoint3D.java
运行结果:
(1, 2, 3)
1
2
3
(4, 5, 6)
Java provides a binary operator called instanceof which returns true if an object is an instance of a particular class. The syntax is as follows:
anObject instanceof aClass
Circle c1 = new Circle();
System.out.println(c1 instanceof Circle); // true
A subclass instance processes all the attributes operations of its superclass. When a superclass instance is expected, it can be substituted by a subclass instance. In other words, a reference to a class may hold an instance of that class or an instance of one of its subclasses - it is called substitutability.
If a subclass instance is assign to a superclass reference, you can invoke the methods defined in the superclass only. You cannot invoke methods defined in the subclass.
However, the substituted instance retains its own identity in terms of overridden methods and hiding variables. If the subclass overrides methods in the superclass, the subclass's version will be executed, instead of the superclass's version.
2.多态
Shape.java
public class Shape {
private String color; public Shape (String color) {
this.color = color;
} @Override
public String toString() {
return "Shape of color=\"" + color + "\"";
}
public double getArea() {
System.out.println("shape unknown! Cannot compute area!");
return 0;
}
}
Rectangle.java
public class Rectangle extends Shape {
private int length;
private int width; public Rectangle(String color, int length, int width) {
super(color);
this.length = length;
this.width = width;
}
//重载父类的方法
@Override
public String toString() {
return "Rectangle of length=" + length + " and width="
+ width + ", subclass of " + super.toString();
}
//重载父类的方法
@Override
public double getArea() {
return length * width;
}
}
Triangle.java
public class Triangle extends Shape {
private int length;
private int width; public Triangle(String color, int length, int width) {
super(color);
this.length = length;
this.width = width;
}
//重载父类的方法
@Override
public String toString() {
return "Rectangle of length=" + length + " and width="
+ width + ", subclass of " + super.toString(); }
//重载父类的方法
@Override
public double getArea() {
return 0.5 * length * width;
}
}
TestShape.java
public class TestShape {
public static void main(String[] args) {
Shape s1 = new Rectangle("red", 4, 5); //多态的体现,可以将子类复制给父类,应为子类具有父类的属性
System.out.println(s1);
System.out.println("Area is " + s1.getArea()); //根据赋值前的情况,将会调用Rectangle中的getArea函数 Shape s2 = new Triangle("blue", 4, 5);
System.out.println(s2);
System.out.println("Area is " + s2.getArea()); //根据赋值前的情况,将会调用Rectangle中的getArea函数
}
}
运行结果:
Rectangle of length=4 and width=5, subclass of Shape of color="red"
Area is 20.0
Rectangle of length=4 and width=5, subclass of Shape of color="blue"
Area is 10.0
3.抽象类(abastract class)
修饰符:abstract
抽象类只有接口,但是其中的函数并没有实现。
An abstract
class is incomplete in its definition, since the implementation of its abstract
methods is missing. Therefore, an abstract
class cannot be instantiated. In other words, you cannot create instances from an abstract
class (otherwise, you will have an incomplete instance with missing method's body).
To use an abstract
class, you have to derive a subclass from the abstract
class. In the derived subclass, you have to override the abstract
methods and provide implementation to all the abstract
methods. The subclass derived is now complete, and can be instantiated. (If a subclass does not provide implementation to all the abstract
methods of the superclass, the subclass remains abstract
.)
This property of the abstract
class solves our earlier problem. In other words, you can create instances of the subclasses such as Triangle
and Rectangle
, and upcast them to Shape
(so as to program and operate at the interface level), but you cannot create instance of Shape
, which avoid the pitfall that we have faced. For example,
Shape.java
abstract public class Shape {
private String color; public Shape(String color) {
this.color = color;
} @Override
public String toString() {
return "Shape of color\"" + color + "\"";
}
//其中的方法不必实现,实现由其子类来完成
abstract public double getArea();
}
Rectangle.java和Triangle.java使用上面的。子类继承父类,并实现器中的未实现的函数。抽象类不能够实例化,即通过new操作符,新建一个instance。
TestShape.java
public class TestShape {
public static void main(String[] args) {
Shape s1 = new Rectangle("red", 4, 5);
System.out.println(s1);
System.out.println("Area is " + s1.getArea()); Shape s2 = new Triangle("blue", 4, 5);
System.out.println(s2);
System.out.println("Area is " + s2.getArea()); //wrong
//Shape s3 = new Shape("green");
}
}
4.接口(interface)
A Java interface
is a 100% abstract superclass which define a set of methods its subclasses must support. An interface
contains only public
abstract methods (methods with signature and no implementation) and possibly constants (public
static
final
variables). You have to use the keyword "interface
" to define an interface
(instead of keyword "class
" for normal classes). The keyword public
and abstract
are not needed for its abstract methods as they are mandatory.
An interface is a contract for what the classes can do. It, however, does not specify how the classes should do it.
Movable.java
public interface Movable {
public void moveUp();
public void moveDown();
public void moveLeft();
public void moveRight();
}
MovablePoint.java
public class MovablePoint implements Movable {
private int x, y; public MovablePoint(int x, int y) {
this.x = x;
this.y = y;
} @Override
public String toString() {
return "Point at (" + x + ", " + y + ")";
}
@Override
public void moveUp() {
y++;
}
@Override
public void moveDown() {
y--;
}
@Override
public void moveLeft() {
x--;
}
@Override
public void moveRight() {
x++;
}
}
TestMovable.java
public class TestMovable {
public static void main(String[] args) {
Movable m1 = new MovablePoint(7,7); m1.moveUp();
System.out.println(m1);
m1.moveDown();
System.out.println(m1);
m1.moveLeft();
System.out.println(m1);
m1.moveDown();
System.out.println(m1);
}
}
运行结果
Point at (7, 8)
Point at (7, 7)
Point at (6, 7)
Point at (6, 6)
接口的出现,使得java可以间接实现多继承,因为一个类可以通过修饰符implements来实现多个接口。
As mentioned, Java supports only single inheritance. That is, a subclass can be derived from one and only one superclass. Java does not support multiple inheritance to avoid inheriting conflicting properties from multiple superclasses. Multiple inheritance, however, does have its place in programming.
A subclass, however, can implement more than one interfaces. This is permitted in Java as an interface merely defines the abstract methods without the actual implementations and less likely leads to inheriting conflicting properties from multiple interfaces. In other words, Java indirectly supports multiple inheritances via implementing multiple interfaces. For example,
public class Circle extends Shape implements Movable, Displayable { // One superclass but implement multiple interfaces
.......
}
The formal syntax for declaring interface is:
[public|protected|package] interface interfaceName
[extends superInterfaceName] {
// constants
static final ...; // abstract methods' signature
...
}
oop-Inheritance & Polymorphism的更多相关文章
- 封装,capsulation,&&继承,Inheritance,&&多态,polymorphism
Inheritance&&polymorphism 层次概念是计算机的重要概念.通过继承(inheritance)的机制可对类(class)分层,提供类型/子类型的关系.C++通过类派 ...
- 【转】Basic C# OOP Concept
This Article will explain a very simple way to understand the basic C# OOP Concept Download ShanuBas ...
- systemverilog之OOP
what is oop terminology an example class default methods for classes static attibute assigment and c ...
- JAVA面向对象初步知识总结:封装、继承、多态
1.封装 把数据和方法包装进类中,以及具体实现的隐藏,常共同被称作是是封装.其结果是一个同时带有特征和行为的数据类型.所谓具体实现的隐藏是通过访问权限控制实现的.JAVA 子类重写继承的方法时,不可以 ...
- Design Pattern: Not Just Mixin Pattern
Brief 从Mix-In模式到Mixin模式,中文常用翻译为“混入/织入模式”.单纯从名字上看不到多少端倪,而通过采用Mixin模式的jQuery.extend我们是否可以认为Mixin模式就是深拷 ...
- 115 Java Interview Questions and Answers – The ULTIMATE List--reference
In this tutorial we will discuss about different types of questions that can be used in a Java inter ...
- Service Oriented Architecture and WCF 【转】
http://www.codeproject.com/Articles/515253/Service-Oriented-Architecture-and-WCF Introduction This a ...
- Java Knowledge series 4
JVM & Bytecode Has-a or Is-a relationship(inheritance or composition) 如果想利用新类内部一个现有类的特性,而不想使用它的接 ...
- Java Knowledge series 3
JVM & Bytecode Abstract & Object Object in Java (1) 所有东西都是对象object.可将对象想象成一种新型变量:它保存着数据,但可要求 ...
- Introduction to Object-Oriented JavaScript 转载自:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript
Introduction to Object-Oriented JavaScript IN THIS ARTICLE JavaScript review Object-oriented program ...
随机推荐
- centos部署supervisor
#!/bin/bash yum -y install python-setuptools ping pypi.python.org -c 4 >/dev/null 2>&1 eas ...
- STM32 GPIO口模式配置
F103系列 typedef struct { uint16_t GPIO_Pin; /*!< Specifies the GPIO pins to be configured. This pa ...
- 办公技巧:局域网内设置固定ip
第一步:查看自己现在的网络配置 打开命令行,输入:ipconfig /all 第二步:打开控制面板 - 网络配置 根据CMD命令的ipconfig信息对号入座填入即可. 然后,重启一下WIFI即可. ...
- python标准库介绍——23 UserString 模块详解
==UserString 模块== (2.0 新增) ``UserString`` 模块包含两个类, //UserString// 和 //MutableString// . 前者是对标准字符串类型的 ...
- cocos2dx 3.x ccDrawLine一个坑
ccDrawLine,如果传进去的坐标是INFINITY,画不出来.
- 逆向随笔 - switch 语句深入分析
switch case 语句在c语言里还是比較简单的.可是被编译出来之后,优化结果往往让人非常疑惑.全然看不懂,以下我们一次次的尝试,看看编译器究竟把switch语句变成什么样了. ① 先上个最简 ...
- ajax 兼容性问题解决 集锦
这两天刚解决了ajax多浏览器兼容的问题,主要就针对Firefox的,开始还以为Firefox不支持ajax呢(别笑我呀,不怎么了解Firefox也没用过,呵呵),多亏看了下面的文章才让我了解ajax ...
- Ubuntu 安装谷歌拼音输入法
Ubuntu14.04内置的拼音输入法有一个bug,使得Live USB全拼无法使用. 安装Google拼音输入法步骤如下: 1. 打开Ubuntu软件中心 (Ubuntu Software Cent ...
- 有趣的switch应用(填入种类,显示响应的价格)
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- C++面向对象程序设计的一些知识点(4)
摘要:累继承可以实现源代码重用,模板技术也可以达到同样的目的.模板可以分为函数模板和类模板,其共同点是允许参数类进行类型化,编译器根据程序员传递的具体类型,又把函数模板实例化为具体函数,把类模板实例化 ...