这两天总结了数据结构中栈的用法，对栈的初始化、出栈、入栈的总结：
http://t.csdn.cn/7sKjQ
对双栈共享的初始化、入栈、出栈的总结：
http://t.csdn.cn/4WXCO
调用父类构造器
子类不会获得父类的构造器，但是可以调用父类构造器的初始化代码，类似于重载。
通过 super 来调用父类构造器的初始化过程。
super 调用必须出现在执行体的第一行，且this 调用和 super 调用不会同时出现。
当调用子类的初始化构造器时，会先执行父类构造器，父类构造器会继续上溯到它的父类构造器，所以最先执行的是 java.lang.Object 类的构造器。（Object 类是所有类的父类或者是间接父类）
调用关系如下面的代码：
package com.ittht.day05;
class Creature{
public Creature(){
System.out.println("无参");
}
}
class Animal extends Creature{
public Animal(String name){
System.out.println("有一个参");
}
public Animal(String name,int age){
this(name);
System.out.println("有两个参");
}
}
public class Wolf extends Animal{
public Wolf(){
super("apple",5);
System.out.println("wolf无参");
}
public static void main(String[] args) {
new Wolf();
/*会输出"无参
有两个参
wolf无参“
*/
}
}
多态
编译时类型和运行时类型不同，有可能发生多态。
编译时类型是父类，运行是类型是子类，此时该方法行为总是表现为子类的行为特征，但是父类不存在的方法变量不能调用，会编译错误。
package com.ittht.day05;
class BaseClassOne{
public int book=10;
public void base(){
System.out.println("父类的普通方法");
}
public void test(){
System.out.println("父类被子类覆盖的方法");
}
}
public class Class extends BaseClassOne{
public String book="讲义";
public void sub(){
System.out.println("子类的普通方法");
}
public void test(){
System.out.println("覆盖父类的方法");
}
public static void main(String[] args) {
//编译方法和运行方法都是BaseClass的实例
BaseClassOne Bcl=new BaseClassOne();
System.out.println(Bcl.book);//10
Bcl.test();//父类的普通方法
Bcl.base();//父类被子类覆盖的方法
//编译方法和运行方法都是Class的实例
Class C=new Class();
System.out.println(C.book);//讲义
C.sub();//子类的普通方法
C.test();//覆盖父类的方法
//多态发生
//编译方法和运行方法不同
BaseClassOne tc =new Class();
System.out.println(tc.book);//10
tc.base();//父类的普通方法
tc.test();//覆盖父类的方法
//tc.sub();/*编译会出现错误，BaseClassOne没有提供sub方法*/
}
}
引用变量的强制类型转换
基本类型之间可以在数值间转换，但数值类型和布尔类型不能转换；
引用类型的转换只能在具有继承关系的两个类型之间运行（编译时类型是子类类型，运行时类型为子=父类类型），两个没有任何继承关系的类型不能进行类型转换。
对于 valueOf（） 的方法：
package com.ittht.day05;
public class ConversionTest {
public static void main(String[] args) {
double num=2.66;
long NUM=(long)num;
System.out.println(NUM);
int in=5;
//boolean on=(boolean)in;/*在数值和布尔类型间不能转换，所以会出错*/
Object object ="Hello";
String str=(String)object;
System.out.println(str);
Object object1=Integer.valueOf(5);
//Object和Integer存在继承关系
//String str1=(String)object1;
}
}
instanceof 运算符
instanceof 运算符前面的操作数的编译时类型要么与后面的类的相同，要么与后面的类具有父子继承关系，否则会编译错误。
package com.ittht.day05;
public class Instanceof {
public static void main(String[] args) {
Object hello="hello";
//hello是Object的实例，返回true
System.out.println(hello instanceof Object);
//hello的实际类型是String
System.out.println(hello instanceof String);
//Math与Object存在继承关系，但是返回false
System.out.println(hello instanceof Math);
//String实现了Comparable的借口，返回true
System.out.println(hello instanceof Comparable);
}
}
组合复用
对于继承，子类可以直接活动父类的 public 方法，程序使用子类时，可以直接访问该子类从父类继承到的方法；
组合是把旧类对象作为新类的成员变量组合起来，允许在新类里访问该子类从父类继承到的方法。
package com.ittht.day05;
class Animal{
public void beat(){
System.out.println("心脏跳动");
}
public void breathe(){
beat();
System.out.println("吸一口气，呼一口气");
}
}
class Wolf extends Animal{
public void run(){
breathe();//继承父类的breathe方法
System.out.println("跑");
}
}
class Bird extends Animal{
public void fly(){
breathe();//
System.out.println("飞");
}
}
public class InheritTest {
public static void main(String[] args) {
Wolf w=new Wolf();
w.breathe();
w.run();
Bird b=new Bird();
b.fly();
b.breathe();
}
}
