JAVA多态 抽象类 接口
多态
1什么是多态
多态是指一个事物在不同时刻所表现出来的不同状态
多态意味着父类的变量可以指向子类对象
public static void main(String[] args){
Object o = new Integer()//Integer是Object子类 Object的变量可以指向 Integer对象
}
2多态的前提
1.必须要有继承关系。
继承是多态的基础。没有继承多态也就不存在了。
2.要有方法重写。
没有方法重写也可以的,但是多态就没有意义。
3.必须要有父类引用指向子类对象。
fatherClass f = new ChildClass();
3多态的优缺点
1)多态的优点
1.提高了代码的维护性(继承保证)。
2.提高了代码的扩展性(由多态保证)。
2)多态的缺点
不能调用子类特有的方法。 这一点会在后边讲到。
4多态成员访问特点(动态绑定)
1)声明类型与实际类型
一个变量必须被声明为某种类型,这个类型称为他的声明类型。
变量的实际类型是被变量引用的对象的实际类。
在上边例子中变量o的声明类型为Object,实际类型为Integer。
程序是否能够通过编译只看他的声明类型
2)访问方法
阅读下面代码,你觉得会调用哪一个类的toString()方法,是A类还是B类或者会不会是Object类的呢?
public class A{
public String toString();
ruturn "I'am A";
}
public class B extends A{
public String toString();
ruturn "I'am B";
}
public static void main(String[] args){
A a= new B();
System.out.println(a);
}
其实a调用哪一个的toString()方法是由a的实际类型决定的,在这里会调用B的tiString()方法,这也就是动态绑定。
这里我们就需要了解动态绑定的工作机制了。
动态绑定的工作机制如下:如果有一个继承链,假设对象o是C1,C2,C3,…,Cn的实例其中C1是C2的之类,C2是C3的子类,… ,Cn-1是Cn的子类。如果调用一个方法p,那么JVM会一次在C1,C2, C3, … ,Cn中查找方法p的实现,直到找到为止。一旦找到一个实现就会停止查找,然后调用这个首先找到的实现。
通俗的讲,在多态中,调用方法时最特殊的类(继承链中最小的子类)优先级最高。
public class C4{
public String toString();
ruturn "I'am C4";
}
public class C3 extends C4{
}
public class C2 extends C3{
public String toString();
ruturn "I'am B";
}
public class C1 extends C2{
}
public static void main(String[] args){
C4 a= new C1();
System.out.println(a); //
}
在上边例子中a的实际类型是C1所以在调用toString方法时JVM会先在C1中找,没有找到然后在他的父类C2中找,这时候找到了,就会调用C2的toStin()方法。若C2中还没有重写toSting()方法,则会一直向上找到C4类中的toString()方法。
3)访问成员变量
以多态形式访问成员变量时会以变量的声明类型为准,这是与访问方法所不同的。
下面的例子,会调用a的声明类型A类的num。
public class A{
int t=10;
}
public class B extends A{
int t=20;
}
public static void main(String[] args){
A a = new B();
System.out.println("a.t")//回调用A类的num
}
4)访问静态方法
以多态形式访问静态方法时会以变量的声明类型为准,和访问成员变量相同。
下边例子中a会调用A类中的method()方法,输"A 类的静态方法"。
public class A{
public static void method{
System.out.println("A 类的静态方法");
}
}
public class B extends A{
public static void method{
System.out.println("B 类的静态方法");
}
}
public static void main(String[] args){
A a = new B();
a.method();
}
5向上转型与向下转型
1)向上转型
多态就是一种向上转型。
FatherClass f = new ChildClass();
将子类类型向上转为父类型。
2)向下转型
FatherClass f = new ChildClass();
ChildClass c=(ChildClass)f;
将父类类型f转为子类类型。
3)转型中遇到的问题
public class A{
}
public class B extends A{
}
public class C extends A{
}
public static void main(){
B b = new B();
A ab=(A)b;
A a = new A();
C c1=(C)ab;//向下转型错误
C c2=(C)a;//向下转型错误
}
为什么上边的代码中为什么会向下转型错误
其实原因很简单,因为子类对象永远是父类的实例,而父类的对象不一定是子类的实例。
可以这么简单的理解:子类的对象可以向上转型为父类的对象,而父类对象不能向下转型为子类的对象,除非它本身的实际类型就是子类的类型。
在这里ab的实际类型为B 他不是C类的子类所有无法转型。a的实际类型为A,他无法向下转型为C。
4)instance运算符
那么我们如果希望向下转型,却又害怕出现错误怎么办。可以使用instance运算符来判断对象的实际类型。
public class A{
}
public class B extends A{
}
public class C extends A{
}
public static void main(){
A a= new B();
if(a instanceof B)
{
B b=new B();
}
}
抽象类
1什么是抽象类
1)抽象方法
在理解抽象类之前,我们要先了解什么是抽象方法
抽象方法就是只声明方法 而不给出具体的实现,需要他的子类去实现的方法称为抽象方法。
2)abstract关键字
声明抽象方法必须使用abstract关键字。
public abstract void method();//只需声明,不需要实现。
上边的方法就是一个抽象方法。需要他的子类来实现这个方法。
3)抽象类的概念
拥有抽象方法的类必须使用abstract关键字声明为抽象类。
public static class A {//抽象类
public static void method();//抽象方法
}
需要注意的是,如果一个类继承了抽象类但是没有实现它的全部抽象方法,则这个类也必须声明为抽象类。
因为这个子类也继承了抽象类的抽象方法,而有抽象方法的类必须声明为抽象类。
2抽象类特点
1.抽象类不能直接实列化(创建对象)。
2.一个类中如果有了抽象方法,此类必须为抽象类。
3.抽象类里面可以没有抽象方法。
4.抽象类里面有构造方法。
5.抽象类里面既可以有抽象方法,也可以有非抽象方法。
6.抽象类中的所有抽象方法,子类必须重写,带有强制性,否则必须声明为抽象方法。
3抽象类举例
如果想定义一些形状类,而且想要要求他们实现求周长和面积的方法,可以将他们向上抽取一个形状类,并且拥有抽象方法getPerimeter()和getArea()。
public abstract Class Shape{ //抽象类
public abstract double getPerimeter();
public abstract double getArea();
}
public class Rectangle extends Shape{
private double length,wide;
Rectangle(double length,double wide)
{
this.length=length;
this.wide=wide;
}
public double getPerimeter()
{
return 2*(length+wide);
}
public double getArea()
{
return length*wide;
}
}
public class Circle extends Shape{
private double r;
Rectangle(double r)
{
this.r=r;
}
public double getPerimeter()
{
return 2*MATH.PI*r
}
public double getArea()
{
return Math.PI*r*r;
}
}
public static void main(String[] args)
{
Rectangle r = new rectangle(5,10);
System.out.println(r.getPerimeter());
System.out.println(r.getArea());
Circle c= new Circle(9);
System.out.println(c.getPerimeter());
System.out.println(c.getArea());
}
接口
1什么是接口
接口是一种与类相似的结构,只包含常量和抽象方法。
我们可以通过继承接口来实现JAVA中的多继承。
接口需要使用关键字 interface定义,而实现接口需要使用关键字implements。
public interface A{//定义接口A
...
}
public class B implements A{//B类实现A接口
...
}
接口在许多方面都与抽象类很相似,但接口的目的是指明相关或不相关类的多个对象的共同行为。
在JAVA中接口被看做是一种特殊的类,每个接口都被编译为独立的字节码文件。
2接口的特点
1.接口中所有的方法都是抽象方法,没有非抽象方法,方法前面默认有修饰符 public abstract 你可以省略不写,建议你写出来
2.接口中没有构造方法
3.接口不能创建对象
4.接口中所有的成员变量都是公共的静态常量
5.接口的子类可以是抽象类
6.接口跟接口之间可以继承,而且是多继承
3接口举例
我们都知道基本类型的对象是可以比较的,那么想让其他的对象进行比较可以吗?
答案是肯定的,我们可以让类继承Comparable接口来使类的对象可以进行比较。
以上边的例子继续为例,如果我想比较两个矩形类对象,该怎么办实现。我们可以通过继承Comparable接口比较两个对象的面积来判断他们的大小
public interface Comparable<E>{ //定义可比较接口
public int compareTO(E o);
}
public class ComparabkeRectangle extends Rectangle implements Comparable<CombleRenctangle>{ //继承接口
public ComparableRectangle(double length,double wide){
super(length,height)
}
public int compareTo(ComparableRectangle o){ //重写比较方法
if(getArea()>o.getArea())
return 1;
else if(getArea()<o.getArea())
return -1;
else return 0;
}
}
public static void main(String[] args)
{
ComparableRectangle r1 = new ComparableRectangle(4, 5);
ComparableRectangle r2 = new ComparableRectangle(3,6);
System.out.println(r1>r2);//两个对象可以进行比较了。
}
接口与抽象类的区别
抽象类 | 接口 | |
---|---|---|
变量 | 无限制 | 所有变量必须是public static final 类型 |
构造方法 | 子类通过构造方法链调用构造方法,抽象类不能用new操作符实例化 | 没有构造方法,接口不能用new操作符实例化 |
方法 | 无限制 | 所有方法必须是公共的抽象实例化方法 |
那么应该如何确定在什么情况下应该使用接口,什么情况下使用抽象类呢?一般来说,清晰描述父子关系应该使用类建模。要标明对象拥有某种属性,可以使用接口建模。
通常,推荐使用接口而非抽象类,因为接口可以定义非相关类共有的父类型。接口比类更加灵活。