Java类的继承，抽象，接口与多态

继承

当我们定义很多部分具有相同属性和行为的类时，如果使用之前我们所讲类的定义方式进行定义，那么是 不是发现有大量的代码重复书写，为了允许使用现有的类的功能，并在无须改写原来的类的情况下，引入了继 承的概念。我们把允许重用现有类称为基类（或超类，父类），由基类派生出来的类称为派生类(子类)。
比如：动物包括猫，狗，鱼，小鸟等。动物便是一个基类，猫，狗，鱼等都是动物类的派生类，也就是子类。
java 类的继承主要通过 extends 关键字来完成的。一旦继承后，子类将获得父类的成员属性跟成员方法。
基本语法: class 类名 extends 父类名 { }
如果没有指定的父类，那么 java 编译器默认 Object 就是该类的父类。所有的类都及继承Object类，即Object类是所有类的基类。】

class Animal{
  protected String name;
  protected int age; 
  protected String sex; 
  Animal(){ } //构造函数
  public Animal(String name){ 
     this.name=name;
     } 
 public void eat(){ //动物的行为
 System.out.println("Animal eat");
     } 
  } 
 class Cat extends Animal{
 public Cat (String name){ 
     super(name);//如果父类只有一个带参数的构造函数，不可省略改语句
     this.name=name;
     } 
}

super 关键字的使用
1 用于从派生类访问基类的成员
2 派生类要调用基类的构造方法 super（），super（）只能在派生类的构造方法中调用，位于方法首行。
3 调用基类已被其他方法重写的方法
4 访问基类的数据成员：super.成员变量、super.成员方法

抽象

抽象类和抽象方法 在 Java 面向对象当中，所有的对象都是用过类进行描绘的，但是并不是所有的类都是用来描绘对象的，如果一 个类中没有包含足够的信息来描绘一个具体的对象，我们把这种类定义为抽象类。
抽象类的特征：
1 不能用来实例化对象，所以抽象类必须被继承才能够被使用，其他的功能和普通类相同。
2 一个类只能继承一个抽象类。
3 抽象类的修饰符不能是 private。
抽象类的定义：
abstract class 类名{
成员变量定义；
方法（）{ }；//定义具体方法
abstract 方法（）；//定义抽象方法
}
说明：
(1)在抽象类中可以包含具体方法和抽象方法。抽象方法的定义与和具体方法不同，抽象方法在方法头后直接跟分号，而具体方法含有以大括号框住的方法体。
(2)抽象类表示的是一个抽象概念，不能实例化对象。
抽象类应用

abstract class fruit {
	abstract public int getweight();
}
class apple extends fruit{
	private int w;
	private String name;
    apple(String a,int b) {
    	w=b;
		name=a;
	}
    public String getname()
    {
    	return name;
    }
    public int getweight() {
    	System.out.println(getname()+w+"kg");
    	return 0;
    }
}
class tao extends fruit{
	private int w;
	private String name;
	tao(String a,int b)
	{
		w=b;
		name=a;
	}
	 public String getname()
	    {
	    	return name;
	    }
	public int  getweight()
	{
		System.out.println(getname()+w+"kg");
		return 0;
	}
}
class orinage extends fruit{
	private int w;
	private String name;
	orinage (String a,int b)
	{
		w=b;
		name=a;
	}
	 public String getname()
	    {
	    	return name;
	    }
	public int getweight()
	{
		System.out.println(getname()+w+"kg");
		return 0;
	}
}

public class e3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 fruit f[]=new fruit[3];
         f[0]=new apple("苹果",5);
         f[1]=new tao("桃子",3);
         f[2]=new orinage("橘子",10);
         for(int i=0;i<3;i++)
       	  f[i].getweight();
	}

}

接口

在抽象类中，可以包含一个或多个抽象方法，但是在接口中，所有的方法必须是抽象的，不能有方法体，他比 抽象类更加的抽象。接口规定一个类必须做什么而不规定他如何去做。
接口中生命的成员变量默认都是 public static final 的，必须显示的初始化。因而在常量声明时可以省略这些修饰 符。是若干常量和抽象方法的集合。
接口有以下特性：
1 接口中只定义抽象方法，这些方法默认都是 public abstract 的，在方法声明时可以省略这些修饰符。
2 在接口中定义实例变量，非抽象实例方法以及静态方法都是不允许的。
3 接口中没有构造方法，也不能被实例化。
4 一个接口不能实现另一个接口，但是可以多继承其他接口。
接口的使用：
1 接口的使用与类的使用有些不同，在需要使用类的地方，会直接进行 new 关键字来创建一个类的实例，但 是接口不行。
2 接口必须通过类来实现他的抽象方法。
3 如果一个类不能实现完接口中的抽象方法，那么这个类我们应该设计为抽象类。
4 不允许创建接口的实例，但是允许定义接口类型的引用变量引用实现该接口的类的实例。
接口的定义
接口有常量和抽象方法组成，由关键字interface引导接口定义，具体语法如下：
public interface 接口名 [extends 父接口名列表]{
public static final 域类型 域名 = 常量值;
public abstract 返回值 方法名（参数列表）[throw 异常列表]；
}
接口应用

package nine;

public interface e1 {
       void display();
}
class tongzhi implements e1{
		private String s;
	    tongzhi(String a) {
			this.s=a;
		}
	    public void display() {
	    	System.out.println("通知内容："+s);
	    }
	}
	class car implements e1{
		private int y;
		 car(int a)
		{
			y=a;
		}
		public void display()
		{
			System.out.println("汽车油量"+y+"升");
		}
	}
	class ad implements e1{
		private String f;
		public ad(String a)
		{
			f=a;
		}
		public void display()
		{
			System.out.println("广告消息："+f);
		}
	}

	public class e11 { 

		public static void main(String[] args) {
			// TODO Auto-generate
	    e1 t=new tongzhi("是达芬奇");t.display();
	    car c=new car(5);c.display();
	    ad a=new ad("发生口角发");a.display();
	    
		}
	}

多态

发生多态的三个条件：
1 继承
2 方法的重写（类方法的重写应满足下列条件：
1 派生类中该方法的返回值和基类同名方法的返回值相同，参数列表相同。
2 派生类中的重写方法的访问权限不能比基类小。权限的顺序为：public,protected,private。
3 基类的 abstract 方法必须被派生类重写，否则派生类也必须是 abstract
4 基类的 final 方法不能被派生类重写。 ）
3 父类引用引用派生类对象（向上造型） （向上造型就是定义父类的引用，引用派生类的对象。 Animal animal=new Cat(); animal 引用.出来的方法是父类的方法接口，但是方法的实现却是子类的实现方式。
）
多态包括静多态与动多态
静多态：静多态也称编译时的多态，就是我们所说的方法重载。相同的函数名，根据形参类型个数的不同调用不同的方 法。在编译期间就已经确定要调用的方法。
如：animal a=new animal();
a.eat();
a.eat(10);
动多态（运行时多态） 运行期
注意：发生运行时多态的三个条件。
重写和重载的区别：
1 首先重载和重写他们所处的作用域范围不同。重载是在同一个类中进行方法的定义，重写是在父子类中进 行方法的定义。
2 其次，他们的定义方式也不同。重载是方法名相同，参数列表不同。而重写是方法名相同参数列表也相同。