Java入门——抽象类和接口的基本概念

Java入门——抽象类和接口的基本概念

---

本blog内容：

1. 抽象类的基本概念（重点）
2. 接口的基本概念（重点）
3. 对象的多态性（重点）
4. instanceof关键字

---

开始本blog时间：

2016-09-16   16:21:09

---

 抽象类的基本概念（重点）　

　　包含一个抽象方法的类一定是抽象类

　　抽象类和抽象方法都要使用abstract关键字定义

　　抽象方法只需要声明，不需要实现

　　抽象类必须被继承，子类必须复写全部抽象方法

　　

package Sep13;

public class AbstractClass {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        B b=new B();
        b.print();
    }

}
abstract class A{//定义抽象类
    public static final String FLAG="CHINA";
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public abstract void print();//若在接口中可以省略abstract关键字
}
class B extends A{//继承抽象类
    public void print(){
        System.out.println("flag="+FLAG);
        System.out.println("姓名="+super.getName());
        
    }
}

flag=CHINA
姓名=null

---

接口的基本概念（重点）

　　是一种特殊的类，是由全局常量和公共的抽象方法（必须是public，可以省略）组成的。一个类可以实现多个接口，实际上也就摆脱了Java单继承的限制。

1：类实现接口
    class 类 implements 接口A,接口B{  
}
2：继承抽象类实现接口
    class 子类 extends 抽象类 implements 接口A，接口B，{
}
3：接口的继承
    interface 子接口 extends 父接口A，父接口B{}

---

对象的多态性

　　（1）方法的重载与覆写

　　（2）对象的多态性

对象向上转型：父类 父类对象 =子类实例（自动完成）
对象向下转型：子类 子类对象=（子类）父类实例

public class Wine {
    public void fun1(){
        System.out.println("Wine 的Fun.....");
        fun2();
    }
    
    public void fun2(){
        System.out.println("Wine 的Fun2...");
    }
}

public class JNC extends Wine{
    /**
     * @desc 子类重载父类方法
     *        父类中不存在该方法，向上转型后，父类是不能引用该方法的
     * @param a
     * @return void
     */
    public void fun1(String a){
        System.out.println("JNC 的 Fun1...");
        fun2();
    }
    
    /**
     * 子类重写父类方法
     * 指向子类的父类引用调用fun2时，必定是调用该方法
     */
    public void fun2(){
        System.out.println("JNC 的Fun2...");
    }
}

public class Test {
    public static void main(String[] args) {
        Wine a = new JNC();
        a.fun1();
    }
}
-------------------------------------------------
Output:
Wine 的Fun.....
JNC 的Fun2...

参见：http://www.cnblogs.com/chenssy/p/3372798.html

总结：向上转型：执行所指向的子类中的方法。但是前提是父类中定义的该方法，如果父类中没有子类中的方法，则无法引用该方法，换言之：子类重写的方法可以应用，子类重载或重新定义的方法，无法引用。

---

 instanceof关键字

　　在Java中使用instanceof关键字判断一个对象到底是那个类的实例，格式如下所示：

package Sep16;

public class instanceofDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        A a1=new B();//通过向上转型实例化A类对象
        System.out.println("A a1=new B():"+"	"+(a1 instanceof A));
        System.out.println("A a1=new B():"+"	"+(a1 instanceof B));
        A a2=new A();//直接实例化A类对象
        System.out.println("A a2=new A():"+"	"+(a2 instanceof A));
        System.out.println("A a2=new A():"+"	"+(a2 instanceof B));
    }

}
class A{
    public void fun1(){
        System.out.println("A---->public void fun1(){}");
    }
    public void fun2(){
        this.fun1();
    }
}
class B extends A{
    public void fun1(){
        System.out.println("B---->public void fun1(){}");
    }
    public void fun3(){
        System.out.println("B---->public void fun3(){}");
    }
}

A a1=new B():    true
A a1=new B():    true//向上转型的实例化对象即是A类对象，也是B类对象
A a2=new A():    true
A a2=new A():    false