JAVA多态 抽象类 接口

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操作符实例化
方法	无限制	所有方法必须是公共的抽象实例化方法

那么应该如何确定在什么情况下应该使用接口，什么情况下使用抽象类呢？一般来说，清晰描述父子关系应该使用类建模。要标明对象拥有某种属性，可以使用接口建模。
通常，推荐使用接口而非抽象类，因为接口可以定义非相关类共有的父类型。接口比类更加灵活。