http://bbs.itheima.com/thread-3077-1-1.html

Android 培训-----我的java笔记，期待与您的交流；

（一）接口

1、接口概述：

1.当一个类中，包含都是抽象方法时，可以将此类声明为"接口"。

2.使用关键字：interface.

3.接口同抽象类一样不能被实例化；

4.一个类实现接口使用关键字：implements

interface  IA

{

        abstract void add();

        abstract void delete();

        abstract void update();

        abstract void find();

}

abstract class B implements IA

{

        //实现一部分方法，那么此类必须是一个抽象类

        public void add(){

        }

}

class C extends B

{

        public void delete(){

        }

        public void update(){

        }

        public void find(){

        }

}

class D implements IA

{

        public void add(){

        }

        public void delete(){

        }

        public void update(){

        }

        public void find(){

        }

}

class Demo

{

        public static void main(String[] args)

        {

                System.out.println("Hello World!");

        }

}

[size=10.5000pt]2、接口的属性

1.成员变量：

                1).接口中的成员变量必须声明为"常量"，必须是公有的.public static final

                2).接口中的成员变量可以不使用关键字public final。如果不使用，系统会自动添加

        2.构造方法：

                接口中没有构造方法；

        3.成员方法：

                1).接口中只能包含抽象方法；

                2).接口中的抽象方法被隐式的声明为：public abstract。如果不加关键字，系统会自动添加

3、接口的作用：

        1.接口就是用来被实现的；

        2.一个类可以同时实现多个接口；语法：class 类名 implements IA,IB

        3.一个类可以同时继承自一个类或抽象类，并且同时实现多个接口；

          一定要先继承，后实现；

          语法：class 类名  extends 父类  implements 接口1,接口2

        4.接口的作用：

          1).Java中的继承只能单继承，不能同时继承自多个类，此时如果想扩充方法，

             可以同过接口实现；

          2).例子：

                 项目经理1：

                 1.规定了一个抽象类，要求大家继承：

                        abstract class AbstracA{

                                void add();

                                void update();

                        }

                 2.我们程序员：继承自这个类

                        class A extends AbstracA{

                                void add(){

                                }

                                void update(){

                                }

                        }

                 项目经理2：

                 1.规定了一个抽象类，要求大家继承：

                        abstract class AbstractB{

                                void delete();

                                void find();

                        }

                 2.我们程序员：继承自这个类：由于此时我们已经继承了一个类，所以无法再继承另一个类。

                        class A extends AbstractA

                 3.项目经理2将抽象类改为接口：

                        interface IB{

                                void delete();

                                void find();

               

4、多态：

        1.继承的多态：      父类类型 变量名 = new 子类类型();

        2.抽象类的多态：        抽象类父类类型 变量名 = new 子类类型();

        3.接口的多态：      接口的类型   变量名 = new 子类类型();

        最长用的是：接口多态；

class C

{

}

class D extends AbstractA

{

        public void show(){

        }

        void fun(){

        }

}

class Demo

{

        public static void main(String[] args)

        {

                IA a = new B();

                a.show();

        //        a.method();//不可以，编译错误，父接口中没有定义method方法

                //向下转型

                B b = (B)a;

                b.method();

                //由于C不是IA的实现类，所以下面代码不可以

        //        IA a2 = new C();

                IA a3 = new D();

                AbstractA a4 = new D();

        }

}

接口的继承：

1.一个接口可以同时"继承"自一个或多个接口，使用继承：extends类：一个类可以继承自一个类或者继承自一个抽象类(单继承)，并且可以同时实现多个接口；

        抽象类：一个抽象类可以继承自一个抽象类(单继承)，并且可以实现多个接口；

        接口：一个接口可以继承自一个，或多个接口(多继承);

interface IA

{

        void show();

}

interface IB

{

        void show();

        void fun();

}

interface IC extends IA,IB//接口继承自接口时，允许多继承。

{

}

class ClassA implements IC

{

        public void show(){

        }

        public void fun(){

        }

}

class Demo

{

        public static void main(String[] args)

        {

                System.out.println("Hello World!");

        }

}

http://bbs.itheima.com/thread-3077-1-1.html

Android 培训-----我的java笔记，期待与您的交流；

（一）接口

1、接口概述：

1.当一个类中，包含都是抽象方法时，可以将此类声明为"接口"。

2.使用关键字：interface.

3.接口同抽象类一样不能被实例化；

4.一个类实现接口使用关键字：implements

interface  IA

{

        abstract void add();

        abstract void delete();

        abstract void update();

        abstract void find();

}

abstract class B implements IA

{

        //实现一部分方法，那么此类必须是一个抽象类

        public void add(){

        }

}

class C extends B

{

        public void delete(){

        }

        public void update(){

        }

        public void find(){

        }

}

class D implements IA

{

        public void add(){

        }

        public void delete(){

        }

        public void update(){

        }

        public void find(){

        }

}

class Demo

{

        public static void main(String[] args)

        {

                System.out.println("Hello World!");

        }

}

[size=10.5000pt]2、接口的属性

1.成员变量：

                1).接口中的成员变量必须声明为"常量"，必须是公有的.public static final

                2).接口中的成员变量可以不使用关键字public final。如果不使用，系统会自动添加

        2.构造方法：

                接口中没有构造方法；

        3.成员方法：

                1).接口中只能包含抽象方法；

                2).接口中的抽象方法被隐式的声明为：public abstract。如果不加关键字，系统会自动添加

3、接口的作用：

        1.接口就是用来被实现的；

        2.一个类可以同时实现多个接口；语法：class 类名 implements IA,IB

        3.一个类可以同时继承自一个类或抽象类，并且同时实现多个接口；

          一定要先继承，后实现；

          语法：class 类名  extends 父类  implements 接口1,接口2

        4.接口的作用：

          1).Java中的继承只能单继承，不能同时继承自多个类，此时如果想扩充方法，

             可以同过接口实现；

          2).例子：

                 项目经理1：

                 1.规定了一个抽象类，要求大家继承：

                        abstract class AbstracA{

                                void add();

                                void update();

                        }

                 2.我们程序员：继承自这个类

                        class A extends AbstracA{

                                void add(){

                                }

                                void update(){

                                }

                        }

                 项目经理2：

                 1.规定了一个抽象类，要求大家继承：

                        abstract class AbstractB{

                                void delete();

                                void find();

                        }

                 2.我们程序员：继承自这个类：由于此时我们已经继承了一个类，所以无法再继承另一个类。

                        class A extends AbstractA

                 3.项目经理2将抽象类改为接口：

                        interface IB{

                                void delete();

                                void find();

               

4、多态：

        1.继承的多态：      父类类型 变量名 = new 子类类型();

        2.抽象类的多态：        抽象类父类类型 变量名 = new 子类类型();

        3.接口的多态：      接口的类型   变量名 = new 子类类型();

        最长用的是：接口多态；

class C

{

}

class D extends AbstractA

{

        public void show(){

        }

        void fun(){

        }

}

class Demo

{

        public static void main(String[] args)

        {

                IA a = new B();

                a.show();

        //        a.method();//不可以，编译错误，父接口中没有定义method方法

                //向下转型

                B b = (B)a;

                b.method();

                //由于C不是IA的实现类，所以下面代码不可以

        //        IA a2 = new C();

                IA a3 = new D();

                AbstractA a4 = new D();

        }

}

接口的继承：

1.一个接口可以同时"继承"自一个或多个接口，使用继承：extends类：一个类可以继承自一个类或者继承自一个抽象类(单继承)，并且可以同时实现多个接口；

        抽象类：一个抽象类可以继承自一个抽象类(单继承)，并且可以实现多个接口；

        接口：一个接口可以继承自一个，或多个接口(多继承);

interface IA

{

        void show();

}

interface IB

{

        void show();

        void fun();

}

interface IC extends IA,IB//接口继承自接口时，允许多继承。

{

}

class ClassA implements IC

{

        public void show(){

        }

        public void fun(){

        }

}

class Demo

{

        public static void main(String[] args)

        {

                System.out.println("Hello World!");

        }

}