java类

　　java类分为普通类和抽象类，接口，上一节我大概讲了java类的一般格式，今天将抽象类和接口。同时讲一下它们是怎样存储的。

　　最重要的是理解为什么要有抽象和接口，这样学下来你猜不会迷茫，才能更好的去使用，所以多看看我写的关于抽象类和接口的目的。

抽象类

目的

　　为了对代码更好的维护和重用。
　解析：
　　抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。

　　1.因为抽象类不能实例化对象，所以必须要有子类来实现它之后才能使用。这样就可以把一些具有相同属性和方法的组件进行抽象，这样更有利于代码和程序的维护。
　　例子：

　　比如本科和研究生可以抽象成学生，他们有相同的属性和方法。这样当你对其中某个类进行修改时会受到父类的限制，这样就会提醒开发人员有些东西不能进行随意修改，这样可以对比较重要的东西进行统一的限制，也算是一种保护，对维护会有很大的帮助。

　　2.当又有一个具有相似的组件产生时，只需要实现该抽象类就可以获得该抽象类的那些属性和方法。
　　例子：　　

　　比如学校又新产生了专科生这类学生，那么专科生直接继承学生，然后对自己特有的属性和方法进行补充即可。这样对于代码的重用也是很好的体现。

　　所以，Java中抽象类对于代码的维护和重用有很好的帮助，也是Java面向对象的一个重要体现。

定义

　　抽象方法：就 是以abstract修饰的方法，这种方法是不完整的；仅有声明而没有方法体。

      abstract void f();

　　抽象类：包含一个或多个抽象方法称为抽象类。抽象类不能被实例化（be instantiated)，但可以实例化非抽象子类。

抽象类的实现

abstract class A{//定义一个抽象类

    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }

    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

}

抽象类的使用

直接实例化抽象类的对象（错误）

abstract class A{//定义一个抽象类

    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }

    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

}

public class TestDemo {

    public static void main(String[] args) {
        A a = new A();
    }
}

运行：

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Cannot instantiate the type A

    at com.wz.abstractdemo.TestDemo.main(TestDemo.java:14)

　　　从上可知，A是抽象的，无法直接进行实例化操作。为什么不能直接实例化呢？当一个类实例化之后，就意味着这个对象可以调用类中的属性或者放过了，但在抽象类里存在抽象方法，而抽象方法没有方法体，没有方法体就无法进行调用。既然无法进行方法调用的话，又怎么去产生实例化对象呢。

抽象类的使用原则如下

　　（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；

　　（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；

　　（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；

　　（4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；

　　要实现抽象方法就得让子类去继承抽象类，所以就得了解继承，我前面写了一篇关于继承的大家可以看下我写的关于继承的博客http://www.cnblogs.com/yangliguo/p/7481550.html

例子：

abstract class A{//定义一个抽象类

    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }

    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

}
//单继承
class B extends A{//B类是抽象类的子类，是一个普通类

    @Override
    public void print() {//强制要求覆写
        System.out.println("Hello World !");
    }

}
public class TestDemo {

    public static void main(String[] args) {
        A a = new B();//向上造型

        a.fun();//被子类所覆写的过的方法
    }
}

运行结果：

Hello World !

现在就可以清楚的发现：

　　（1）抽象类继承子类里面有明确的方法覆写要求，而普通类可以有选择性的来决定是否需要覆写；

　　（2）抽象类实际上就比普通类多了一些抽象方法而已，其他组成部分和普通类完全一样；

　　（3）普通类对象可以直接实例化，但抽象类的对象必须经过向上转型之后才可以得到。

　　虽然一个类的子类可以去继承任意的一个普通类，可是从开发的实际要求来讲，普通类尽量不要去继承另外一个普通类，而是去继承抽象类。

抽象类的使用限制

（1）抽象类中有构造方法么？
　　由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。

　　并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。

abstract class A{//定义一个抽象类

    public A(){
        System.out.println("*****A类构造方法*****");
    }

    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

}
//单继承
class B extends A{//B类是抽象类的子类，是一个普通类

    public B(){
        System.out.println("*****B类构造方法*****");
    }

    @Override
    public void print() {//强制要求覆写
        System.out.println("Hello World !");
    }

}
public class TestDemo {

    public static void main(String[] args) {
        A a = new B();//向上转型
    }

}

执行结果：

*****A类构造方法*****
*****B类构造方法*****

（2）抽象类可以用final声明么？
不能，因为抽象类必须有子类，而final定义的类不能有子类；

（3）抽象类能否使用static声明？

关于外部抽象类的范例：

static abstract class A{//定义一个抽象类

    public abstract void print();

}

class B extends A{

    public void print(){
        System.out.println("**********");
    }
}
public class TestDemo {

    public static void main(String[] args) {
        A a = new B();//向上转型
        a.print();
    }

}

执行结果

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Illegal modifier for the class A; only public, abstract & final are permitted

    at com.wz.abstractdemo.A.<init>(TestDemo.java:2)
    at com.wz.abstractdemo.B.<init>(TestDemo.java:8)
    at com.wz.abstractdemo.TestDemo.main(TestDemo.java:17)

关于内部抽象类：

abstract class A{//定义一个抽象类

    static abstract class B{//static定义的内部类属于外部类
        public abstract void print();
    }

}

class C extends A.B{

    public void print(){
        System.out.println("**********");
    }
}
public class TestDemo {

    public static void main(String[] args) {
        A.B ab = new C();//向上转型
        ab.print();
    }

}

执行结果：

（4）可以直接调用抽象类中用static声明的方法么？
任何时候，如果要执行类中的static方法的时候，都可以在没有对象的情况下直接调用，对于抽象类也一样。

（5）有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见，目的是对用户隐藏不需要知道的子类。

abstract class A{//定义一个抽象类
    public abstract void print();

    private static class B extends A{//内部抽象类子类

        public void print(){//覆写抽象类的方法
            System.out.println("Hello World !");
        }
    }

    //这个方法不受实例化对象的控制
    public static A getInstance(){
        return new B();
    }

}

public class TestDemo {

    public static void main(String[] args) {

        //此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
        A a = A.getInstance();
        a.print();
    }
}

运行结果：

Hello World !

向上、向下转型（补充）

向上转型：子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口

向下转型：父类引用的对象转换为子类类型称为向下转型。

前者是一个向上转型，Animal dog 引用指向new Dog();子类对象当成父类对象，只能调用父类的成员，如果子类重写了父类的方法就根据这个引用指向调用子类重写的这个方法（这个方法就是覆盖override）。这个调用过程就称为“动态绑定”。
转型需要注意的问题：

向上转型

向上转型时，父类指向子类引用对象会遗失除与父类对象共有的其他方法，也就是在转型过程中，子类的新有的方法都会遗失掉，在编译时，系统会提供找不到方法的错误。实例如下：

public class Animal {

         public void eat(){
             System.out.println("animal eatting...");
         }
}

class Bird extends Animal{

         public void eat(){
              System.out.println("bird eatting...");
         }

         public void fly(){
              System.out.println("bird flying...");
         }
}

class Main{      
         public static void main(String[] args) {
                Animal b=new Bird(); //向上转型
                b.eat();
                b.fly();  //此处提示在Animal中没有定义fly方法。

｝

向下转型

在向下转型过程中，分为两种情况：

情况一：如果父类引用的对象如果引用的是指向的子类对象，那么在向下转型的过程中是安全的。也就是编译是不会出错误的。

情况二：如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误。实例如下：

public class Girl {  
    public void smile(){  
        System.out.println("girl smile()...");  
    }  
}  
class MMGirl extends Girl{  

    @Override  
    public void smile() {  

        System.out.println("MMirl smile sounds sweet...");  
    }  
    public void c(){  
        System.out.println("MMirl c()...");  
    }  
}  
class Main{  

    public static void main(String[] args) {  

        Girl g1=new MMGirl(); //向上转型  
        g1.smile();  

        MMGirl mmg=(MMGirl)g1; //向下转型,编译和运行皆不会出错  
        mmg.smile();  
        mmg.c();  


        Girl g2=new Girl();  
//      MMGirl mmg1=(MMGirl)g2; //不安全的向下转型,编译无错但会运行会出错  
//      mmg1.smile();  
//      mmg1.c();  
/*output: 
* CGirl smile sounds sweet... 
* CGirl smile sounds sweet... 
* CGirl c()... 
* Exception in thread "main" java.lang.ClassCastException: com.wensefu.other1.Girl 
* at com.wensefu.other1.Main.main(Girl.java:36) 
*/  
        if(g2 instanceof MMGirl){  
            MMGirl mmg1=(MMGirl)g2;   
            mmg1.smile();  
            mmg1.c();  
        }  

    }  
} 

总结：

1、父类引用可以指向子类对象，子类引用不能指向父类对象。

2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。

　　 如Father father = new Son();

3、把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。

　　 如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son）father；

　　 其中father前面的（Son）必须添加，进行强制转换。

4、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效

5、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。

接口

定义

　　接口（Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合。接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口其实是一种特殊的抽象类，你会发现接口只是比抽象类少了普通方法，抽象的层次更深一点。所以接下来接口会将的少一点。

　　如果一个类只由抽象方法和全局常量组成，那么这种情况下不会将其定义为一个抽象类。只会定义为一个接口，所以接口严格的来讲属于一个特殊的类，而这个类里面只有抽象方法和全局常量，就连构造方法也没有。

interface A{//定义一个接口

    public static final String MSG = "hello";//全局常量
    public abstract void print();//抽象方法
}

接口的使用

1、由于接口里面存在抽象方法，所以接口对象不能直接使用关键字new进行实例化。接口的使用原则如下：

　　（1）接口必须要有子类，但此时一个子类可以使用implements关键字实现多个接口；

　　（2）接口的子类（如果不是抽象类），那么必须要覆写接口中的全部抽象方法；

　　（3）接口的对象可以利用子类对象的向上转型进行实例化。

2、对于子类而言，除了实现接口外，还可以继承抽象类。若既要继承抽象类，同时还要实现接口的话，使用一下语法格式：

    class 子类 [extends 父类] [implemetns 接口1,接口2,...] {}

　　对于接口，里面的组成只有抽象方法和全局常量，所以很多时候为了书写简单，可以不用写public abstract 或者public static final。并且，接口中的访问权限只有一种：public，即：定义接口方法和全局常量的时候就算没有写上public，那么最终的访问权限也是public，注意不是default。

　　注：接口中默认是public修饰，若子类中没用public修饰，则访问权限变严格了，给子类分配的是更低的访问权限。所以，在定义接口的时候强烈建议在抽象方法前加上public ，子类也加上

3、在Java中，一个抽象类只能继承一个抽象类，但一个接口却可以使用extends关键字同时继承多个接口（但接口不能继承抽象类）。

　从继承关系来说接口的限制比抽象类少：
　　（1）一个抽象类只能继承一个抽象父类，而接口可以继承多个接口；
　　（2）一个子类只能继承一个抽象类，却可以实现多个接口（在Java中，接口的主要功能是解决单继承局限问题）

4、从接口的概念上来讲，接口只能由抽象方法和全局常量组成，但是内部结构是不受概念限制的，正如抽象类中可以定义抽象内部类一样，在接口中也可以定义普通内部类、抽象内部类和内部接口（但从实际的开发来讲，用户自己去定义内部抽象类或内部接口的时候是比较少见的），范例如下，在接口中定义一个抽象内部类：

interface A{
    public void funA();

    abstract class B{//定义一个抽象内部类
        public abstract void funB();
    }
}

接口和抽象类区别

　　在上面比较零碎的写了接口和抽象类的区别，现在总体的写一下他们之间的区别。

（一）语法层次

• 抽象类方式中，抽象类可以拥有任意范围的成员数据，同时也可以拥有自己的非抽象方法，

• 但是接口方式中，它仅能够有静态、不能修改的成员数据（但是我们一般是不会在接口中使用成员数据），同时它所有的方法都必须是抽象的。

• 在某种程度上来说，接口是抽象类的特殊化。

• 对子类而言，它只能继承一个抽象类（这是java为了数据安全而考虑的），但是却可以实现多个接口。

（二）设计层次

1、 抽象层次不同

　　抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。
　　举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。

2、 跨域不同

　　抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分，然后泛化成抽象类，子类继承该父类即可，但是接口不同。实现它的子类可以不存在任何关系，共同之处。
　　例如猫、狗可以抽象成一个动物类抽象类，具备叫的方法。鸟、飞机实现飞Fly接口，具备飞的行为，这里我们总不能将鸟、飞机共用一个父类吧！所以说抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在”is-a” 关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的， 仅仅是实现了接口定义的契约而已。

3、 设计层次不同

　　对于抽象类而言，它是自下而上来设计的，我们要先知道子类才能抽象出父类，而接口则不同，它根本就不需要知道子类的存在，只需要定义一个规则即可，至于什么子类、什么时候怎么实现它一概不知。比如我们只有一个猫类在这里，如果你这是就抽象成一个动物类，是不是设计有点儿过度？我们起码要有两个动物类，猫、狗在这里，我们在抽象他们的共同点形成动物抽象类吧！所以说抽象类往往都是通过重构而来的！但是接口就不同，比如说飞，我们根本就不知道会有什么东西来实现这个飞接口，怎么实现也不得而知，我们要做的就是事前定义好飞的行为接口。所以说抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。

　我介绍的就这些，可能写的不够好但是我把认为比较重要的都写在这里了，感觉写的不错的话给我赞一个，我写了个飞机大战的项目感兴趣的可以去看下网址为http://blog.csdn.net/liveor_die/article/details/69938653。