父类与子类的继承，多态与强制转换

继承的特点：

Java的继承通过extends关键字实现。
实现继承的类被称为子类。
被继承的类称为父类。

public class Fruit
{
    public double weight;
    public void info()
    {
        System.out.println("我是一个水果! 重:" + weight + "g!");
    }
}

public class Apple extends Fruit
	{
   	 	public static void main(String[] args)
    	{
        	//创建Apple对象
        	Apple a = new Apple();
        	//Apple 对象本身没有 weight 成员变量
        	//因为Apple 父类有 weight 成员变量, 所以也可以访问 Apple 对象的 weight 成员变量.
        	a.weight = 56;
       		 //调用 Apple 对象的 info() 方法
       		 a.info();
   		 }
	}
子类继承了父类, 所以说子类是一个特殊的父类. 
大部分时候, 子类总是以父类为基础. 
额外增加新的成员变量和方法. 
但有一种情况例外: 子类需要重写父类的方法. 
例如鸟类都包含了飞翔的方法, 但其中的鸵鸟并不会飞, 因为鸵鸟是鸟的子类, 因此它将从鸟类中获得飞翔的方法, 但这个飞翔的方法显然不适合鸵鸟, 所以鸵鸟这个子类需要重写鸟类(父类)的方法.


public class Bird
{
    //Bird 类的 fly() 方法
    public void fly()
    {
        System.out.println("我在天空自由自在的飞翔...啦啦啦");
    }
}

public class Ostrich
{
    //重写 Bird 类的  fly() 方法
    public void fly()
    {
        System.out.println("NND, 我可飞不了, 虽然我有双翅膀, 啦啦啦");
    }
    public static void main(String[] args)
    {
        //创建 Ostrich 对象
        Ostrich os = new Ostrich();
        //执行 Ostrich 对象的 fly() 方法, 将会输出 "...飞不了..."
        os.fly();
    }
}

覆盖方法和被覆盖方法，要么都是类方法，要么都是实例方法。

方法重载和方法重写在英文中分别是 overload 和 override
重载和重写 并不是同一种东西, 虽然二者都是发生在方法之间, 并要求方法名相同之外, 并没有太大相似之处.
因为重载主要发生在同一个类的多个同名方法之间.
而重写发生在子类和父类的同名方法之间.
当然, 父类方法和子类方法之间也有可能发生重载, 因为子类会获得父类方法.
如果子类定义了一个与父类方法有相同方法名, 但参数列表不同的方法, 就会形成父类方法和子类方法的重载.

Super：

super是Java提供的一个关键字，super用于限定该对象调用它从父类继承得到的实例变量或方法。
正如this不能出现在static修饰的方法中一样，super也不能出现在static修饰的方法中。
在子类定义的实例方法中可以通过super来访问父类中被隐藏的实例变量。

class BaseClass
	{
	    public int a = 5;
	}
	public class SubClass extends BaseClass
	{
	    public int a = 7;
	    public void accessOwner()
		    {
		        System.out.println(a);
		    }
		    public void accessBase()
			    {
			        //通过使用 super 来限定访问从父类继承得到的 a 的实例变量
			        System.out.println(super.a);
			    }
			    public static void main(String[] args)
				    {
				        SubClass sc = new SubClass();
				        sc.accessOwner(); //输出 7
				        sc.accessBase(); //输出 5
				    }
	   }

调用父类构造器

子类不会获得父类的构造器. 
但子类构造器里可以调用父类构造器的初始化代码. 
类似于前面所介绍的一个构造器调用另一个重载的构造器.
在一个构造器中调用另一个重载的构造器使用 this 调用来完成. 
在子类构造器中调用父类构造器使用 super 调用来完成.
看下面程序定义了 Base 类 和 Sub 类, 其中 Sub 类是 Base 类的子类. 
程序在 Sub 类的构造器中使用 super 来调用 Base 类的构造器初始化代码.

class Base
{
    public double size;
    public String name;
    public Base(double size, String name)
    {
        this.size = size;
        this.name = name;
    }
}
public class Sub extends Base
{
    public String color;
    public Sub(double size, String name, String color)
    {
        //通过 super 调用来调用父类构造器的初始化过程
        super(size, name);
        this.color = color;
    }
    public static void main(String[] args)
    {
        Sub s = new Sub(5.6, "皮卡丘", "黄色");
        //输出 Sub 对象的 三个实例变量
        System.out.println(s.size + "--" + s.name + "--" + s.color);
    }
}

多态的是实现

Java实现多态的三个必要条件：继承、重写、向上转型。

1.继承：在多态中必须存在有继承关系的子类和父类。
2.重写：子类对父类中某些方法进行重新定义。在调用这些方法就会调用子类的方法。
3.向上转型：在多态中需要将子类的引用赋给父类对象。

强制类型转换

强制类型转换的格式是在需要转型的数据上加上“（）”，然后在括号内加入需要转化的数据的类型，有的数据经过转型运算后，精度会丢失，而有的会更加精确。